🪅-progaming

[lucid trail]

i know that background anywhere lol

[valid jetty]

because that is a huge refactoring as the codegen depends on things from the custom parser

[hoary sluice]

it lights up the screen white so its a flahbang

[supple whale]

yeah vanta is now a "generic cryptobro website library"

wasnt back then

[lucid trail]

https://tnixc.space flashbang

[supple whale]

and for the most part "europe" is a good enough narrow down

[hoary sluice]

and you probably dont want to tie your parser to a dependency

[supple whale]

since most hires care about "oh not america? nvm then"

[valid jetty]

true i guess

[hoary sluice]

whats wrong with stating ur country

[valid jetty]

why is it moving

[hoary sluice]

unless its the vatican

[supple whale]

nothing!

[valid jetty]

its unsettling lol

[deep mulch]

@valid jetty hiii

[valid jetty]

and the back button doesnt work 😭

evil

theyre just dissapearing lol

[supple whale]

it looks better on shit like https://thaunknown.github.io/?miru

again this was like my 1st or 2nd svelte project ever

[valid jetty]

oh lol i see

[supple whale]

so ideas were there, execution not so much

i think i made this before sveltekit had wide support

so i didnt have a router

yeah sveltekit came out 3 months after i made this site XD

[supple whale]

i juust wanted to check if svelte was better than react

and HOLY was it ever better than react

i switched to svelte exclusively after making that website, i had that good of an experience with it

well and occasionally vue with setup for work

[jade stone]

#cast is fucking insane

[deep mulch]

yop

[valid jetty]

😭

[lucid trail]

i support x as T

[valid jetty]

fine ill do x as T

[hoary sluice]

woo

[deep mulch]

yippee

[hoary sluice]

you should sugar all these #

[hoary sluice]

zootie spawned

[valid jetty]

what sugar would you give #set_allocator(alloc_expr)

[jade stone]

Love

[deep mulch]

setAllocator(allocExpr)

no # required

[valid jetty]

the # is important tho

[deep mulch]

nop

[lucid trail]

#cast(x, T) feel very C# coded to me

[valid jetty]

it tells you that its a compiler builtin

and not a usermade function

[deep mulch]

doesnt matter

[hoary sluice]

but so is alloc t size

we all need to create projects in elle so it gets added to github

[placid cape]

i prefer @ for compiler builtin

like zig

but i understand you dont use it because of annotations

[hoary sluice]

__builtin_set_allocator

[placid cape]

💀

[hoary sluice]

nix moment

[dawn ledge]

you'll need atleast 100

[dawn ledge]

the entirely of elle is like this

__internal_ spam

[valid jetty]

no mangling moment

[deep mulch]

guhh internal keyword when

[valid jetty]

there is !pub but thats not applicable to the link-time codegen

essentially all of elle is extern C which means there can be collisions just like in C

thats why you can namespace things

but things arent namespaced for you

@hoary sluice how do you differentiate (x as void *) * y and (x as void) * (* y)

i dont think as is a good idea

[hoary sluice]

how is (x as void) valid syntax

[valid jetty]

ignore that its void

what should the parser determine that x as T * *y is: (x as T *) * (y) or (x as T) * (*y)?

[valid jetty]

lol i meant the parser wont be able to always differentiate it without brackets because either expression here is valid without brackets

[hoary sluice]

(x as T*) * (y) = cast x as T* and multiply by y

(x as T) * (*y) = cast x as T and multiply by y*

[hoary sluice]

oh

[valid jetty]

but what if i write x as T * * y

what does the parser see it as

or well, what should it see it as

[hoary sluice]

it should see it as cast x as T* and multiply by y

you just put precedence

[valid jetty]

but what if you actually wanted to do (x as T) * (*y) cast x to T and multiply by the deref of y

its still ambiguous just in a different way to (T)x

[hoary sluice]

then write (x as T) * (*y)

[valid jetty]

😭

[hoary sluice]

this is why using the same symbol as multiplication for pointers is a bad idea

use @ for pointers (dont)

use deg symbol for pointers

[valid jetty]

@dawn ledge @deep mulch @lucid trail what do you guys think about this

[hoary sluice]

im serious

[valid jetty]

deg symbol is unicode isnt it

[hoary sluice]

using @ wouldnt actually be a bad idea would it

[valid jetty]

how do i even type that on my keyboard

[valid jetty]

its already used for attributes

[dawn ledge]

operator precedence

[hoary sluice]

shift ^ on qwertz idk qwerty

[hoary sluice]

^

[valid jetty]

thats not deg thats just caret

[valid jetty]

its ambiguous when read tho

[dawn ledge]

or better use kyuuhachi's suggestion

<Type>T

<Type>(T)

[hoary sluice]

i dont think us qwerty has deg

use ^ for pointers

[dawn ledge]

[hoary sluice]

oh wait thats xor

use words for binary ops and ~ for pointers

[dawn ledge]

please do not try to redefine common operators

[hoary sluice]

why not

[dawn ledge]

bad dx

[valid jetty]

that can interfere with generics and the < and > binops unfortunately

[dawn ledge]

(Type)T

[valid jetty]

😭

why does casting need special sugar why cant it just be #cast(x, T)

"its ugly with many on a single line" YEAH like (T)x isnt ugly on a single line

*(int *)(void *)((void *)(*x) * (uintptr_t **)y)
``` yeah readable

[hoary sluice]

when are you ever going to cast x into T and multiply it by *y on the same line

this is not common enough to worry about making convenient to type

[dense sand]

@placid cape i cant write my thesis in new computer modern 😭

[dawn ledge]

im not against it

[supple whale]

yeah thats normal

every uni forces some old sherif font

[dense sand]

i wanted to use typst 😭

[dense sand]

because the template is word 💀

[supple whale]

you could for code blocks

since those count as "attachments" or "images"

or "objects" simply

[hoary sluice]

theres no way they can do that wtf

make ur entire thesis an attachment lol

what are they gonna do

[supple whale]

then ud fail

because you wouldnt meet the page and word count

[valid jetty]

x as u64 * * num_of_u64s
#cast(x, u64 *) * num_of_u64s

[supple whale]

thank you for coming to my ted talk

[dawn ledge]

font is auxilliary
why do you even care about what they enforce
just work on the content dude

[hoary sluice]

you need to put () in #cast anyways so its still easier to write as

[dense sand]

why are they putting tutorial in word 😭 they think word is the only thing this can be made in 😭

[dense sand]

lc.tr

[visual shell]

-# <:i:1323844562875187291> Translated from 🇺🇸 English to 🇺🇸 English • Google Translate
why are they putting tutorial in word 😭 they think word is the only thing this can be made in 😭

[hoary sluice]

because times new roman looks ugly

[dense sand]

wow

[dawn ledge]

ocrtr

[dawn ledge]

skill issue

[dense sand]

ocrtr

what

[valid jetty]

yeah but the () ensures you will always use () and there can never be any ambiguity

[dawn ledge]

add lc.

also pissbot supports editing

[dense sand]

lc.ocrtr

[visual shell]

-# <:i:1336065711323222119> ​ 🇨🇿  Czech   ​ ​ ​​<:i:1336064835691090043> ​ ​ ​ ​🇺🇸  English  

1.9 Figures, tables and equations
A caption for a figure or table is inserted by right-clicking on the object
and selecting Insert caption. The object type (Tab. or Fig.) is then selected.```

