huh
#🪅-progaming
formal belfry
vim diesel
formal belfry
valid jetty
on that note i discovered the best way to take notes
valid jetty
it gets in the way so much
no not really
hoary sluice
on that note i discovered the best way to take notes
writing notes as haskell functions
why are there a bunch of ::
hoary sluice
rosie did you make types first or other stuff first
valid jetty
wdym
hoary sluice
i initially made just functions with no type checking
did u do that too
or type checking first
valid jetty
yes ofc
hoary sluice
ofc type checking first?
valid jetty
the initial compiler just generated calls to functions arbitrarily
qbe lets you do that
valid jetty
itll just fail at link time if the function doesnt exist but if you pass wrong arguments its just undefined behavior
valid jetty
i initially made just functions with no type checking
this
hoary sluice
ok
also im gonna remove shadowing to simplify things
remove scopes
make everything global
valid jetty
lmao
you should look at the first draft of my compiler the code was geuinely beautiful
hoary sluice
is that sarcastic
hoary sluice
and this
this looks like if a c programmer was forced to write rust
i still dont know if you actually mean its ugly or not cause this looks like very normal rust code with some unneccessary clones
omg i have to finish icypeas literally just so i can rename it to ricypeas and make icypeas be icypeas written in icypeas
im gonna go learn lambda calc now gn
valid jetty
i still dont know if you actually mean its ugly or not cause this looks like ver...
its pretty cursed for what it is
it could barely compile a basic program
hoary sluice
it could barely compile a basic program
that was my code before i deleted it just now
valid jetty
lmao
i just checked out an old branch omg this is nostalgic now
fn add(Int size, ...) {
Int res = 0;
Variadic args[size];
Defer free(args);
for _ = 0 to size - 1 {
res += args yield Int;
}
return res;
}
pub fn main() {
Int res = add.(1, 2, 3, 4);
printf!("%d\n", res);
return 0;
}
back when Dart syntax highlighting looked better than c++ or rust
hoary sluice
wlats yield int
deep mulch
i just checked out an old branch omg this is nostalgic now
```rs
fn add(Int size...
HAATEEE
valid jetty
wlats yield int
equivalent now
fn add(ElleMeta meta, ...args) {
res := 0;
for i in 0..meta.arity {
res += args.yield(i32);
}
return res;
}
fn main() {
res := add(1, 2, 3, 4, 5);
io::println(res);
}
that for statement 😭
deep mulch
equivalent now
```rs
fn add(ElleMeta meta, ...args) {
res := 0;
for i i...
better
hoary sluice
equivalent now
```rs
fn add(ElleMeta meta, ...args) {
res := 0;
for i i...
ElleMeta 
deep mulch
equivalent now
```rs
fn add(ElleMeta meta, ...args) {
res := 0;
for i i...
ElleMeta
hoary sluice
please just make varargs a normal array
valid jetty
ElleMeta <:husk:1026532993923293184>
look at all of these things you get for free
valid jetty
please just make varargs a normal array
that means the args must all be 1 type
hoary sluice
but you shouldnt have that
hoary sluice
that means the args must all be 1 type
dynamic varargs????
deep mulch
that means the args must all be 1 type
as they should be
valid jetty
but you shouldnt have that
why not its runtime call introspection
hoary sluice
dynamic varargs????
might as well delete the type system
valid jetty
dynamic varargs????
yeah how do you think string::as_string works 😭
deep mulch
Rosie making js
formal belfry
hoary sluice
why not its runtime call introspection
but every language that has any kind of reflection only has slow reflection so this is probably slow
hoary sluice
https://www.youtube.com/watch?v=d8XtNXutVto&t=96s
you posted this already
valid jetty
but every language that has any kind of reflection only has slow reflection so t...
it is very much not slow its compile time sugar
when you call a function if the 0th arg is typed ElleMeta the compiler automagically generates the struct and passes it for you
there is no reflection its just strings being created at compile time
but can be inspected at runtime
formal belfry
you posted this already
new part of the vid
hoary sluice
cant open the link it puts me into jew youtube
i meant ads youtube
got them mixed up
how do i make android open yt linkr in vanced
deep mulch
how do i make android open yt linkr in vanced
enable link handling in the yt app settings
hoary sluice
where
lucid trail
"p" -> '"_dP'
i cant live without it
also do you sync vim clipboard with system clipboard?
hoary sluice
you delete into the black hole register then paste effectively copying nothing because its deleted
hoary sluice
also do you sync vim clipboard with system clipboard?
yes
lucid trail
you delete into the black hole register then paste effectively copying nothing b...
yes i took some time to try it, hence i now know how it works
hoary sluice
typing "+p on this takes approximately 4 years
hoary sluice
i have 4 spare pcbs
hoary sluice
crone choc?
ferris sweep choc
wish i got a corne
i really want those 2 extra thumb keys
lucid trail
i was seriously considering a corne but i mainly program on my laptop so it's not justifiable
lucid trail
LOL that fan into laptop setup is a classic
frosty obsidian
innovative cooling solution
hoary sluice
LOL that fan into laptop setup is a classic
cant play among us without it
havent gotten rid of it since my last among us session like a month ago
lucid trail
ferris sweep choc
dang 140euro is pretty expensive for what it is
hoary sluice
i paid more like 280
lucid trail
that's a horrible deal
hoary sluice
or like 220 idr
i bought all the parts myself and built it myself and theres a shortage of choc keycaps and i messed up on shipping
ordered twice from the same shop
got the expensive nice nanos instead of pro micros
gold plated pcb 😎
if bitcoin goes to 120k i might get a voyager
lucid trail
might as well buy a CNC-ed aluminum housing from JLCCNC
hoary sluice
im not that rich
altho voyager is pretty big
corne might be a better idea
hmm i wonder if clicky chocs are nice
id love clickies but then i cant use it in an office
lucid trail
insane
what switches do you have in there rn?
though I'm not very familiar with low profile ones
hoary sluice
what switches do you have in there rn?
brown tactile 60gf
my keycaps have this annoying slope on the sides
might get new ones soon
lucid trail
oh yeah if I ever buy one i'd want hall effect switches for sure
hoary sluice
yea have fun getting low profile hall effect on a well designed pcb
lucid trail
I've used linear switches for so long idk how I would feel using tactile ones
hoary sluice
id just get a voyager
im prob gonna buy one soon
its expensive but worth it
365$ but its soo nice
lucid trail
yeah
I'm quite scared of getting an RSI but I'm not actively doing anything to prevent it either
hoary sluice
you get a carrying case and extra caps
lucid trail
i saw a review of it where a guy mounted it to his desk almost vertically
hoary sluice
yea ive seen it
im scared of getting a keyboard with a trrs connection cause it shorts vcc and gnd if u unplug it
hoary sluice
i saw a review of it where a guy mounted it to his desk almost vertically
id personally love a tented keyboard with 36 or 42 keys that has a smooth surface, like a glove 80 but with less keys
theres the dactyl which seems almost perfect but im not sure id like it
it looks rough
or dactyl manuform
it has so many rough edges
atp might as well use datahand v2 https://svalboard.com/
valid jetty
consider macos keyboard
very short travel time
nice switches
its amazing to type on
tactile and fast
deep mulch
no
hoary sluice
consider macos keyboard
stfu!!
valid jetty
its really good can confirm
my thinkpad keyboard is similar but longer travel time
which i sometimes prefer but whatever
lucid trail
macOS keyboard is peak
deep mulch
Rosie has tiny fingers
lucid trail
low travel => more accurate and faster
hoary sluice
i have way less travel time
almost no travel time
all keys are at most 1 away
from home row
and the layout isnt qwerty
lucid trail
what layout are you using
deep mulch
Rosie struggles to push the keys down
hoary sluice
what layout are you using
semimak jq
its explained here https://semilin.github.io/blog/2021/reflection_on_semimak.html
under ring finger movements
valid jetty
all keys are at most 1 away
that is not what travel time means
hoary sluice
as a side note are your vim keys still hjkl
nope i have the left thumb key on the right half + home row bound to arrow keys
lucid trail
high (left), lower (right)
hoary sluice
oh
well im using choc switches
which have very short travel time
but theyre mechanical so its higher than on a membrane keyboard either way
nicer for typing fast tho
supple whale
opens theo stream for 1s, sees this, leaves
hoary sluice
this is fake
supple whale
nah this is legit a ss from his stream 10 seconds ago
hoary sluice
@valid jetty this is so hard to get intuition for
valid jetty
no not really
lucid trail
I think I know which video this is from
valid jetty
a boolean in functional programming is a 2 arg function that picks a or b depending on if its true or false
NOT just takes a boolean and makes it return b when path a is taken and vice versa
its really not that complicated
deep mulch
when Rosie says something isn't complicated it usually is complicated
valid jetty
when Rosie says something isn't complicated it usually is complicated
true is λab.a or a => b => a
valid jetty
all NOT does is just, when you take NOT(TRUE) you do (a => b => a)(a => b => b)(a => b => a) which looks confusing when written but idk how explain with words
i think its better like
in functional programming, true and false are both functions that pick something right?
if you define true and false, (definition not required to show the below) then
NOT x = x false true
when its true, you get false, when its false you get true
lucid trail
basically not reverses the order of the args
valid jetty
yeah exactly
lucid trail
const NOT = b => x => y => b(y)(x);
hoary sluice
all NOT does is just, when you take NOT(TRUE) you do `(a => b => a)(a => b => b)...
i know what it does i understand it i just want intuition for it
valid jetty
in the case of the image eagely sent, TRUE = λab.a, FALSE = λab.b
so applying NOT TRUE would be doing TRUE FALSE TRUE
valid jetty
i know what it does i understand it i just want intuition for it
i explained under the intuition
winged mantle
function not(b) { return Boolean(b) === false; }
hoary sluice
like if i read the equivalent as an imperative function id probably understand it
valid jetty
like if i read the equivalent as an imperative function id probably understand i...
function not(x) {
if (x) return false;
return true;
}
^^^
hoary sluice
```ts
function not(x) {
if (x) return false;
return true;
}
```
yup and i immadiately see what it does
i just need to feed myself more lambda calculus
so i have the same intuition
valid jetty
thinking of TRUE as a function that always picks the first argument is a good way to think about it
hoary sluice
also this is really funny and actually makes sense
hoary sluice
thinking of TRUE as a function that always picks the first argument is a good wa...
yes thats what it is
valid jetty
because NOT true would make it just pick the second argument
hoary sluice
and how the guy explained it
valid jetty
yes thats what it is
i know lol
i like the isZero implementation
idk if its in the video
hoary sluice
u dont need to teach me lambda calculus ik how it works
valid jetty
lol okk
hoary sluice
tomorrow
hoary sluice
https://gist.github.com/acquitelol/d57fcca15ccc14dccc178d2da16c1c12
?remind horror in 19 hours
delicate groveBOT
Alright @hoary sluice, in 19 hours: horror
valid jetty
fizzbuzz isnt as interesting as the div impl
i wanted to do it with the Y combinator
hoary sluice
idk if its in the video
valid jetty
did they ever explain how IS_0 works tho
valid jetty
ycomb my beloved
hoary sluice
now were talking about the riemann hypothesis?????
deep mulch
in functional programming, true and false are both functions that pick something...
i read htis twice and i still dont know what youre saying
hoary sluice
math is scarily interrelated
valid jetty
i read htis twice and i still dont know what youre saying
in functional programming functions have only 1 argument
which means, to get the same multi arg functions as normal programming, you have to just accept multiple functions
a funtion like add in functional-style would be like const add = a => b => a + b
which:
if i do add(3) i get back another function!!! if i call that function with anything i get 3 + that thing
typically you call it like add(3)(4) which gives 7, and this is a way you can circumvent the fact that functional languages only allow for a single parameter in functions
so the true function is a function defined like a => b => a
if i do
true(42) and i call that function with ANYTHING i will always get 42 because it picks a no matter what
the false function is similar, its just a => b => b
hoary sluice
i read htis twice and i still dont know what youre saying
true is defined as this:
def true(a, b):
return a
false is this:
def false(a, b):
return b
a NOT gate therefore is:
def not(x): # where x is either the true() function or the false() function
return x(false(true))
valid jetty
true is defined as this:
```py
def true(a, b):
return a
```
false is this:...
this makes it harder to understand i think
valid jetty
i think the way i was explaining it is easier maybe
valid jetty
its a good video but you dont need to watch a video to understand booleans
hoary sluice
its a good video but you dont need to watch a video to understand booleans
no point in understanding fp bools if thats the only thing u understand
valid jetty
true
deep mulch
<@289556910426816513> watch the video
i did
formal belfry
lucid trail
the kerning on those italics are horrendous
valid jetty
true
placid cape
the hell
Lmao
Rosie I have a challenge for you
Try to sleep for more than 5 hours a day :d
dense sand
impossible
deep mulch
impossible
leaden crater
@deep mulch
deep mulch
@leaden crater
placid cape
@placid cape
deep mulch
@valid jetty ```
fn main() {
val x = 55
println("Hello, world! " + x)
}
[Token(kind=FN), Token(kind=IDENTIFIER, value=main), Token(kind=LPAREN), Token(kind=RPAREN), Token(kind=LBRACE), Token(kind=VAL), Token(kind=IDENTIFIER, value=x), Token(kind=EQ), Token(kind=NUMBER, value=55), Token(kind=IDENTIFIER, value=println), Token(kind=LPAREN), Token(kind=LITERAL, value=Hello, world! ), Token(kind=ADD), Token(kind=IDENTIFIER, value=x), Token(kind=RPAREN), Token(kind=RBRACE)]
now what
placid cape
Time for parser
leaden crater
<@433225972070744064>
what's today's regular color i WONDER
deep mulch
what's today's regular color i WONDER
greeb
deep mulch
Time for parser
thats the thing that builds the tree and ties everything together right
spark tiger
Try to sleep for more than 5 hours a day :d
genuinely who the hell is sleeping that much
like unemployed ppl??
placid cape
5 hours is a lot?
spark tiger
5 hours is a lot?
kinda
i sleep like 3 hours at night
and then 3ish in the evening
valid jetty
<@581573474296791211> ```
fn main() {
val x = 55
println("Hello, world! ...
yay nice
now you implement a parser
depending on how your language works this could be a little different but typically you take that token stream and you go “is it the FN token?” “ok let’s parse a function”
and then you consume all the tokens and by the end you have a struct with the function’s name and body
parsing the body is the interesting part because you have to go recursively parsing statements and then expressions
i would recommend watching a video on how this works because it’s easier to understand than for me to type it i think
but essentially you turn
FN
main
(
)
{
print
(
“hi”
)
}
into
Function {
name: “main”,
body: [FunctionCall {
name: “print”
arguments: [StringLiteral {
value: “hi”
}]
}]
}
okay
nini @valid jetty @valid jetty
ornate quiver
nini
ionic lake
nini
hoary sluice
<@581573474296791211> ```
fn main() {
val x = 55
println("Hello, world! ...
ZOOT IS MAKING A COMPILER?????
THIS IS THE BEST DAY OF MY LIFE
frosty obsidian
i bet its in kotlin
balmy lintel
you will die shortly
hoary sluice
you are not a rabbit
hoary sluice
<@415132870252822539> i got 8 hours of sleep (this week) are you proud
you are not 74
although you might be very soon
hoary sluice
i bet its in kotlin
Yup
u can see from the print output
thats kotlin enum formatting
@valid jetty https://youtu.be/RcVA8Nj6HEo
nop wrong link
watch this
placid cape
<@415132870252822539> i got 8 hours of sleep (this week) are you proud
now make it 8 hours of sleep every day
hoary sluice
@valid jetty i think im just gonna make lambda calculus valid icypeas syntax
either
add : int int int
add a b = a + b
or
λxy.x+y a b
or
\xy.x+y a b
fleet cedar
So is \xy.x+y there a function that's applied to the arguments a b?
Similar to haskell (\x y -> x + y) a b
hoary sluice
my lambdas before this were { identifier } $ body
required () unless theyre on their own line
hoary sluice
So is `\xy.x+y` there a function that's applied to the arguments `a b`?
yes
except instead of doing it the stupid way with lambda x y: x + y or (x y $ x + y)
valid jetty
either
```hs
add : int int int
add a b = a + b
```
or
```hs
λxy.x+y a b
```
or
`...
who is gonna be typing λ
i am NOT copy pasting that every time i want a function
hoary sluice
ctrl shift u 03bb enter
Έ
oops
λ
typed 0388 there cause i did unpress number layer toggle
hoary sluice
i am NOT copy pasting that every time i want a function
if ur too lazy to type ctrl shift u 03bb you can just use \ like in hs
hoary sluice
what
valid jetty
rust throwing the best warnings
winged mantle
rust hates clean code
valid jetty
clippy::restriction my beloved
valid jetty
how tf is rust able to make such amazing analysis of my code
calm walrus
rust being so predictable that it can actually infer what may have went wrong is so awesome.
deep mulch
@valid jetty hiii
valid jetty
like this is cool
placid cape
either
```hs
add : int int int
add a b = a + b
```
or
```hs
λxy.x+y a b
```
or
`...
cool
placid cape
how tf is rust able to make such amazing analysis of my code
yeah that's amazing
deep mulch
@valid jetty what fields should my token class have
valid jetty
<@581573474296791211> what fields should my token class have
mine has kind, value, and location
deep mulch
@valid jetty help how do i make the parser
valid jetty
<@581573474296791211> help how do i make the parser
collect all the tokens into an array and then make functions like "expect_token(TokenKind)" and then start iterating the tokens and expect one of the top-level statement keywords
deep mulch
would elle be a good reference
valid jetty
also make an advance function and stuff
uhhhhhhhhhhhhhhh
elle is a lot more complex than a basic compiler so not really
if anything ichigo is a good reference
deep mulch
what is binop
deep mulch
and + - * / was arithmetic operations
fleet cedar
i thought binary woas just shifting
You're confusing it with bitwise
valid jetty
ichigo just does the basic ones as a function
fn Parser::add_arithmetic(Parser *self, string name, string op) {
self.tree.push(Primitive::Function(
name,
[Argument::new("x", "整数"), Argument::new("y", "整数")],
[AstNode::Return(
AstNode::BinOp(
AstNode::from_token(Token::new("identifier", ValueKind::String("x"))),
AstNode::from_token(Token::new("identifier", ValueKind::String("y"))),
op
)
)]
));
}
fn Parser::add_arithmetic_methods(Parser *self) {
self.add_arithmetic("加算", "add"); // 「かさん」と読みます
self.add_arithmetic("減算", "sub"); // 「げんざん」と読みます
self.add_arithmetic("乗算", "mul"); // 「じょうざん」と読みます
self.add_arithmetic("除算", "div"); // 「じょざん」と読みます
self.add_arithmetic("剰余", "rem"); // 「じょうよ」と読みます
}
And &&/|| aren't bitwise anyway
deep mulch
does ichigo not do a tree
valid jetty
it does its right there
self.tree.push
the top level usually isnt AstNode, its a "Primitive"
deep mulch
i am struggling to read elle
valid jetty
how
valid jetty
primitive is top level stuff (functions only in ichigo but for elle thats functions, enums, namespaces, structs, constants)
astnode is just a statement
fleet cedar
That's a strange definition of primitive
valid jetty
idk thats what i called it when i first wrote this thing
deep mulch
That's a strange definition of primitive
yea
winged mantle
how does adding a fullstop to string create an error...
description is just a plain string type
😭
and if i add something after the fullstop and remove it again the error goes away - the same code sometimes has an error and sometimes does not
??
race condition in typescript compiler?
restarting also makes the error go away
fleet cedar
Probably some weird lsp synch issue
deep mulch
is expression just another name for an ast node
fleet cedar
No
deep mulch
oh
winged mantle
isn't it something which has a value
fleet cedar
Typically you'd have a typed ast where statements are one type, expressions are another, etc
deep mulch
so a node would be the base for everything?
fleet cedar
?
deep mulch
like the tree would be made from nodes and expressions would be an implementation of the node
fleet cedar
Nah, there's no point in having a Node trait imo
Like, what behavior would that represent
placid cape
That's a strange definition of primitive
yep you should rename it @valid jetty
deep mulch
idk I thought it was the standard type
placid cape
too rusty
maybe look at some of the repositories listed on https://monkeylang.org/
deep mulch
maybe look at some of the repositories listed on https://monkeylang.org/
I will do
fleet cedar
Traits are useful when they're useful
If they aren't useful, no point in having them
deep mulch
I don't do rust so idk much about traits
placid cape
race condition in typescript compiler?
report it
fleet cedar
I don't do rust so idk much about traits
The same is true for all abstractions
placid cape
I don't do rust so idk much about traits
it's basically an interface
fleet cedar
Abstractions that aren't useful aren't useful
deep mulch
oh
placid cape
idk how to reproduce lol
just create issue on github with the video
some ts boy will reproduce it
winged mantle
a good issue should have a minimal reproducible example
placid cape
yea
deep mulch
placid cape
but i think it's still better to create the issue even without a minimal example than not to create one
well idk
valid jetty
i’m adding enums
do i make Foo::A or Foo.A???
to keep it consistent i’ll probably do Foo::A
fleet cedar
How do you use :: vs . in other cases?
valid jetty
How do you use :: vs . in other cases?
:: is used for non-instance methods of structs
ie Foo::new() (without a self instance)
fleet cedar
In rust it's that you have . if lhs is a value and :: if there's a type/path
ionic lake
::
valid jetty
In rust it's that you have . if lhs is a value and :: if there's a type/path
ok yeah so similar thing
alright i’ll do :: then
are enum variants always known at compile time
like their inner value
valid jetty
not really if you want an enum with strings or one that starts at something other than 0
valid jetty
i know but i mean the repr type lol
fleet cedar
Unimportant other than ffi
valid jetty
ya ya but useful for printing them
valid jetty
i have basic ones done tho
ideally theyre not a function theyre just sugar for a enum-typed literal
fleet cedar
But what's the value in printing the memory representation, do you write strings as "Hello" = 48 65 6c 6c 6f too?
valid jetty
lol no that part is unfinished
when im done itll show the variant name
right now the formatter just does an explicit cast to the enum repr type
it would be returning a string
hoary sluice
And `&&`/`||` aren't bitwise anyway
they are if you want them to be
valid jetty
theyre not lol
theyre by definition logical because they have short circuiting/lazy evaluation built in
in a non-functional environment thats an important distinction because doing foo && bar() could have side effects
hoary sluice
@deep mulch https://craftinginterpreters.com/contents.html
you dont have a parser yet so whether its an intepreter or a compiler doesnt matter
valid jetty
i have basic ones done tho
this is correct i think
hoary sluice
in a non-functional environment thats an important distinction because doing `fo...
not if i make || and && bitwise operators and or and and logical
valid jetty
glacial mirage
not if i make | and & bitwise, || and && logical, and or and and logical + short circuiting
valid jetty
THATS WORSE
deep mulch
to keep it consistent i’ll probably do Foo::A
ulgy
deep mulch
<@289556910426816513> https://craftinginterpreters.com/contents.html
information overload grahhh
deep mulch
.
valid jetty
but non-instance functions use ::
you do foo_instance.xyz() but FooTheType::xyz()
it would make sense to have :: for enums
valid jetty
implicit self when
no explicit self is good
valid jetty
its good for looking at signatures of functions
you know whether its an instance method or not
deep mulch
it just clutters code
if you're operating in the scope of the instance it makes sense the methods come from the instance
valid jetty
??? you can have both
fleet cedar
if you're operating in the scope of the instance it makes sense the methods come...
Maybe if you see it as the type doing things, rather than the method doing things
valid jetty
struct Foo {
i32 x;
};
fn Foo::x() {
return 42;
}
fn Foo::y(Foo *self) {
return self.x + 1;
}
if there was no Foo *self how would you know whether you do Foo::y() or foo_instance.y()
without reading the source code
imagine the function has 1000 lines of code
dense sand
elle discord support when
valid jetty
at some point in the distant future lol but idk if ill be the one to make that
delicate groveBOT
@hoary sluice, <t:1745444598:R>: horror
deep mulch
```rs
struct Foo {
i32 x;
};
fn Foo::x() {
return 42;
}
fn Foo::y(Foo ...
x isn't defined anywhere so it's safe to assume x is defined on the instance
at least maybe compromise by removing self as a required parameter and implicitly have it available
Guhhh
implicit return type
valid jetty
at least maybe compromise by removing self as a required parameter and implicitl...
that solves nothing
valid jetty
x isn't defined anywhere so it's safe to assume x is defined on the instance
again you have to know the source code when you call the function
deep mulch
fn Foo::y(): i32 {
return self.x + 1;
}
but what if Foo::y is a static (non instance) method
?
valid jetty
the main problem is you dont know, as the caller, whether its an instance method or not
deep mulch
okay but I don't understand the implicit return type cause you can argue the same situation for the self
valid jetty
yeah thats a thing i would get rid of if i could
but explicit return types means refactoring hundreds of functions and its too late now
placid cape
How the heck you want to know if the method is static or not without explicit self/keyword?
fleet cedar
Implicit return type requires global reasoning, which is slow and fragile
placid cape
but explicit return types means refactoring hundreds of functions and its too la...
but you can still do it... it's still manageable
deep mulch
but explicit return types means refactoring hundreds of functions and its too la...
never too late
valid jetty
the implicit return type also serves the purpose of ensuring all code paths return the same type (or an implicitly convertible one)
deep mulch
I'd do it
deep mulch
How the heck you want to know if the method is static or not without explicit se...
idk
maybe static fn
placid cape
don't make elle second javascript
deep mulch
Elle will have JavaScript concatenation
placid cape
idk
maybe static fn
yeah so keyword like in java
deep mulch
yss
winged mantle
huh
it's not really magic at this point it's in almost every language xD
and explicitly calling with :: looks like it would bypass virtual function
(idk if you have this feature but still..)
fleet cedar
"Many languages do it" doesn't mean it's not magic
deep mulch
@winged mantle kode tode
valid jetty
So `x.foo()` being the same as `X::foo(x)` is a good thing
yes i like that this is a thing
winged mantle
"Many languages do it" doesn't mean it's not magic
what would the problem be though
it's not like people will have trouble understanding it
I think having more ways to do the same thing is confusing
placid cape
So `x.foo()` being the same as `X::foo(x)` is a good thing
yea, it cna be a thing so why not allowing it
it's nice
deep mulch
it's useful if you have a local variable with the same name
meager solstice
i am currently making a python learning tool for the raspberry pi that helps others learn python 100% free and pretty easy!
fleet cedar
In rust the only difference between self and not is that you can call them with dot syntax
Nothing else
jade stone
im so good at performance 
valid jetty
do i allow strings to be values in the enum
formal belfry
popsicle
valid jetty
so you can doo
enum Bar {
Colon3 = ":3",
Abc = "abc"
};
enum EBar {
Colon3 = ":3",
Abc = "abc"
};
horror
formal belfry
peak
deep mulch
so you can doo
```rs
enum Bar {
Colon3 = ":3",
Abc = "abc"
};
```
maybe
enum Bar string
enum Bar<string>
spark tiger
til u can use windows executables inside wsl
jade stone
do i allow strings to be values in the enum
why not just allow any values
like enums in typescript
deep mulch
hm
fleet cedar
Yeah but TS is a completely different type system paradigm
Lattice based, rather than semiring based
deep mulch
as long as rosie doesnt implement something insane like
enum Guh {
a = 3,
b = "b"
}
hoary sluice
so you can doo
```rs
enum Bar {
Colon3 = ":3",
Abc = "abc"
};
```
elle enums???????????
placid cape
Do you want real enums or something rust's enums?
valid jetty
these are real enums
valid jetty
but the issue arises that i cant very easily account for offsets when the variants can be strings
fleet cedar
Enums are superior to named constants in every way
valid jetty
please make them castable to strings without implementing a switch case for ik
"{}".format(my_thing)
you cant #cast(string, my_thing) because thats an IR-level promotion demotion of types
placid cape
Elle macros/comptime when
deep mulch
Elle pre processor when
hoary sluice
@valid jetty i have to write a paper on 4g vs 5g until tomorrow and i have 0 idea where to even start
fuck this im just gonna watch italian brainrot compilations
valid jetty
valid jetty
<@581573474296791211> i have to write a paper on 4g vs 5g until tomorrow and i h...
horror
deep mulch
@hoary sluice will learn about 5g protocol
valid jetty
@deep mulch
deep mulch
i cant
deep mulch
i will fix elle syntax
valid jetty
whats wrong with it
hazy pine
<@289556910426816513>
this looks identical to rust
supple whale
const slice = threads[page] ??= client.threads(media.id, page)
deep mulch
rust 2
hoary sluice
<@289556910426816513>
pls dont assign costants to enums
thats not what enums were made for
enums are not a static hash map
if you want a static hash map you should use a static hash map
valid jetty
pls dont assign costants to enums
supple whale
welp i need to migrate to oxlint
esling is dying
my ts server is too
i'm running out of ideas
valid jetty
if you want a static hash map you should use a static hash map
this one is special in that you can only assign string, int, and char literals to it
i want to make it very restrictive
hoary sluice
nope literally die never using elle ever again
hoary sluice
this one is special in that you can only assign string, int, and char literals t...
omg so its a static hash map but it doesnt work for non primitive types
make enums be like in rust
rust did them perfectly
valid jetty
omg so its a static hash map but it doesnt work for non primitive types
pretty much
deep mulch
i beg dont use @repr thats so ugly
valid jetty
suggest syntax then
hoary sluice
copy rust
hoary sluice
rust literally has `#[repr(u8)]` for enums
i did see zoots msg
i was gonna say make enums without constant assignment, implement good pattern matching for them and then add rust like tuple values and struct enums or whatever theyre called
struct values?
valid jetty
enum Guh<char>
uhhhh i wanna save that for when i eventually do tagged enums with generics
hoary sluice
elle more like typescript
placid cape
What repr stands for?
valid jetty
representation
placid cape
Oh okay
valid jetty
the type of the underlying enum
hoary sluice
i thoght it meant reproducible in c
placid cape
I like it
formal belfry
@deep mulch be quiet!
deep mulch
uhhhh i wanna save that for when i eventually do tagged enums with generics
enum Guh(char)
idk
formal belfry
@deep mulch shut uuup
hoary sluice
@deep mulch sybau
placid cape
enum Guh(char)
python ahhhh extend class syntax
deep mulch
@hoary sluice
hoary sluice
i think its time to watch italian brainron compilations
valid jetty
ughhhhh i think its time for the cursed question
deep mulch
you are
hoary sluice
capybari cocosini
frosty obsidian
zeet disable huskbot
hoary sluice
ughhhhh i think its time for the cursed question
: what happened on 16/7/2024
deep mulch
zeet disable huskbot
never
frosty obsidian
there aren't 16 months idiot
hoary sluice
i remembered the date i didnt even need to check
deep mulch
ughhhhh i think its time for the cursed question
what happened on 07/16/2024
hoary sluice
there aren't 16 months idiot
america try not to be wrong challenge (impossible)
deep mulch
nop
valid jetty
how does (zig | go | jai | odin | v) do the syntax for repr of enums
placid cape
#cast(u8 is ulgy
It's better than ((u8) (...)), comptime function
placid cape
how does `(zig | go | jai | odin | v)` do the syntax for repr of enums
go doesn't have enums
valid jetty
go doesn't have enums
i know about that actually
placid cape
it's just a group of constants lol
deep mulch
infinitely better than the current syntax
frosty obsidian
zeet loves ts enums
deep mulch
zeet loves ts enums
nop
placid cape
it's just a group of constants lol
type Something int
const (
Abc Something = iota,
B,
C
)
go
deep mulch
@valid jetty add iota
placid cape
```go
const (
FOO = 2 * iota - 1 // 0
BAR, // 1
BAZ // 3
);
``` i so...
What do you like about it? the iota thing?
valid jetty
yeah the fact it scales for each constant
deep mulch
@frosty obsidian i wish kotlin enums had iota
placid cape
yea that's the only good thing about it
frosty obsidian
don't know what iota is
deep mulch
its the current value
placid cape
don't know what iota is
Number counter
valid jetty
its a counter
ok well i think actually im gonna leave enums like this for the time being
placid cape
Zig enums:
const Value2 = enum(u32) {
hundred = 100,
thousand = 1000,
million = 1000000,
next,
};
i have to write documentation + fix treesitter + other stuff
deep mulch
Zig enums:
```zig
const Value2 = enum(u32) {
hundred = 100,
thousand = 1...
interesitng
placid cape
deep mulch
does zig inline enums to the value?
valid jetty
Zig enums:
```zig
const Value2 = enum(u32) {
hundred = 100,
thousand = 1...
how does it know the growth factor
valid jetty
does zig inline enums to the value?
isnt that what every language does
enums are compile time sugar
deep mulch
not jvm
valid jetty
husk
placid cape
enum Color as u8 {
red // the default start value is 0
green // the value is automatically incremented to 1
blue // the final value is now 2
}
v 🤮
deep mulch
where comma
valid jetty
thats the same as elle except for the as u8
frosty obsidian
where comma
\n
hoary sluice
@valid jetty do you know how brr brr patapims court case is going
placid cape
how does it know the growth factor
It only increases by one and you can overwrite it, like in typescript
spark tiger
how does `(zig | go | jai | odin | v)` do the syntax for repr of enums
all i know about zig's enums is that you can do this and it's very convenient
valid jetty
enum Color @repr(u8) {
Red,
Green,
Blue
};
``` elleokay what about
valid jetty
all i know about zig's enums is that you can do this and it's very convenient
oh its like odin
frosty obsidian
all i know about zig's enums is that you can do this and it's very convenient
swift
spark tiger
oh its like odin
ig
placid cape
the attribute order doesn't matter or? @valid jetty
valid jetty
```rust
@repr(u8)
enum Color {
Red,
Green,
Blue
};
```
now its just rust but the # and @ are swapped around
deep mulch
elle already is rust
valid jetty
the attribute order doesn't matter or? <@581573474296791211>
nope order doesnt matter but it must be between the enum name and {
frosty obsidian
all languages have been made already
placid cape
nope order doesnt matter but it must be between the enum name and {
why
deep mulch
@frosty obsidian frog lang
placid cape
just capture all annotations and use them
valid jetty
thats just where its checked for
frosty obsidian
i would make my own language but i have too many other projects
deep mulch
annotations should be optional imo
placid cape
just capture all annotations and use them
Like java
valid jetty
annotations should be optional imo
noone is forcing you to @repr(u8)
if you dont it will just use i32
frosty obsidian
@deep mulch in my showperms rewrite i have every permission in one big enum and i use the ordinal as the shift amount
formal belfry
deep mulch
enum Color : u8 {
Red,
Green,
Blue
}
there's 51 permissions now
deep mulch
by far the best of all
placid cape
by far the best of all
don't agree
frosty obsidian
discord will run out at some point
deep mulch
that works
placid cape
show it
valid jetty
hm?
frosty obsidian
getting dangerously close to my idea
valid jetty
technically this is inconsistent with function return types and constants
if i were to make it consistent with constants it would be
enum u8 Color {
Red,
Green,
Blue
};
and with functions
enum Color -> u8 {
Red,
Green,
Blue
};
but both of those are bad
frosty obsidian
even closer to my bad idea
deep mulch
my idea best
frosty obsidian
zeet knows thats true
valid jetty
putting a colon when a colon is not used in like any other part of the language is pretty bad i think
hoary sluice
(λc.λr.λg.λb.c r g b) (λr.λg.λb.r) (λr.λg.λb.g) (λr.λg.λb.b)
this is the only real solution
valid jetty
i hate that i understand what you wrote
deep mulch
@valid jetty is an alien
valid jetty
@frosty obsidian what was your idea
frosty obsidian
i said u8 enum Guh as a joke earlier
hoary sluice
<@581573474296791211> is an alien
def red(r, g, b):
return r
def green(r, g, b):
return g
def blue(r, g, b):
return b
def match(one_of, r, g, b):
return one_of(r, g, b)
made it intentionally bad and zeet fell for it
valid jetty
theres only 3 problems in computer science
coming up with syntax for enums, cache invalidation, naming things, and off by one errors
hoary sluice
there are no problems in computer science
you can use bracket notation to compute everything
deep mulch
rosie knows everything
valid jetty
should i allow for bool literals
in enum defs
you can already do hex and binary and stuff because those are just lexing-time syntax sugar
placid cape
if i were to make it consistent with constants it would be
```rs
enum u8 Color {...
No
Keep the annotation
valid jetty
@repr?
valid jetty
idk i dont mind
im drawn to both @repr(u8) and just u8
though parsing that will be kinda annoying
placid cape
you can use bracket notation to compute everything
jsfuck
I would use annotation to keep consistent
hoary sluice
rosie knows everything
you can define any computation using only the iota combinator and parentheses, if you use () to denote iota then you can express any computation using only the characters ( and )
this is the identity combinator written using only ()
(()(())) (()(()))
Or I remember that you said you want something like Struct[alloc=...] {}
royal nymph
placid cape
in constructors
valid jetty
yeah
valid jetty
thats just inventing a second system for annotations tho surely
valid jetty
hmm ok
placid cape
Btw do you have hardcoded annotations?
deep mulch
jot
valid jetty
Btw do you have hardcoded annotations?
for now yes because they flip booleans or change things internally at the parsing stage
no need to over-engineer it
#[derive(Debug, Clone)]
pub enum Attribute {
// Allows an external function marked by this to be renamed to another symbol
Alias,
// Ensures a function marked by this is not cleaned up if it is never used
Volatile,
// Ensures no formatter is set by default on a struct marked by this
NoFormat,
// Automatically runs the formatter on every parameter of a function marked by this
Format,
// Representation of the inner type in an enum
Repr,
}
impl Token {
/// Ensures an attribute is valid and returns its enum variant
pub fn parse_attribute(&self) -> Attribute {
if self.kind != TokenKind::Identifier {
elle_error!(self
.location
.borrow()
.error("Tried to parse an attribute on a non-identifier token"));
}
let attribute = self.value.get_string_inner().unwrap();
match attribute.as_str() {
"alias" => Attribute::Alias,
"volatile" => Attribute::Volatile,
"nofmt" => Attribute::NoFormat,
"fmt" => Attribute::Format,
"repr" => Attribute::Repr,
_ => todo!("more attributes: {attribute}"),
}
}
}
👍
hoary sluice
rewrite the elle compiler in elle and then include the entire source code of the elle elle compiler in every elle program to allow elle users to use elle to rewrite elle elle syntax and then compile the elle elle compiler that the elle user just modified using the elle elle compiler to give them an elle elle compiler that compiles elle as they desire so you end up with elle elle macros without having to implement elle elle macros in the elle elle compiler
valid jetty
oh and for the record unwrap on get_string_inner is safe because tokens with the kind Identifier will always have a string value
valid jetty
rewrite the elle compiler in elle and then include the entire source code of the...
i love infinitely recursive quines
hoary sluice
i love infinitely recursive quines
but how is it a quine
placid cape
Which one do you like more? rust's macros or zig's comptime
hoary sluice
its like a rust proc macro except you modify the source code directly instead of via an exposed api named the "proc macro"
hoary sluice
Which one do you like more? rust's macros or zig's comptime
never used zig before
saw it like twice i think
valid jetty
Which one do you like more? rust's macros or zig's comptime
proc macros are amazing
hoary sluice
oh and for the record `unwrap` on `get_string_inner` is safe because tokens with...
use .expect
in case it isnt safe
valid jetty
it is absolutely safe
there are a billion asserts everywhere that Identifier will only ever have string
hoary sluice
use dioxus::prelude::*;
pub fn App() -> Element {
let mut count = use_signal(|| 0);
rsx! {
h1 { "High-Five counter: {count}" }
button { onclick: move |_| count += 1, "Up high!" }
button { onclick: move |_| count -= 1, "Down low!" }
}
}
use expect
this is the point of expect
you expect it to work
hoary sluice
what if you get a cosmic bit shift
valid jetty
i usually just use .unwrap_or_else(|| elle_error!())
hoary sluice
@placid cape ```rs
use yew::prelude::*;
html! {
<div>
<div data-key="abc"></div>
<div class="parent">
<span class="child" value="anything"></span>
<label for="first-name">{ "First Name" }</label>
<input type="text" id="first-name" value="placeholder" />
<input type="checkbox" checked=true />
<textarea value="write a story" />
<select name="status">
<option selected=true disabled=false value="">{ "Selected" }</option>
<option selected=false disabled=true value="">{ "Unselected" }</option>
</select>
</div>
</div>
};
this is valid rust
valid jetty
yeah !!! i love proc macros
valid jetty
```rs
use dioxus::prelude::*;
pub fn App() -> Element {
let mut count = use...
btw lmao
i accidentally dreamed up of that pattern on my own
fn main() {
rl::init_window(SCREEN_WIDTH, SCREEN_HEIGHT, "Counter :3");
defer rl::close_window();
rl::set_target_fps(60);
counter := 0;
while !rl::window_should_close() {
rl::begin_drawing();
defer rl::end_drawing();
rl::clear_background(BACKGROUND);
mouse_pos := rl::get_mouse_position();
render_button("Increment", 1, mouse_pos, &counter, fn(i32 *counter) { *counter += 1; });
render_button("Decrement", -0.35, mouse_pos, &counter, fn(i32 *counter) { *counter -= 1; });
render_button("Reset", -1.7, mouse_pos, &counter, fn(i32 *counter) { *counter = 0; });
count := "Counter: {}".format(counter);
rl::draw_text(count, (SCREEN_WIDTH - rl::measure_text(count, 40)) / 2, 100, 40, WHITE);
}
}
although not with move because screw move semantics
placid cape
<@525316393768452098> ```rs
use yew::prelude::*;
html! {
<div>
<div...
cool
well yeah that's not possible in zig
hoary sluice
i accidentally dreamed up of that pattern on my own
```rs
fn main() {
rl::in...
what abt it
valid jetty
i wonder if theres a neater way to approach that
hoary sluice
@valid jetty listens to this https://youtu.be/JWxYFXCInbg
supple whale
accurate statement
valid jetty
<@581573474296791211> listens to this https://youtu.be/JWxYFXCInbg
oh god you havent heard mc hammersmith before
look him up :)
hoary sluice
this is a remix of a song where one of the lyrics is unironically "i could never wifey an opp thot"
valid jetty
does stuff like "ive definitely got a gun" count
deep mulch
@valid jetty @valid jetty
nimble bone
@valid jetty
hoary sluice
https://open.spotify.com/intl-ja/track/6mpRf3jQb9K06ENY0OKtfe?si=f18e170c0fc64c6...
not a good mock cause its like old jazz or smth and not drill like the actual english rappers
valid jetty
not a good mock cause its like old jazz or smth and not drill like the actual en...
its meant to be satire
literally read the lyrics
hoary sluice
its meant to be satire
yes i know but the one i sent does it better cause it uses the same genre
hoary sluice
its not funny when he does it 713 times
valid jetty
why were enums so fucking easy to implement
i was expecting to spend a few days i did it in like 4 hours
though i guess theyre stupider enums because they cant hold a value but theyre still enums
deep mulch
@valid jetty hiii
formal belfry
bananas
jade stone
what even is this type????
jade stone
which is better
jade stone
which is better
@deep mulch @nimble bone @royal nymph
jade stone
deep mulch
```js
const importSourceId = ret[0];
names = ret[1];
```
yop
dawn ledge
i usually just use `.unwrap_or_else(|| elle_error!())`
should really make a trait for it
trait UnwrapElleError<T> {
fn unwrap_elle<F>(&self, f: F) -> T
where
F: FnMut(Location);
}
impl<T, E> UnwrapElleError<T> for Result<T, E> {
fn unwrap_elle<F>(&self, f: F) -> T
where
F: FnMut(Location)
{
// panic or whatever the macro does
}
}
this is great and all until you realize things can have more than just an on_click handler 😔
also immediate mode ui is pain
(personally)
valid jetty
```rs
trait UnwrapElleError<T> {
fn unwrap_elle<F>(&self, f: F) -> T
where
...
great idea
formal belfry
april 25 2025
fleet cedar
That is today
fleet cedar
Did you have hundreds of unaddressed lints or did you change your clippy settings
valid jetty
i changed my clippy settings
all + pedantic + nursery + cargo iirc
i wanted to go through them 1 by 1 because there was like 700 and i don’t wanna just apply random changes to my code that large
(i’m not done yet)
nimble bone
Top Track
Kitchen Wall Clock Ticking - Extended Version
ASMR Sound Studio
valid jetty
yeah i left it overnight for a day or two as sleeping noise before i realized
lol
thankfully i realized early enough that there aren’t that many scrobbles
nimble bone
Rosie sleep scrobbler...
valid jetty
i love breaking c abi..//
spark tiger
What They're Doing Is Very Smart but Also Very Dangerous…
fleet cedar
Yes
x.bar() is the same as X::bar(x)
Other than dot syntax implicitly adding & or &mut as needed
hoary sluice
`x.bar()` is the same as `X::bar(x)`
ty
hoary sluice
@valid jetty how do i handle result values that cant be err because the parser already makes sure its correct
fleet cedar
Why is it a Result if it can't be err
hoary sluice
Why is it a Result if it can't be err
in this case the parser looks for an identifier, thats the function name, then it checks if its followed by another TokenKind::Identifier and if its not it throws an error, then when the interpreter looks at the ast it sees a Token followed by a Token wrapped in a Expression::Call, both those tokens have kind = TokenKind::Identifier but the interpreter doesnt know that
fleet cedar
Sounds like your ast is insufficiently typed then
hoary sluice
yea it probably is
should i make the function name String
Assignment {
name: Token,
parameter: Token,
body: Box<Expression>,
},
vs
Assignment {
name: String,
parameter: String,
body: Box<Expression>,
},
well not actual string, itd be a string with a location
formal belfry
sigmalicious
fleet cedar
Types should always reflect what the variable contains
fleet cedar
So the name can be {
hoary sluice
kind is identifier, value is the string name
hoary sluice
So the name can be `{`
no thats rejected by the lexer
hoary sluice
yea it was easiest in the parser to just use token since what the parser sees is a token and just forwards it
so youre saying i should make a eparate type in the parser for identifiers
fleet cedar
Yes
If something has a specific type, then the type of the thing should reflect that
hoary sluice
same thing for functions then i guess
but idk
functions are wrapped inside Value and are siblings of Integer, Boolean, etc, so anything can evaluate to a function but inside the call evaluation i have to unwrap value even tho it can only be Function
i did not think about this when i designed the enums
oh wait it just work
s
nvm
ok identity functions and literals work
foo x = x
foo 3
foo x = 7
foo 3
bar y = foo y
foo x = x
bar 8
this returns 8
woohoo
valid jetty
now make recursion
valid jetty
you saw the talk you should know how ;3
hoary sluice
i know how but my code is ugly and i dont have nearly enough features to warrant recursion
i have literally only number / string / bool literals but no operations on them so to calculate anything you have to write out the lambda calculus implementation
valid jetty
well surely you make numbers and strings out of church notation right
making them just interpret to the right thing means the language isnt really purely functional unless 3 is sugar for \f x -> f (f (f x))
hoary sluice
making them just interpret to the right thing means the language isnt really pur...
thats slow tho
hoary sluice
well surely you make numbers and strings out of church notation right
i could yes
at least i hope
valid jetty
do it !!!!
the best thing about church numerals is that you can do stuff like for = \n x -> n x to loop
like for 3 (print "hi")
hoary sluice
nope i dont think i can
wait
idk
what should this evaluate to
b y = y
a x = b
a 3 4
4 right?
valid jetty
yes
hoary sluice
how do i make true in this
\x.\y.x is true right
im not completely sure if it preserver the environment but i intended for everything to be global
true1 y = x
true x = true1
true 3 4
ill try this in a bit
valid jetty
`\x.\y.x` is true right
yes
hoary sluice
ill try this in a bit
but the point isnt to play with alternate syntax named lambda calculus
hoary sluice
its to make sugar for it
valid jetty
but the point isnt to play with alternate syntax named lambda calculus
lmao
you should make a language like apl
i feel like if you properly learn it you can be faster than a functional lang
hoary sluice
is that the one uiua is inspired by
valid jetty
yes and bqn
formal belfry
banana
hoary sluice
i feel like if you properly learn it you can be faster than a functional lang
the goal isnt purely just to be faster at aoc i also just wanna make a language
hoary sluice
what should this evaluate to
```
b y = y
a x = b
a 3 4
`...
currying is one of the concepts of all time
i didnt think itd just work
valid jetty
the goal isnt purely just to be faster at aoc i also just wanna make a language
that’s what i said
valid jetty
you should make a language like apl
.
hoary sluice
that’s what i said
oh i thought u mean learn apl
what paradigm is apl
i mean i wanna make pretty much just sugary haskell with different monad/type handling
valid jetty
what paradigm is apl
functional iirc
or well
its a lot more terse
technically its an "array" language
but i think its still functional
valid jetty
@fleet cedar i can have a &Box<Option<Type>> where Type doesnt implement Copy
i can prevent cloning it and get a Option<&Type> without consuming the inner T by doing this
ty.as_ref().as_ref().map_or_else(|| name.into(), |ty| format!("{name}({})", ty.display()))
but as_ref twice is really ugly and i cant find a more concise way to do that
fleet cedar
How do you get a Box<Option<T>> in the first place? Generics stuff?
valid jetty
yeah
fleet cedar
I'd probably do Option::as_ref(ty).map_or_else to get those derefs happening automatically
valid jetty
the Enum type's rhs can optionally be the repr type which becomes Type::Word if it doesnt exist, ie
Type::Enum(String, Box<Option<Type>>)
i have to Box<T> it because Option<T> includes the size of the Type and if i dont itll be recursive without direction (infinitely sized)
valid jetty
I'd probably do `Option::as_ref(ty).map_or_else` to get those derefs happening a...
i see
fleet cedar
Option<Box<T>> is better than Box<Option<T>> if you can
meager solstice
Anyone here interested in learning python, java or html?
deep mulch
@valid jetty hii
valid jetty
@deep mulch minkscript when
deep mulch
<@289556910426816513> minkscript when
soon
valid jetty
this is so nice
- Self::Enum(_, inner) => inner.clone().map(|x| x.is_map_to_int()).unwrap_or(false),
+ Self::Enum(_, inner) => Option::as_ref(inner).is_some_and(Self::is_map_to_int),
@deep mulch loves java
placid cape
Anyone here interested in learning python, java or html?
why?
placid cape
Just asking, are you?
well i already know all of them
hoary sluice
Anyone here interested in learning python, java or html?
anyone here knows those already
main crypt
meager solstice
anyone here knows those already
There are people who don’t
And I just wanted to ask
hoary sluice
@valid jetty it works