Google Lens • labsCore

[hoary sluice]

our teacher also was like guys pay attention you need this and then gave a tutorial on how to use zotero in word

not being able to understand czech in 2025 is crazy

[dense sand]

why did they give example with new computer modern font 😭

[hoary sluice]

do u have to write the thesis in czech?

[dense sand]

yes

[hoary sluice]

surely they cant force you to

[dawn ledge]

font and language aint getting that degree for you

😭

[hoary sluice]

language is pretty important

[dense sand]

i will ask next year how much enforced is it

[hoary sluice]

theres no way i wouldve written mine in german

[dense sand]

whoever uses typst here, do you self compile or use their ide?

[dawn ledge]

self compile for distribution

nvim plugin + script when writing

[dense sand]

is there any structure i should be using?

[hoary sluice]

i have nvim with autosave tiled with an evince pdf which auto reloads and typst running in tmux so i can ctrl b + L to see errors

[dawn ledge]

wdym by structure

i just usually categorize my files by relevance and an .assets folder for attachments

[hoary sluice]

https://github.com/eagely/voice-docs

[dawn ledge]

TEX

jumpsace

[lucid trail]

why is that kerning so weird

[hoary sluice]

sorry for not knowing about typst in september

[dense sand]

its a pasted image 😭 idk

[hoary sluice]

most of it is plain text anyways

and code blocks

how do you cite in typst

theres probably a library right

[dawn ledge]

typst supports bib

https://typst.app/docs/reference/model/bibliography/

As soon as you add a bibliography somewhere in your document, you can start citing things with reference syntax (@key) or explicit calls to the citation function (#cite(<key>)). The bibliography will only show entries for works that were referenced in the document.

[hoary sluice]

types as functions

hmm

sounds awesome

[valid jetty]

but that can actually also be ambiguous with tuples i just realized

[hoary sluice]

someone probably already wrote a phd thesis about that

[valid jetty]

(i32, i32)(x)

[hoary sluice]

whats ambiguous about that

[valid jetty]

it could be interpreted as a parenthesized expression

[dawn ledge]

.as<T> is insane

[hoary sluice]

wdym could be

i dont see how it can be any valid expression other than cast

[dawn ledge]

function call

duh

[valid jetty]

even then pointers are also ambiguous lol

T *(x) looks like x multiplied by T

[dawn ledge]

just do #cast(T, x) and call it a day

no better option

better than mem::transmute

[hoary sluice]

didnt know you could do

fn (i32, i32)();
(i32, i32)(x)

[dawn ledge]

(foo)(x)

[hoary sluice]

yea whats ambiguous about this

foo is either a function or a type

[dawn ledge]

quit it

[hoary sluice]

???

[dawn ledge]

just do #cast

[valid jetty]

the thing with something like this or .asT or .toT or as.T is that i would either need to make a function for casting from one type to every other possible type or make syntax sugar which looks exactly like existing syntax but actually is a compiler builtin

and i dont really wanna do either

[valid jetty]

yeah ok

[hoary sluice]

theres nothing wrong with T(x)

#cast is annoying to write

[valid jetty]

.

[dawn ledge]

then dont?

dont write in elle

[hoary sluice]

but you cant multiply by a type

[dawn ledge]

parsing ambiguity

[hoary sluice]

discouraging people from using a language is not why a language is made

[valid jetty]

you cant but that would require a parser hack to work and its ambiguous (was the idea)

[hoary sluice]

which can be resolved

[deep mulch]

rosinga

[dawn ledge]

you dont know if T is a type or a variable ident at parse time

[hoary sluice]

so then parse it as a function call

[valid jetty]

zig has @Tcast

[dawn ledge]

T *(x) would be parsed as a multiplication node

[deep mulch]

what is happening here

[hoary sluice]

were discussing what version would be the best in the language not the easiest to write a parser for, this isnt 1950

[dawn ledge]

😭

[valid jetty]

you voted for as T, the first one is cast x to T* and multiply by y, the second is cast x to T and multiply by the deref of y

[dawn ledge]

why are vencord members so hard to talk to

[valid jetty]

both are plausible, both could be viable, you have no idea which one it is without brackets

[hoary sluice]

you have boomer mentality

[deep mulch]

i thought & was deref

[dawn ledge]

fym boomer mentality

[valid jetty]

& is "take the addr of"

[deep mulch]

guh

[valid jetty]

@deep mulch

[dawn ledge]

zooter minky will deref with &

[hoary sluice]

literally 1972

how to make a language where i have to spend the least effort possible writing a parser

[valid jetty]

how to make a langauge where it looks like im multiplying by a type

[deep mulch]

rosie making rust 2

[hoary sluice]

how to make a language where using pointers looks like multiplication

[dawn ledge]

i'll give you one better
skimming through code
what if i have a var T
and someone writes T *(x) intending it for a multiply
now am i supposed to sit and think if its a cast or multiplication

[royal nymph]

go does that

[dawn ledge]

????

[valid jetty]

which is an established syntax lol

[dawn ledge]

thats like every lang using pointers

[valid jetty]

wait good point actually

thats a really good point

[hoary sluice]

that doesnt mean rosie has to do it

[valid jetty]

i didnt even think of that

[deep mulch]

multiply should only happen if there's a space after the operator

[royal nymph]

you will use golang type assertions: ```go
thing.(SomeType)

[jade stone]

INSANE

id rather learn rust over go

[hoary sluice]

force types to be PascalCase and variables snake_case

[dawn ledge]

thats just bad

[dawn ledge]

forcing stylistic choices is so bad

[valid jetty]

actually not a bad idea because now i can always expect that after a . there is a type or identifier

[hoary sluice]

not force but if someone writes var T and then reads T*(x) as a type cast not a multiplication thats their problem

[jade stone]

yop

someone turn off the default rust naming conventions warnings

[hoary sluice]

cause they called the variable that

[valid jetty]

however what do you make of x.(Foo<Bar *>)

[royal nymph]

/run ```go
package main

func main() {
var x interface{} = 7
sum := x.(int) + x.(int)
println(sum)
}

[rugged berry]

@royal nymph I only received go(1.16.2) error output

14

[deep mulch]

I hate that

[dawn ledge]

#![ignore(...)] loves you

[royal nymph]

bot has ancient go okay

bot is legit like 10 go versions outdated

[hoary sluice]

however i do think that forcing style choices is a good thing

[valid jetty]

@royal nymph ?

[deep mulch]

int(x) or (int) x or x as int

[dawn ledge]

your idea wont work with this eagly

[valid jetty]

i think eagely was joking with this

because thats evil

[hoary sluice]

pick a naming style and force everyone to use it because most people are going to use it anyways and you remove the small number of people that confuse erevyone

[hoary sluice]

i was but now im not

[dawn ledge]

kodetoad hates you

[hoary sluice]

make i128 builtin

[deep mulch]

i256

[hoary sluice]

Int128

allow i\d+

[dawn ledge]

i1024

i love adding hacks to my parser to support ambiguous syntax

[valid jetty]

i128 is not a type in qbe, if i made it a builtin that means i would literally need to make a struct and all the binop overloads via manual ast node creation in the parser

which i do already but it sucks

[hoary sluice]

then dont make i128 and make BigInt instead

[deep mulch]

HugeInt
GiganticInt
MassiveInt

[dawn ledge]

i8 in question:

[hoary sluice]

where do you need i128

[deep mulch]

add i2

[dawn ledge]

simd

[valid jetty]

things like this

[hoary sluice]

i might do Int64 Float64 naming

[valid jetty]

BigInt exists but sometimes you just want a bigger int

[hoary sluice]

or is that evil

bigint is literally infinite

[valid jetty]

no i wanted to do that when i first dreamed up elle syntax

[dawn ledge]

more bits dont hurt

[hoary sluice]

this is something java would make

[deep mulch]

yop

[hoary sluice]

also

obligatory you know what else is massive

[deep mulch]

yes

[valid jetty]

its not its as big as 2^64^(2^64) bits

[deep mulch]

@valid jetty add long long to elle

[valid jetty]

if you make an array of i64s which has a max len of u64

[hoary sluice]

java bigint is a base 65536 array of digits idk what urs is

[valid jetty]

husk

[dawn ledge]

be like zig

[hoary sluice]

you can always add another array when it overflows

[valid jetty]

elle one is a u8[]

[dawn ledge]

variable size integers u8 padded

[valid jetty]

naive approach

[deep mulch]

@valid jetty add unsigned long long int

[valid jetty]

u64

exists

[deep mulch]

boringg

[hoary sluice]

make long thats 64 on linux and 32 on windows

[valid jetty]

contrary to popular belief long int is NOT a 64 bit int

[leaden crater]

regular chanel is pretty chill

[hoary sluice]

too many windows users in progaming

[leaden crater]

ugh you again

slop os

[hoary sluice]

see what i mean

[dawn ledge]

long long long long long

[hoary sluice]

[valid jetty]

elle can only compile on 64 bit and theres no usize type in qbe but when it becomes a thing, i will have to change elle to make it work

[hoary sluice]

dont you have to change elle to do literally anything

i misread that

[valid jetty]

lmao

usually no

almost every elle program ive wanted to write has been writable without changes to the compiler

only things missing in stdlib

[dawn ledge]

nostd!

elle on embedded

[valid jetty]

exists

but its a compilation flag

[dawn ledge]

yeah i saw

nogc is my favorite

[valid jetty]

all it does is no longer link with -lelle

[deep mulch]

Elle for embedded devices when

[hoary sluice]

when elle on esp32

[valid jetty]

that one uses the arena alloc by default xd

[hoary sluice]

would actually be awesome

[deep mulch]

elle for arduino

make elle for stm chips

[hoary sluice]

if you pivot to embedded support and rewrite the arduino framework in elle you will have massive adoption because arduino cpp is garbage and elle isnt

[dawn ledge]

hop on llvm, running elle on AMDGPU

[deep mulch]

elle on attiny85

[leaden crater]

int main() {
    long long long long long long long long long long long long long long long long 
    long long long long long long long long long long long long long long long long 
    long long long long long long long long long long long long long long long long 
    long long long long long long long long long long long long long long long long 
    long long long long long long long long long long long long long long long long 
    long long long long long long long long long long long long long long long long 
    long long long long long long long long long long long long long long long long 
    long long long long long long long long long long long long long long long long x = 1;

}

[hoary sluice]

elle on 4 bit minecraft computer

[valid jetty]

you can technically go fully back to C style programming by using nogc and then in main func #set_allocator(HeapAllocator::new()

now #alloc will call malloc, #realloc will call realloc, #free will call free, etc

[valid jetty]

but the stdlib is kinda useless with it because none of it is manually freed

[dawn ledge]

rust embedded crates:

[valid jetty]

so youd leak a lot of memory

[hoary sluice]

not enough support

[valid jetty]

using arenas you dont leak because its all freed by the compiler at the end

[leaden crater]

typedef unsigned long i2048[32];

[jade stone]

yeah, let me do that on every single variable function and struct field I make

[hoary sluice]

they forked the rust compiler and rewrote it for xtensa and its still terrible

[deep mulch]

@valid jetty hiii

extralong long

[dawn ledge]

the ! in #! applies it for everything

[hoary sluice]

or just write normal rust

[leaden crater]

should i make infinitely long long long long ... in my language

[hoary sluice]

Integer32

[leaden crater]

@valid jetty

[fleet cedar]

Rather, it applies it to the parent block (usually module)

[dawn ledge]

do it at the root and now its global

boom

[valid jetty]

use std/allocators/heap;

fn main() {
    #set_allocator(HeapAllocator::new()); // back to C we go, but with nicer semantics :3333

    x := #alloc(i32); // does (i32 *)malloc(#size(i32)) internally
    defer #free(x); // deferring :33333
}

compiled with ellec main.le --nogc
@dawn ledge love?

[hoary sluice]

let
  define i Integer32 = 17
  define str CharacterArray = "hello"
in
foo = str + i

[valid jetty]

you said you wanted icypeas to be fast to use for aoc

good luck typing CharacterArray every time

lol

[hoary sluice]

i am not going to seriously call strings CharacterArray

[dawn ledge]

i feel like writing the codegen backend myself and also not depending on libc

[hoary sluice]

although it would be funny

[jade stone]

That's not the point. Forcing stylistic choices like what Go does and rusts default warnings does it is just bad.

[valid jetty]

i depend on libc because i dont have to write code in another language for the stdlib (like asm or C)

[jade stone]

I hate snake case so I don't want to write code with it

[dawn ledge]

writing asm is fun

atleast for me

[hoary sluice]

i dont care im going to do it anyways

[valid jetty]

yeah but not so fun when you have to rewrite networking code in asm from scratch with raw syscalls

[hoary sluice]

will you be happy if i force camel case

[valid jetty]

networking in C is hard enough

[dawn ledge]

well fwiw unlike go rust's are just warnings and the program compiles and runs

[hoary sluice]

rosie you should actually rewrite arduino in elle

it will get you any job you want

[dawn ledge]

i was actually looking at syscalls a day ago
very fun

i also like networking so

i love writing binary formats

[hoary sluice]

elleduino

[valid jetty]

ok so #cast ?

[dawn ledge]

yes

[valid jetty]

alright

[hoary sluice]

T(x)

[valid jetty]

evil

maybe one day

[hoary sluice]

does elle have macros

[valid jetty]

there are ways to do most things youd want from macros

[hoary sluice]

can i use T(x) instead of #cast

[valid jetty]

😭

do it in icypeas

[hoary sluice]

im currently thinking of a way to make types be functions

qbe with no types 1 argument curryable functions first

[dawn ledge]

raaaaaaaah

[valid jetty]

const x = y; at the top level will make a thing which is ran every time you reference the const

so like if you make it const my_thing = [i32;];
if i do

my_thing[0] = 1;
``` and then ```rs
$dbg(my_thing.len());
``` it will be 0

maybe const is a bad name

should be inline or something

but it works almost exactly like a define macro lol

[dawn ledge]

no ast manipulation :(

[valid jetty]

wdym

[dawn ledge]

rust procmacros

take in ast -> spit out ast

[valid jetty]

no that doesnt really exist atm lol not even regular macros like in rust exist yet

[valid jetty]

ya i know what a procmacro is

[dawn ledge]

[valid jetty]

actually probably not that bad 😭

at least for a prototype

[hoary sluice]

can you explain this in english

[valid jetty]

imagine #define my_thing ((i32 *)malloc(sizeof(i32) * 4))

[dawn ledge]

casual IBM Z

is that even used

[valid jetty]

its similar semantically except it inserts the AST and not the source code

[hoary sluice]

what does it have to do with the length being 0

[valid jetty]

when you do my_thing the second time you get a new array

just like in c if you call the macro twice you get a new allocation

[hoary sluice]

ohh

[jade stone]

yeah that's why I specifically mentioned default warnings instead of what go has where you know it's just forced

But I still feel like default warnings are extremely bad.

[dawn ledge]

also go's refusal to compile on unused variables is insane

[jade stone]

warnings should be for things that actually matter

[valid jetty]

it expands to ```rs
fn my_thing() {
return [i32;];
}

fn main() {
my_thing()[0] = 123;
$dbg(my_thing().len());
}

```rs
fn main() {
    [i32;][0] = 123;
    $dbg([i32;].len();
}

[hoary sluice]

make them default warnings and implement Wnoerror format

[jade stone]

I tried to learn go, but the module system and the forced naming conventions made me stop very quicky

[dawn ledge]

good

dont learn

i used to write go

[jade stone]

The module system for Go is legitimately so fucking confusing.

[hoary sluice]

why does it do that

is that intended

[valid jetty]

does go have generics yet

[jade stone]

I cannot understand it for the life of me.

[valid jetty]

yes

its intended

[dawn ledge]

go community has strong opinions over the project stucture

and my answer to that is FUCK YOU

[valid jetty]

8 space ident in go sucks

[jade stone]

Yop

[dawn ledge]

you dont get to decide my preference on how i wan my code to be structured

I am writing MY code NOT YOU

[valid jetty]

if its even 8 space it might be more

idk

i remember it was definitely more than 4

[hoary sluice]

is that real???

why is 8 space the default in vim who made that

[dawn ledge]

i understand formatting and structure policies project wise
for example if i am contributing to project xyz and they need all types to be defined in a separate file thats perfectly acceptable

but if the language itself forces me to have all types in a separate files, now thats a completely different matter

[valid jetty]

someone should make the ultimate customizable language

[hoary sluice]

rust:

lisp:

[valid jetty]

the function keyword is f[unction]?

fuc x()

[dawn ledge]

any language with macros is customizable to hell and back

[valid jetty]

fuction x()

[dawn ledge]

take rust rsx for example

[hoary sluice]

dreamberd

[valid jetty]

f x()

[hoary sluice]

i think nunoitfc is a valid keyword in dreamberd

any arrangement of function

[valid jetty]

my favourite dreamberd feature is negative lifetimes

[hoary sluice]

omg nino x()

[dawn ledge]

dremberd is a literal meme

[hoary sluice]

my favorite dreamberd feature is worldwide constants

[hoary sluice]

the sky is blue

[valid jetty]

print(x)
const let let x: i32' -1 = malloc(i32)

[dawn ledge]

no the sky is red

[hoary sluice]

const const const PI = 3 now PI is 3 for everyone forever

[dawn ledge]

actually the sky doesnt have a color
youre just looking at filtered light from the sun!

[hoary sluice]

so color

[dawn ledge]

nuh uh

[valid jetty]

LMAOOOOOO

THIS IS THE DREAMBERD REO

THEYRE CALLED GULF OF MEXICO NOW

HELP

[hoary sluice]

We also banned the import function and any function that tests for equality. Oh and we've got plans to round up 30,000 people and put them into a concentration camp.

lol

[dawn ledge]

duuuudeeee where is the codegen code located in gcc

this is literal bloat

[valid jetty]

you will never find it lol

g*u software

[hoary sluice]

me when the app is so abstracted that it literally doesnt do what its supposed to do but still somehow does

https://github.com/EnterpriseQualityCoding/FizzBuzzEnterpriseEdition

[dawn ledge]

https://arxiv.org/abs/2011.13127 interesting

[dawn ledge]

java

checksout

[royal nymph]

corny

[dawn ledge]

🌽

[valid jetty]

@hoary sluice

[hoary sluice]

whats wrong with that

scores[PI]

[supple whale]

[hoary sluice]

oh wait

[dawn ledge]

arr[0.00000000000000000001] my beloved

[hoary sluice]

PI Is 3 because its a const const const i defined earlier

[valid jetty]

😭

[dawn ledge]

LLVM consists of over 20 million lines of code
😭

[deep mulch]

elle will be longer

40 million lines

[dawn ledge]

add cranelift backend to ellee

hop off qbe

!

(joking btw)

[valid jetty]

ok WHICH ONE

[hoary sluice]

T(x)

[dawn ledge]

b

type first

[hoary sluice]

evil

actually evil

[lucid trail]

#cast(x as T)

[valid jetty]

TIL that everyone has an entirely different opinion

[valid jetty]

LMAO

[hoary sluice]

actually a good idea tho

[valid jetty]

at that point might aswell #as(x, T)

[hoary sluice]

or still just do some variation of as or .as<> or smth

if u want to multiply by pointers just use ()

[valid jetty]

@dawn ledge #cast(T, x) or #as(T, x)

[hoary sluice]

#as is evil

it should be infix

[dawn ledge]

#as just to piss eagely off

[hoary sluice]

make .as a function on everything

[valid jetty]

what if i swapped @ and #

[hoary sluice]

x.as(T)

[valid jetty]

fn main() #fmt #alias(foo::bar) {
    x := @alloc(i32);
    return @cast(i64 *, x);
}

[hoary sluice]

no this is genuinely evil

[valid jetty]

what it would be right now

fn main() @fmt @alias(foo::bar) {
    x := #alloc(i32);
    return #cast(i64 *, x);
}

[hoary sluice]

less evil (still evil because #cast)

[valid jetty]

@ for builtins reminds me a lot of zig lol

[hoary sluice]

idk if qbe is great for fp

https://github.com/grin-compiler/grin

unmaintained

do i compile to haskell

[dawn ledge]

We try only to add languages once they have some usage on GitHub. In most cases we prefer that each new file extension be in use in at least 200 unique :user/:repo repositories before supporting them in Linguist (but see #5756 for a temporary change in the criteria).
get 300 vencord members to use elle

[dawn ledge]

i like this

[hoary sluice]

how did you read 200 and immediately forget

[dawn ledge]

i intentionally wrote 300

surplus

more never hurts

[still jolt]

unless it's more bugs ​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​

[valid jetty]

it took me forever to find this bug but

fn main() {
    x := i32;
}
``` this compiled for the longest time lol

better

[deep mulch]

EOF

end of file?

[valid jetty]

well usually yes but i just say EOF for end of token stream

the part in between := and ; is a new token stream

[deep mulch]

just say that then

[valid jetty]

cursed but its an old parser

[deep mulch]

silly

[valid jetty]

true

[fleet cedar]

When I do token subtrees, I use the corresponding terminator char for eof message

Which is to say, ) ] or }

[valid jetty]

wdym like

[fleet cedar]

Or \0, since I implicitly wrap the whole stream in a pair of \0 tokens to simplify many checks

[valid jetty]

expected foo found ;

?

[fleet cedar]

Yep

End of input just means it found the delimiter

[valid jetty]

i can do that but that means i have to pass down the delimiter through the parser recursion

[fleet cedar]

That's no issue for me, my cursor is just ```rs
#[derive(Clone)]
pub struct Cursor<'a> {
tokens: &'a [RawToken],
range: Range<usize>,
pos: usize,
}

[hoary sluice]

expected foo found

[valid jetty]

oh interesting i should do that

i clone the tokens

all of that debating and i STILL ended up with #cast 😭

[valid jetty]

btw the thing you mentioned earlier with <T>x is flawed in that it can be misinterpreted as a binop or generics

[valid jetty]

i have a poll here of different options

[lucid trail]

T.from(x)

T#from(x)

[lavish frigate]

ai reference

[valid jetty]

@lucid trail

same issue with T.from

[lucid trail]

ic

[valid jetty]

this syntax isnt really anywhere else in the language so it would look kinda weird

[lucid trail]

just realized it’s basically the same as as

[valid jetty]

that too but imagine someone first discovering the language

"how do i cast"

"oh i write the type, then #, then from(my thing) that makes.. absolutely no sense"

if its (T)x you could argue its C-like, if its #cast you could argue its consistent with #size and stuff like that

[deep mulch]

@valid jettyhttps://en.wikipedia.org/wiki/Goertzel_algorithm reAd

[valid jetty]

hold on im refactoring the entirety of elle to use #cast

[deep mulch]

husk

[valid jetty]

ive been meaning to get rid of (T)x anyway because it fails to parse specific expressions lol

(T)x casting when tuple types exist is a pain

[winged mantle]

#static_cast

[jade stone]

ok c++ dev

tbh i dont understand c++ casts at all lol

i just always end up doing c style ones

[leaden crater]

cpp is weird

i've been doing it for 4mo and it feels really boring

even lua is more interesting

[jade stone]

lua and go are on the top of my list of langs i hate

[winged mantle]

c++ is really interesting

because it goes so deep

[leaden crater]

maybe interesting but its so boring

[winged mantle]

after years i know nothing

[jade stone]

c++ is intresting but i always get confused about when classes are created

[leaden crater]

i want the rust

[deep mulch]

c++ has things

[winged mantle]

should i call this variable WHITESPACE_EATER_LESS_HUNGRY

[jade stone]

insane

[winged mantle]

is it normal to limit whitespace between prefix and command name in case social engineering

dude copy this text

[jade stone]

what is this going to be used in

[winged mantle]

modbot

so is this amazing code https://github.com/TheKodeToad/SquirrelBot/blob/develop/backend/src/bot/plugin/core/commandEngine/parsing/primitiveParser.ts#L156-L193

[pearl stag]

primitiveParser.ts: Lines 156-193

const SECOND = 1000;
const MINUTE = 60 * SECOND;
const HOUR = 60 * MINUTE;
const DAY = HOUR * 24;
const WEEK = DAY * 7;
const YEAR = DAY * 365.25;
const MONTH = YEAR / 12;

function durationToMS(length: number, unit: string): number | null {
    switch (unit) {
        case "ms":
            return length;

        case "s": case "sec": case "secs": case "second": case "seconds":
            return length * SECOND;

        case "m": case "min": case "mins": case "minute": case "minutes":
            return length * MINUTE;

        case "h": case "hr": case "hrs": case "hour": case "hours":
            return length * HOUR;

        case "d": case "dy": case "dys": case "day": case "days":
            return length * DAY;

        case "w": case "wk": case "wks": case "week": case "weeks":
            return length * WEEK;

        case "mo": case "mon": case "month": case "months":
            return length * MONTH;

        case "y": case "yr": case "yrs": case "year": case "years":
            return length * YEAR;

        default:
            return null;
    }
}

[jade stone]

if you fall for that you're just stupid

[winged mantle]

what was i doing

reminder to implement immunity

[placid cape]

oh my god

[placid cape]

why you can't?

[royal nymph]

is this venbot

[winged mantle]

yes

[royal nymph]

redis

terrifying

what abominations are you cooking

[winged mantle]

remember when i was trying to do temp vc

and venbot had no database

and i only knew redis

[valid jetty]

what the hell i just accidentally got this commit

[deep mulch]

you win

[valid jetty]

@placid cape @hoary sluice @lucid trail look at this beautiful syntax highlighting

its either ident | namespace::ident | module::namespace::ident (doesnt exist yet) but in all cases the first one should be highlighted differently

[jade stone]

can namespaces be nested?

[valid jetty]

nop only 1 level deep

[jade stone]

insane

fix

[valid jetty]

as far as module::namespace::f

[jade stone]

mod::ns_a::ns_b::foo

[valid jetty]

infinite nesting namespaces is kinda more evil

[jade stone]

how

[valid jetty]

you dont have namespace destructuring in the language

[fleet cedar]

Hierarchies are awesome though

[valid jetty]

if you have a function under a deep namespace you need to do a::b::c::d::e() every time

[fleet cedar]

Well do something about that then

[jade stone]

can you just bring a::b::c::d into scope?

then just do e()

[fleet cedar]

If you bring a:🅱️:c::d into scope you'll need d::e()

[jade stone]

i mean something akin to using namespace a::b::c::d

[fleet cedar]

Star imports are the devil though

[jade stone]

@deep mulch does using namespace std in all his header files

[deep mulch]

yop

[valid jetty]

STOP DOING INFINITE NAMESPACES

• NAMESPACES WERE NOT SUPPOSED TO BE 20 LEVELS DEEP
• YEARS OF NAMESPACES yet NO REAL-WORLD USE FOUND for going higher than 2 LEVELS
• Wanted to go higher anyway for a laugh? We had a tool for that it was called UNDERSCORES
• Yes please give me xyz::client::config::builder::retry::policy::standard::StandardRetryStrategy

LOOK at what Namespace Users have been demanding your Respect for all this time, with all the C++ and Rust we built for them
(These are REAL namespaces, done by REAL Namespace Users)

use galaxy::systems::engine::physics::collision::detection::broadphase::GridPartitioning;

?????

use company::platform::autonomy::perception::sensorfusion::lidar::calibration::internal::algorithms::optimization::LidarCalibrator;

???????????????????

"Hello I would like a vision::systems::realtime::localization::vslam::vio::features::matching::gpu::kernels::FeatureMatcher please"
They have played us for absolute fools

[deep mulch]

youre insane

[formal belfry]

insane

[jade stone]

@pseudo sierra @hoary sluice omw to debug a vscode extension with neovim

[valid jetty]

is this a good distinction

[deep mulch]

no

I feel weird about types being used as parameters like that

[valid jetty]

well yield is special

[valid jetty]

@deep mulch love?

it highlights self and args differently because theyre special names

[lucid trail]

very cool

i personally don’t like italics in themes, maybe cause berkeley mono’s italics are mid

[valid jetty]

i like them only for comments and special identifiers like that

you originally set every single parameter for function definitions to use variable.special which was a little excessive lol

@lucid trail i know that tree sitter is a context awareless AST, but do you think theres any way where i can have:

fn foo(i32 foo, ElleMeta meta, i32 bar) { // meta is specially highlighted because its type is ElleMeta
    meta; // special highlight
}

fn bar(ElleMeta meta_with_another_name) {
    meta_with_another_name; // specially highlighted too
}
``` where basically when it finds a param where the type is ElleMeta it marks that identifier to be colored with variable.special for the rest of the function body??

probably too complicated for tree sitter

i dont wanna mark all meta to be colored specially because you could plausibly have a variable called meta which isnt an ElleMeta

right now theres

and

i can relatively easily get meta (or whatever you decide call the parameter) to be highlighted in the function header

but getting it to be also highlighted for all other identifiers in the function body idk how to even start approaching that

[deep mulch]

@valid jetty

[valid jetty]

@deep mulch fix

[deep mulch]

nop

[formal belfry]

cat

[lucid trail]

maybe. I feel like this is more on the highlights.scm side than the grammar side

[valid jetty]

yeah i know, the meta coloring in the function header is on scm side too

[lucid trail]

can you send over your highlights.scm

[valid jetty]

i just have

; Highlight some identifiers with variable.special
((identifier) @variable.special
    (#any-of? @variable.special
        "self"))

; Highlight the ElleMeta one
(parameter
  type: (type) @type
  name: (identifier) @variable.special
  (#eq? @type "ElleMeta"))

(attribute_parameter
  type: (type) @type
  name: (identifier) @variable.special
  (#eq? @type "ElleMeta"))
``` i have no idea how to "scope" it for a function's body

oh yeah ok

not committed yet because im still doing things

[lucid trail]

these are semantic tokens

probably need tagging to implement them, and I also have no idea how they work

wait

these are all semantic tokens, technically

[valid jetty]

yeah but theyre unconditionally colored with variable.special

my idea was to color with variable.special only if there is a variable with the type ElleMeta and the same name in the function header (which means it should only color when in the function body like how do you even do that)

because tagging would probably highlight it here

fn foo(ElleMeta meta) {
    meta; // special highlight
}

fn bar() {
    meta; // with tagging, chances are its gonna be highlighted here too
}

[lucid trail]

this doesn't do anything for me rn

[valid jetty]

do you have latest tree sitter

[lucid trail]

yes, I'm pointing it at your repo 5faa

[valid jetty]

weird it highlights it for me

are there logs?

[lucid trail]

self gets highlighted but not meta

strange

[valid jetty]

oh it has to be typed ElleMeta

and its only highlighted in the header

[lucid trail]

just reloaded the window and it worked

[valid jetty]

ah ok

[lucid trail]

pretty sure i rebuilt tho

[valid jetty]

lmaoo

btw is there a way to locally test tree sitter changes without pushing and changing the rev?

like, actually view the changes in zed

i know you can tree-sitter parse

[lucid trail]

tree-sitter playground has been good

and tree-sitter highlight

dont know how to point to a local repo in zed tho

[valid jetty]

i saw that but that requires docker desktop which is like 3gb and i dont have the storage for that 🥲

[lucid trail]

are you on a 256 macbook

[valid jetty]

yeah

lmao

[lucid trail]

it's over

[valid jetty]

truly

rl::set_shader_value(
    shader,
    rl::get_shader_location(shader, "time"),
    &#cast(f32, rl::get_time()),
    SHADER_UNIFORM_FLOAT
);

look at this beautiful syntax

you can take the address of an immediate expression in elle

you can do like &1 and it automatically makes a temporary

&#cast(f32, rl::get_time()), is so beautiful

[lucid trail]

no box

woaw

Yeah in rust you would totally get temporary value dropped while borrowed

[valid jetty]

the power of a gc (I guess :3)

oh god i actually cant get around the issue of types vs exprs in directives

the #size directive LITERALLY ACCEPTS EITHER

[lucid trail]

lol types vs exprs has so many conflicts

[valid jetty]

like i can do #size(i32) or #size(foo() * 3)

[lucid trail]

#sizeT()

[valid jetty]

im gonna just have to make choice(prec(2, $.type), prec(1, $.expression)) and hope for the best i think

LMAO @lucid trail have you seen this

use std/prelude;

fn main() {
    while true {
        bin := Array::from_string(io::input("Enter a binary string: "));

        if !bin.every(fn(char x) "01".contains(x)) {
            $eprintf("Invalid string: {}", bin);
            continue;
        }

        mult := math::pow(2, bin.len());
        res := 0;

        for c in bin {
            // extremely insane expression
            // im surprised this even works
            c == '1' && (res += mult /= 2);
        }

        $dbg(res);
    }
}

bin to dec !! totally nothing suspicious going on

[glacial mirage]

ah ive seen that cond&&expr thing in js golf before

[valid jetty]

but have you seen res += mult /= 2 before

[glacial mirage]

no but i can guess what it does

[valid jetty]

the long way would be

for c in bin {
    if c == '1' {
        mult /= 2;
        res += mult;
    }
}

[glacial mirage]

assignment exprs usually return the value they assign

you should remove the curly brackets from the for loop too if you can in this lang

[valid jetty]

wait i did tho

did i read that wrong

[lucid trail]

Wow, I feel like chaining assignments like that could be quite ambiguous from a user's pov

[valid jetty]

it took me a second to figure out what it does when i reread it and i was the one who wrote it 😭

[glacial mirage]

oh probably not if there's no parens around the first bit

[valid jetty]

yeah, its too ambiguous to parse

either mandatory x (cond) stmt or x cond { stmt }

i decided to make curly mandatory because more often than not you want a multi line thing anyway

and not very often is your condition big enough that you need ()

[valid jetty]

i was going on about ambiguity earlier but i feel like this one isnt as bad because you can just read the assignments right to left and it makes sense

[lucid trail]

I've determined that this is probably not possible within tree-sitter

[valid jetty]

lmao i thought so

idk why it took so long for this to exist

but you can .values() and .entries() on a hashmap now

for some reason i only did .keys() when i first wrote it???

what looks best

i like the pink and orange ones best but idk

[lucid trail]

i was trying to make it as close to rust as possible

the last one is the only one that makes sense

[valid jetty]

yeah the last one is what rust's looks like too

[glacial mirage]

1 or 4 imo

[deep mulch]

1 or 3

4 looks basic

[frosty obsidian]

i cant tell what the difference is between the first two

[glacial mirage]

2 uses the same colour for both the use and the paths

[frosty obsidian]

is the first one not?

it looks like its doing that to me

[jade stone]

first but swap the colors

[placid cape]

Nice so you're finally making treesitter

[hoary sluice]

@valid jetty do you desugar in the parser

like for let i; cond; i++ => let i; while cond { i++ }

[hoary sluice]

STOP DOING #compiler_directives

• BUILTINS WERE NOT SUPPOSED TO BE INVOKED WITH HASHTAGS
• YEARS OF LANGUAGE DESIGN yet NO REAL-WORLD USE FOUND for prefixing functions with #
• Wanted to make things look edgy anyway for a laugh? We had a tool for that: it was called MACROS
• Yes please give me #cast(x, T) instead of the perfectly readable x as T
• Built-ins don't need to be segregated with #; they can be keywords themselves

LOOK at what Directive Enthusiasts have been demanding your Respect for all this time, with all the compilers and interpreters we built for them
(These are REAL directives, used by REAL Directive Enthusiasts):

let size = #size_of(T);
let ptr = #alloc(T, n);
let id = #i(x);

"Hello, I would like a #env.allocator.free_self please"

They have played us for absolute fools

directive enthusiast 😭

[blazing haven]

😭

https://monaspace.githubnext.com/

has anyone tried these here yet

what's the consensus

[dawn ledge]

port https://github.com/olebedev/when

[dawn ledge]

was a reply to ^

i fucking hate discord

[mossy ether]

they're awesome

used argon for the zed font and krypton for the buffer

[dawn ledge]

depends on who you ask

they're absolutely horrendous for me, cause i lean more towards the terminus/departure mono side for monospace fonts

[hoary sluice]

the third one is literally computer modern monospace

they look meh

better than some others

but i wouldnt use them

[mossy ether]

yeah they fit better for like a replacement for jetbrain's

[hoary sluice]

what does that mean

[dawn ledge]

i dont see a difference can someone explain

[hoary sluice]

isnt that any good monospace font

[mossy ether]

maybe

[hoary sluice]

just use maple mono

[dawn ledge]

awesome ligatures bro

[mossy ether]

width on m

[dawn ledge]

ahhh

[hoary sluice]

whats the difference between the left side and the right side

[dawn ledge]

i am being sarcastic

there is no difference

With regards to GitHub Blocks, blocks.githubnext.com will no longer work once the technical preview concludes and we will not make Blocks into a full GitHub product. Blocks was an exciting experiment and thanks to your feedback, we learned a lot about how we might add extensibility to GitHub.com. We expect GitHub will continue to explore this capability in the future, but for now we’re focusing our efforts on other areas.
kinda sad blocks got sunset, i used to be in the testing group :(

[fleet cedar]

What's that

[dawn ledge]

interactive elements in markdown

like graphs and diagrams

https://blocks.githubnext.com/

@hoary sluice https://githubnext.com/projects/copilot-voice/

[hoary sluice]

im trying this

theres no nvim plugin

im not trying this

[blazing haven]

akjhkjaskjdhjkasdjkasjkdhkasd

me when i use nvim

[blazing haven]

what do u use

[hoary sluice]

this might actually be cool if it works well

maple mono

[dawn ledge]

github next has devolved into ai slop

[hoary sluice]

this isnt slop

its not vibe coding

[blazing haven]

ai is slop by definition

[hoary sluice]

its tired of typing coding

[blazing haven]

[dawn ledge]

this

[hoary sluice]

how

[dawn ledge]

[blazing haven]

slop for ur brain

[dawn ledge]

well ai post chatgpt explosion

it was cool before chatgpt got good

[hoary sluice]

definition of ai is performanig any task typically associated with humans, which includes medical diagnosis that humans couldnt do

[blazing haven]

cuz they forcing ai into everything where it doesnt even make sense and invent products/solutions for things that werent a problem xd

[hoary sluice]

not all ai is slop

[pulsar elk]

copilot is absolutely worthless btw

[hoary sluice]

copilot voice is in the gray area but it allows handicapped people to code which is awesome and not slop

[dawn ledge]

eagely boutta argue about absolutely everything

[hoary sluice]

it will not be used by vibe coders cause they use cursor with voice input

[hoary sluice]

yess

[pulsar elk]

im ready to argue too 👽

[dawn ledge]

the earth is round eagely

[blazing haven]

let him cook

whats wrong with arguing

[hoary sluice]

youre bringing up stupid points, this very well reflects the current geopolitical and economic situation in the world

also nixos

[dawn ledge]

let me cook you

[blazing haven]

[blazing haven]

r u from catalonia

[hoary sluice]

please tell me copilot voice isnt an april fools joke by microsoft

[dawn ledge]

i dont even know where catalonia is

[hoary sluice]

ok they made it slop

i thought it was a tool for disabled people

its just a general purpose not even programming ai slop

microsoft manages to make everything slop

[blazing haven]

im asking cuz i thought u need to live there to get a .cat domain

[dawn ledge]

hmmmm how am i supposed to run this

[hoary sluice]

theres a trick called not upholding contracts

[blazing haven]

unless u can get it via njal.la or smth

oh yeah there we go

30€/year on njal.la

[dawn ledge]

oh, you have to be there to get it
my registrar said i need to upload catalonian content in 3 months of registering, its been years and they dont care

i got it from regery

like $10/y

[hoary sluice]

buy?

[dawn ledge]

lc.wa 30€ to $

[visual shell]

30€ to $

$34.04 (US dollars)

Wolfram|Alpha • labsCore • Page 1/5

[dawn ledge]

nvm

[blazing haven]

LOL

automod censored my domain

[dawn ledge]

i lied its $20/y

[blazing haven]

iwas going to say catnoise.cat is already taken

[dawn ledge]

most <dictionary word>.<tld> domains are almost always taken

and you have to pay some absurd price if they're up for transfer

[blazing haven]

germancatnoise.cat is available tho

[dawn ledge]

english dictionary :^)

[hoary sluice]

noisesof.cat/s

what about cat-noises.cat

[blazing haven]

vencord.cat is also available

[dawn ledge]

vencord.app

[glossy cloak]

⚠️ vencord.app is a fake malicious site! The only real website is https://vencord.dev! If you have downloaded anything from vencord.app, remove everything you have downloaded immediately, run a malware scan and change your Discord password.

[blazing haven]

nooo copy.cat is also taken

[hoary sluice]

of course it is

[blazing haven]

cyber.cat too

they just hate me

[dawn ledge]

hacker.cat

[blazing haven]

taken

kitty.cat too xd

[fleet cedar]

I count possibly 5, can't count the dtors

[hoary sluice]

@valid jetty i was wondering why rustfmt wasnt working

(i didnt have it installed)

[lavish frigate]

From https://youtu.be/02rh1NjJLI4

Very good video

[hoary sluice]

sheafy(int x) {
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
  foo()
}

or is that indirect

[formal belfry]

foo

[lavish frigate]

Very much is indirect

They aren’t called by main

[blazing haven]

watching now

i feel like a big part of the problem is using std::cout std::endl lmao

but i will keep watching

[lavish frigate]

Keep watching!!

[blazing haven]

i knew it

cuz i had this before years ago i vaguely remember xd

[leaden crater]

is there really any reason to use endl instead of \n if youre not dealing with huge amt of rows

[fleet cedar]

Imagine not using std::println()

[lavish frigate]

std::println!()

[blazing haven]

i'd assume it depends on what u r doing

like if u print to console it prolly doesn't matter

but p sure \n + std::flush is equivalent to std::endl

so if u know u need a flush just use it explicitly

all this assumes u know what u r doing xd

[leaden crater]

eprint!()

[fleet cedar]

They can differ if you're printing from multiple threads simultaneously

But don't do that

[dawn ledge]

use locks when writing to the same fd across threads

use locks when writing to anything shared across threads infact

[dense sand]

Guys which neovim package manager should i be using? I use vim plug rn

[formal belfry]

print("sybau")

[dawn ledge]

i use lazy.nvim

its great

although i want to move to lz.nvim cause of my immutable config setup

[fleet cedar]

There's way too many

[shrewd canopy]

Was it finally implemented without using fmtlib

[fleet cedar]

It's in c++23

Dunno how compiler support is

[formal belfry]

[dense sand]

Wtf is luarocks, wtf is lazy.nvim what should i use im confused

[fleet cedar]

Luarocks is the crates.io of lua

[lavish frigate]

basically luarocks is a lie because lua doesnt rock

[formal belfry]

just use a distro

https://github.com/NvChad/NvChad

[fleet cedar]

lazy.nvim is one of hundreds of plugin managers for nvim

[formal belfry]

it will setup allat for u

[hoary sluice]

@fleet cedar should i curry in the parser or in the interpreter

the parser is supposed to be just parsing the ast and not doing any actual logic right

[fleet cedar]

Parser obviously

It makes no sense so I'd be interested in seeing wtf you mean

[dawn ledge]

i dont like this comparison of c++ and python "assembly"
former is actual assembly, latter is an abstract instruction set

[hoary sluice]

parse it as a function with a list of arguments and evaluate it by storing its curried form in the env

[fleet cedar]

Bytecodes are similar to asms, but usually much higher level

Oh, you mean whether a b c d should be represented in the ast as Call(a, [b, c, d]) or Call(Call(Call(a, b), c), d)

[hoary sluice]

yes

[dawn ledge]

LOOOOLLL

lol that slow rust logo reveal sends me

damn i got baited

it is c

[lavish frigate]

yep

lmao

[dawn ledge]

it was a good video

lmao

[nimble bone]

https://code.visualstudio.com best plugin manager ❤️

[fleet cedar]

Ai bullshit detected ⚠️

[formal belfry]

your code editor

[hoary sluice]

nixvim

[formal belfry]

your text editor REDefined with ai

[lavish frigate]

ill make neovisual studio code which removes ai

ill call it nvim to overshadow neovim though

[hoary sluice]

someone should make a full on ide with no ai bs and market it as innovative but in reality its just an nvim config

[dense sand]

Ill probably just use nvchad like someone suggested

[nimble bone]

based

[dawn ledge]

watching this dudes videos makes me realize just how bad im at math

[nimble bone]

we moved away from VTs for a reason. embrace GUIs 🚀

[hoary sluice]

but make sure to take a day off to configure it

[dawn ledge]

we still emulate VTs for a reason
embrace the terminal lifestyle

[hoary sluice]

some people spend all their free time learning random math subcategories

sheafification

[formal belfry]

wheere

[dense sand]

Im ok with it

I have nothing to do anyways

My current neovim setup is kinda broken

[formal belfry]

namespace ur mum

命名空间 {}

FUCK NAMESPACES

[fleet cedar]

Namespaces are bull, gimme modules

[dawn ledge]

i dont understand the dip here

https://youtube.com/watch?v=u24AjKinHNU?t=1102
LOL imagine spending hours writing crazy math just for GNU MP to be faster than your multithreaded solution on single thread

never have i watched a 4 video series on fib numbers this attentively

[nimble bone]

we should kill rustaceans

[formal belfry]

[hoary sluice]

but why kill @valid jetty

@valid jetty what are u gonna do when boris johnson puts cameras in ur iphone

[nimble bone]

she can stay alive

[pulsar elk]

guys is lua a real language or not

[hoary sluice]

no

hate lua

forced to lua by the neovim industrial complex

[pulsar elk]

y tho

[fleet cedar]

Terrible syntax, global by default, and 1 indexing

[pulsar elk]

well... the syntax isnt that bad

[fleet cedar]

end

[pulsar elk]

touche

[pseudo sierra]

I kinda like lua as a scripting language (cuz that's what it is) and if you think of it as bash but it's usable for full programs it makes 100x more sense

[winged mantle]

when i see brave: someone get me the manager