and also
async function* foo() {
yield 1;
yield 2;
}
const stream = Readable.from(foo())
stream.pipe(process.std.out)
if you NEED a stream for some nodejs API
#๐ช -progaming
supple whale
winged mantle
i can't work out where startsWith is implemented
supple whale
inside v8
so u wont find it
that's an ECMAScript native
so its inside v8 itself
winged mantle
i wonder whether there's a faster way to match any whitespace than to just use /\s+/
it probably doesn't matter that much but if i would rather not use regex if possible
median root
at least he hates java too ig
supple whale
it probably doesn't matter that much but if i would rather not use regex if poss...
do it
regex is stupidly fast in js
especially if you dont have any lookaheads or lookbehinds
which means you have O(n) where N is string length
but the operation cost is x100 lower since its native
formal belfry
ornate quiver
at least he hates java too ig
little does he know that any primitive value in generics becomes autoboxed
meaning Map<Integer, Integer> is all reference types
deep mulch
little does he know that any primitive value in generics becomes autoboxed
meani...
evil
valid jetty
@hoary sluice @placid cape uv mango in elle
and the code is beautiful
ok time to commit everything i did
deep mulch
@valid jetty is a mango
deep mulch
my bots
fleet cedar
@valid jetty how do you handle binary operator precedence?
royal nymph
dude buffer is so fucking slow
I was benchmarking js some while ago against C implementing some bruteforce password algorithm using byte[] and Buffer
js was so much slower
then i implemented the js one with raw U8Array over Buffer and it was like 60% of the C performance
obviously my implementations were probably not ideal but the fact that just switching from Buffer to U8Array made it get somewhat close to C was very eyeopening
dawn ledge
https://www.youtube.com/watch?v=sR1_Jwx6oHQ
first we had init
next a bootloader
and now a distro
the systemd bloat keeps on going
ornate quiver
real
supple whale
obviously my implementations were probably not ideal but the fact that just swit...
yeah, but keep in how old buffer is, it was made before any standards etc
and now it's legacy code that keeps losing perf to maintain compatibility
lavish frigate
the systemd bloat keeps on going
the b in systemd stands for bloat
winged mantle
regex is stupidly fast in js
it's crazy though
i guess it probably compiles the regex too so makes sense
it'd be interesting to see spidermoney results compared to v8 results
interesting how in firefox both are faster...?
but the loop is faster
why are we using v8 based node.js instead of spidermoney based idk... soda.js
winged mantle
maybe this is just a very unscientific test
on my desktop pc with loads of other programs open
but it's like night and day
in chromium i have to wait ages for the tests to complete and in firefox they're basically instant
so weird
maybe it's because i don't actually use the values
and spidermoney is smarter about ignoring unused code?
dense sand
<@581573474296791211> i aced the economics checkup
i got B again from derivations ๐ญ
i genuinely dont know where do i make mistakes
hoary sluice
i got B again from derivations ๐ญ
in what subject
dense sand
math
like the stuff was easy af, i was done like 2nd in the whole class, but i have 0 clue what i did wrong
hoary sluice
my eco teacher graded my test very unfairly (still a B) probably cause im never in class and she thinks i just go home but any time i skipped eco i was either sick or at an open day at a uni (4 times) and i told her that and she offered me to do a checkup
cause its on friday and open day is usually on friday
dense sand
atleast i think i aced the literature test(wow flashcards carried my ass) and waiting for results on my economics test too
hoary sluice
and in the first semester i had an A in eco and a B in another subject which i now fixed
hoary sluice
atleast i think i aced the literature test(wow flashcards carried my ass) and wa...
literature test???
hoary sluice
i thought u were slovak
dense sand
im thinking of buying markers so i can practice math on our whiteboard in class before school startsd
i haven nothing to do on dorms anyways
and writing it on paper is lame
hoary sluice
i might buy a remarkable tablet soon
im going to uni in september and im probably gonna pay attention in class cause its actually the stuff im interested in and not german or hardware development
like its cool and all but i really dont care about how to improve electromagnetic compatibility on a printed circuit board
dense sand
quite excited for my 4th year in HS, besides having to study for czech part of maturita, the stuff seems pretty exciting
i still have to pick my final project
i will either take some nextjs app or rewrite of my jvm to rust
hoary sluice
u have matura too??
dense sand
yes
dense sand
nicee, i want to go see the presentations of matura final projects
to see what people make
i know for a fact that my friend has a plain html/css website... ๐
4 years in hs for this
winged mantle
why are we using v8 based node.js instead of spidermoney based idk... soda.js
oh i had jit off in chromium lol
that makes more sense
that explains why regex was faster somehow
with jit on in vivaldi they are both the fastest
cool
hoary sluice
nicee, i want to go see the presentations of matura final projects
im in a 5 year technical high school (do u have those too?) and for our department theres an event organized where we present our projects and the 4th year can see them
last year someone made a rocket controller
hoary sluice
i know for a fact that my friend has a plain html/css website... ๐
theyre a lot cooler in a technical school
hoary sluice
unfair
we have a few specialists who have barely anything
but some are pretty cool
someone vibe coded a dashboard
dense sand
theyre a lot cooler in a technical school
yea i mean, it depends how much is the person motivated... teaching xampp and old school php in 2025 ๐คฎ
hoary sluice
he spent like 25โฌ on cursor doing vibe coding exactly as in the definition
hoary sluice
yea i mean, it depends how much is the person motivated... teaching xampp and ol...
we did that last year too
at least i can start in 3rd semester of uni so it wasnt wasted time
im probably gonna do a master or even a phd cause its literally just working on a hobby project while getting sponsored and paid a lot and you get a phd for it
dense sand
i should pickup some rust basics if i want to rewrite the vm...
leaden crater
he spent like 25โฌ on cursor doing vibe coding exactly as in the definition
i used cursor once trying to fix my code so it runs faster. it took almost 1 hour and the only optimization was that it runs 6x slower. idk how people can even use it
dense sand
omg pinning in rust seems like a cool concept i could utilize in heap expansion
hoary sluice
i should pickup some rust basics if i want to rewrite the vm...
what vm
hoary sluice
i used cursor once trying to fix my code so it runs faster. it took almost 1 hou...
i did a decent part of my voice assistant with ai (mainly boilerplate) and the only part it actually helped with besides reducing typing time was refactoring my local recorder to be synchronous and not unsafe
hoary sluice
OMG I GOT MARK 1(A) FROM CZECH LIT
what ur avg grade
dense sand
what ur avg grade
3.4
i hate czech
i skill issue so hard in this subject
like im sorry but how tf do i bang information about 20 authors and 30ish of their works into my head
leaden crater
pretty easy (coping) we do that here too
dense sand
im not the kind of person that could just remember things
leaden crater
i did a decent part of my voice assistant with ai (mainly boilerplate) and the o...
i guess that's good?
leaden crater
im not the kind of person that could just remember things
just go through some essaywork or something and read different things
supple whale
i guess it probably compiles the regex too so makes sense
nah it doesnt compile regex, it justs uses native code to operate on the string via a native regex engine
supple whale
why are we using v8 based node.js instead of spidermoney based idk... soda.js
because its more stable
it scales better with memory usage
its GC is way smarter
winged mantle
it turned out i had jit turned off in chromium
supple whale
spidermonkey starts eating shit the moment u start GC'ing anything
winged mantle
nah it doesnt compile regex, it justs uses native code to operate on the string ...
regex jit certainly does exist in some libs
hoary sluice
<@415132870252822539> what to use for rust dev
nvim
dawn ledge
actually good suggestion
dense sand
no
lavish frigate
:(
winged mantle
I don't understand how Map.get is faster than Array.find even if the first item is matched
maybe i made a mistake
royal nymph
I don't understand how Map.get is faster than Array.find even if the first item ...
it shouldnt be
in fact array is faster than Map for small amount of elements
winged mantle
yes
i would've thought
and this is a very small data set
it makes zero sense
i guess it's just the overhead of needing to do includes on each item
lavish frigate
array.find probably has a lot of overhead
winged mantle
for loop had same issue
what if i do indexof instead of includes
how is Map.get literally faster than [0]
i thin kthat's enough premature optimisation for today
placid cape
supple whale
how is Map.get literally faster than [0]
well.... yeah
js arrays arent actually arrays
typedarrays are
arrays, maps and objects are O(1)
just the O is different costs
winged mantle
but surely v8 is smart enough to actually store arrays as
[ptr to first value][ptr to second value]
in memory
supple whale
eeeeeeeeeh
not really
arrays in js are a piece of fucking wizardry
that noone understands
esp when it comes to spread iterables
and how weirdly fast they are
there's fuckery afloat, a lot of it
HMMMMMMMMM
ARE YOU SURE ABOUT THAT
winged mantle
it seems for of is faster than c style loop in js
wait nvm
it depends
super weird
lavish frigate
HMMMMMMMMM
status: | "CURRENT"...?
royal nymph
C for loop used to be much faster than es6 loops
but they fixed performance and now they're pretty close
winged mantle
it only seems to have a large difference wqith 1m items
at that point use postgres
supple whale
it seems for of is faster than c style loop in js
they are a LOT of slower
lavish frigate
my beloved
loop {
println!("loop");
}
but the utility they offer is unmatched
royal nymph
they are a LOT of slower
nah that's outdated
supple whale
nah that's outdated
trust, it aint XD
when iterating arrays its close to the same
when iterating ANYTHING else they are very slow
winged mantle
such as
supple whale
that said, i use for of exclusively
royal nymph
well yeah I meant array
winged mantle
you can't directly index raw iterators...
supple whale
for of Object.entries(), Object.keys(), Object.values(), Map.values(), Set.values()
supple whale
you can't directly index raw iterators...
yeah no shit!
since iterators are streams
royal nymph
in fact for (let i = 0; i < arr.length; i++) is probably slower than for of because it gets array.length each iteration
supple whale
not precalculated data
winged mantle
yeah lol
supple whale
in fact `for (let i = 0; i < arr.length; i++)` is probably slower than for of be...
nah v8 optimises that
winged mantle
for of Object.entries(), Object.keys(), Object.values(), Map.values(), Set.value...
in that case the alternative is not a C style for loop pretty sure
it's for in
royal nymph
maybe it does 
I wouldn't rely on it
royal nymph
for of is clearer intent than C for loop
supple whale
i benchmarked the fuck out of this, because i made a 3d rendering library which did 100 mil iterations per frame
supple whale
for (let i = 0; i < images.length; ++i) is the fastest loop u can get in js
i ended up moving the iteration code to WASM tho, faster
winged mantle
yes isn't the bottleneck just the fact is has to allocate pointless arrays
supple whale
it doesnt rly matter
winged mantle
(albeit for a more pleasant programming experience)
winged mantle
what about map
supple whale
even object[8001] = value eats shit
supple whale
what about map
no problems there
which is why i made https://www.npmjs.com/package/object-like-map
winged mantle
i just try to avoid using objects if it's something with dynamic keys
supple whale
just so i can use a map like an object
royal nymph
people love abusing objects
winged mantle
due to concerns with bugs
supple whale
import olm from 'object-like-map'
const myOLM = olm({ first: 1, second: 2 })
const third = myOLM.third = 3
const exists = 'first' in myOLM
delete myOLM.second
for (const [key, value] of myOLM) {
console.log({ key, value })
}
myOLM.clear()
console.log(myOLM.size)
i see people do EnumName[key as keyof typeof EnumName] and this has a bug i found
i mean i'm sure other people found it but they weren't commenting about it on stackoverflow for some reason
winged mantle
people do that to "parse" an enum but obviously if you pass constructor or __proto__ it will give you something different
ah
i wish i'd known about that
supple whale
void decodeBitmap(double alpha, size_t *data, ASS_Image *img, int w, int h) {
uint32_t color = ((img->color << 8) & 0xff0000) | ((img->color >> 8) & 0xff00) | ((img->color >> 24) & 0xff);
uint8_t *pos = img->bitmap;
uint32_t res = 0;
for (uint32_t y = 0; y < h; ++y, pos += img->stride) {
for (uint32_t z = 0; z < w; ++z, ++res) {
uint8_t mask = pos[z];
if (mask != 0)
data[res] = ((uint32_t)(alpha * mask) << 24) | color;
}
}
}
ah yes
good old times
i love bitwise hacks
supple whale
what's the best way to do an enum lookup table
not use an enum
enums in js dont work
still jolt
my horrible js code only takes ~7.5s to parse a 250MB text file 
winged mantle
```cpp
void decodeBitmap(double alpha, size_t *data, ASS_Image *img, int w, int ...
ass image
winged mantle
my horrible js code only takes ~7.5s to parse a 250MB text file <:blobcatcozysta...
i feel like that could be faster
royal nymph
my horrible js code only takes ~7.5s to parse a 250MB text file <:blobcatcozysta...
slow
winged mantle
supple whale
my horrible js code only takes ~7.5s to parse a 250MB text file <:blobcatcozysta...
my js takes <2s to parse a 1.8GB video file
:DDDDD
winged mantle
my js is literally just parsing commands but i wanted to microoptimise it because yes
royal nymph
nop ASS is for subtitles
still jolt
my horrible js code only takes ~7.5s to parse a 250MB text file <:blobcatcozysta...
tbf most of the time is (probably) just spent doing ```js
const lines = text.split('\n');
horror
supple whale
nop ASS is for subtitles
yes, this is indeed the topic of conversation
royal nymph
tbf most of the time is (probably) just spent doing ```js
const lines = text.spl...
why the hell are you reading the entire string into memory instead of streaming
there's your problem
winged mantle
yea
still jolt
why the hell are you reading the entire string into memory instead of streaming
laziness โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
winged mantle
i don't know how you'd read a line at a time in js
supple whale
laziness โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
async iterators sir
winged mantle
aren't streams event based
supple whale
async iterators for streaming data are bae
winged mantle
*in node
supple whale
supple whale
aren't streams event based
yes**
still jolt
horrorcode
royal nymph
const fileStream = fs.createReadStream('input.txt');
const rl = readline.createInterface({
input: fileStream,
crlfDelay: Infinity
});
for await (const line of rl) {
// Each line in input.txt will be successively available here as `line`.
console.log(`Line from file: ${line}`);
}
sublime text*
winged mantle
```js
const fileStream = fs.createReadStream('input.txt');
const rl = readlin...
oh ofc
still jolt
but yes, monocraft my beloved
supple whale
```js
const fileStream = fs.createReadStream('input.txt');
const rl = readlin...
yes but no
readline is really bad
winged mantle
it's funny how bad reading from stdin in node is
supple whale
because it fucks chars
supple whale
because it forces some weird char map
which isnt uft8
and it can break a LOT of shit
supple whale
```js
const fileStream = fs.createReadStream('input.txt');
const rl = readlin...
i ended up having to do:
async function * findByteSequence (sourceIterator: AsyncIterable<Uint8Array>, targetSequence: Uint8Array) {
// not great but good enough
const buffer = []
let targetLength = targetSequence.length
let matchIndex = 0
for await (const chunk of sourceIterator) {
for (const byte of chunk) {
buffer.push(byte)
if (byte === targetSequence[matchIndex]) {
matchIndex++
if (matchIndex === targetLength) {
// Sequence found, yield all data up to but not including the sequence
if (buffer.length > 0) {
targetSequence = yield new Uint8Array(buffer.slice(0, -targetLength)) || targetSequence
}
buffer.length = 0 // Clear the buffer
matchIndex = 0
targetLength = targetSequence.length
}
} else {
matchIndex = (byte === targetSequence[0]) ? 1 : 0
}
}
}
if (buffer.length > 0) yield new Uint8Array(buffer)
}
yeah its for spliting data streams by a specific byte
i needed it when implementing the NNTP protocol
cuz nntp is "hey here's some utf8 text data, WOOP NEVER MIND RAW BINARY NOW"
and using textdecoder with "stream: true" and appending a single byte at a time is too slow
when u want to truput gigabytes of data per second
valid jetty
in fact `for (let i = 0; i < arr.length; i++)` is probably slower than for of be...
for (let i = 0, len = arr.length; i < len; ++i)
leaden crater
why use zed/nvm when you can use nano ๐ฅ
valid jetty
do i do this????
"An infinite loop was detected while parsing xyz.
This is an internal bug. Please report it at <issue url>"
lavish frigate
do i do this????
what if someone needs an infinite while loop...
valid jetty
no no not that
hard cap on while loops in the compiler not on code written in elle
like here
loop {
if self.parser.current_token().kind == TokenKind::LeftCurlyBrace {
nesting += 1;
}
if self.parser.current_token().kind == TokenKind::RightCurlyBrace {
if nesting > 0 {
nesting -= 1;
} else {
break;
}
}
self.parser.advance();
}
``` it could potentially never stop
jade stone
@deep mulch i wonder if it would be possible to rewrite sadanify native in c#
from c++
dense sand
would it be possible to have enum in rust with entries having structs which reference other structs?
something like in C:
struct ComplexStructure {
uint8_t tag;
union {
struct A {
const char *data;
}
struct B {
A *a;
}
struct C {
A *a;
}
}
}
in rust something basically based on:
#[derive(Debug)]
pub enum ConstantPoolEntry {
Utf8(str),
Class {
value: /* reference to Utf8 */,
},
String {
value: /* reference to Utf8 */,
},
}
Sure, that's what references are
dawn ledge
like here
```rs
loop {
if self.parser.current_token().kind == TokenKind::Lef...
i mean, realistically youre never gonna have the real estate to parse a file at the size of like u64::MAX
1800 petabytes goes hard
dawn ledge
i mean, realistically youre never gonna have the real estate to parse a file at ...
id go as far as to say u32::MAX
no way you have a file thats 4 gigs
valid jetty
i just check is_eof() lol
dawn ledge
works too ig
lucid trail
hii @valid jetty your stdlib is missing a comma at std/collections/hashmap.le line 42
lucid trail
iโm writing a tree sitter grammar for it and just so happened to pick that file to parse
dawn ledge
or well, rather, the parser
jade stone
insnae
lucid trail
yeah i was like how does that even compile
valid jetty
or well, rather, the parser
because it parses until , instead of parsing an expr (which im moving towards)
dawn ledge
https://github.com/acquitelol/elle/blob/rewrite/std/collections/hashmap.le#L50-L53
duplicate __internal_key_exists_check call since HashMap::get also calls it
pearl stagBOT
https://github.com/acquitelol/elle/blob/rewrite/std/collections/hashmap.le#L50-L...
hashmap.le: Lines 50-53
fn HashMap::__load__<T, U>(ElleMeta meta, HashMap<T, U> *self, T key) {
__internal_key_exists_check(self, key, meta);
return self.get(key);
}
just use crystal, the best language
File.each_line(file) do |line|
puts line
end
also would be nice if it like returned null or threw an exception (if thats a thing in elle) instead of straight up aborting
dense sand
@valid jetty whats your opinion on heap defragmentation
lucid trail
also would be nice if it like returned null or threw an exception (if thats a th...
there's safe_get
valid jetty
https://github.com/acquitelol/elle/blob/rewrite/std/collections/hashmap.le#L50-L...
nop its not duplicate, if you do it from within .get the location of the error will be in __load__ instead of the caller's location, you dont have this problem when you call .get directly
lucid trail
although get being safe by default and having unsafe_get would probably be better
valid jetty
true
dawn ledge
nop its not duplicate, if you do it from within .get the location of the error w...
wdym, get already does it tho
valid jetty
yeah but uhhh
jade stone
Also what is it even compiling here, cef is distributed in shared object form
Are the rust bindings really that big
dawn ledge
things don't take years to build
millennias yeah
dawn ledge
Also what is it even compiling here, cef is distributed in shared object form
compiling function defs or something ig :^)
jade stone
i want to port my spotify mod to rust
but for that, it needs to dynamically link to libcef with cef-rs
valid jetty
wdym, get already does it tho
foo[1];
calls foo.__load__(1)
if that calls .get directly and it fails, the error wont be at foo[1] itll be at foo.__load__'s definition because thats where the ElleMeta was generated for .get
jade stone
so im seeing if cef-rs supports that
valid jetty
if i do a second bounds check and it fails inside of foo.__load__, the error will be generated at foo[1] because the ElleMeta was generated there
dawn ledge
```rs
foo[1];
```
calls `foo.__load__(1)`
if that calls .get directly and it fa...
time to clone rust's track_caller api!
valid jetty
time to clone rust's track_caller api!
lmao true
dawn ledge
jade stone
@valid jetty does elle have destructing
valid jetty
there is a GC, but if you use a different allocator you can also just create a Foo::free and ```rs
foo := Foo::new(1, 2, 3);
defer foo.free();
i did the same thing that rust does
dawn ledge
well borrow checker is indeed a pain in the ass to use and implement
valid jetty
lmao yep
dawn ledge
i did the same thing that rust does
isnt that just for the map["foo"] syntax, while map.get is Option<T>
Option<&V> apparently
valid jetty
oh, yeah i can set up that interface
get will become unsafe_get and safe_get will become get
dawn ledge
why is it building again
cause it hates you ๐
leaden crater
why is it building again
enjoy 200% cpu usage
dawn ledge
remind me why do you need cef
fleet cedar
Wait, elle parses binops by finding and splitting on the lowest-precedence op in the input, and then parsing the halves ๐ญ?
jade stone
remind me why do you need cef
it's what spotify is built on ๐ญ
fleet cedar
Or am I misunderstanding the code
dawn ledge
slap the syntax in tree-sitter and use it for parsing
fleet cedar
Insane
valid jetty
yes but on the tokens which makes it less insane
would be funnier if i did it on the source code
fleet cedar
yes but on the tokens which makes it less insane
Only slightly
Still a majorly insane parsing method
jade stone
is it possible to build a shared object with rust
valid jetty
Still a majorly insane parsing method
the parser is dearly missing a rewrite
fleet cedar
valid jetty
yeah a parse_expr would probably be sane
that just looks like a standard recursive descent
fleet cedar
Yeah pretty much, other than preprocessing into token trees
But I think my precedence handling is pretty elegant
valid jetty
yeah definitely lmao
jade stone
why is cargo trying to build both an executable and a shared library
fleet cedar
You are correct that cdylibs are more bin like than lib like, but don't think that can be changed at this point
Maybe with a new edition, so 2027 at earliest
jade stone
guhhh i managed to fix it
fleet cedar
Better solution is usually to use the standard layout
royal nymph
guhhh i managed to fix it
lavish frigate
royal nymph
sadan is a conservative so he doesn't wanna name it lib
jade stone
guhh is there no hooking lib for windows on rust
i cant find up to date bindings for detours either
insane
fleet cedar
?crate retour
leaden crater
@valid jetty can you help a bit (very hard)
jade stone
?crate retour
nop
fleet cedar
Yes
fleet cedar
Yeah but nobody uses arm do who cares
jade stone
Yeah but nobody uses arm do who cares
please enlighten me on how i'm supposed to use it then
fleet cedar
If you intentionally use an obscure arch, that's on you
valid jetty
<@581573474296791211> can you help a bit (very hard)
depends with what lol
leaden crater
depends with what lol
So i have some number suffixes and want to apply them to other number suffixes in an elegant manner. do you know how i could do that without writing everything down by hand
jade stone
If you intentionally use an obscure arch, that's on you
lol this is just a rust issue
with c/c++ you can easily do this
and arm isnt obscure lol
valid jetty
So i have some number suffixes and want to apply them to other number suffixes i...
uhhh do you have any more detail
jade stone
it doesnt even support modern macos
fleet cedar
It's not a language issue
valid jetty
there are a lot of ways i can interpret that lol
fleet cedar
It's a "probably hundreds of contributors for many years" issue
leaden crater
uhhh do you have any more detail
k m b t qd qn sx sp o n
de ud dd tdd qdd qnd sxd spd ocd nvd
vgn uvg dvg tvg qtv qnv sxv spg ovg nvg
tgn utg dtg tstg qttg qntg sxtg sptg octg nvtg
qddr uqdr dqdr tqdr qdqdr qnqdr sxqdr spqdr ocqdr nvqdr
qqgnt uqgnt dqgnt tqgnt qdqqnt qnqgnt sxqgnt spqgnt ocqgnt nvqgnt
sxgnt usxgnt dsxgnt tsxgnt qdsxgnt qnsxgnt sxsxgnt spsxgnt ocsxgnt nvsxgnt
spgnt uspgnt dspgnt tspgnt qdspgnt qnspgnt sxspgnt spspgnt ocspgnt nvspgnt
ocgnt uocgnt docgnt tocgnt qdocgnt qnocgnt sxocgnt spocgnt ococgnt nvocgnt
nvgnt unvgnt dnvgnt tnvgnt qdnvgnt qnnvgnt sxnvgnt spnvgnt ocnvgnt nvnvgnt
centillion (e303)
uncentillion (e306)
! let centillion = c
----> write them out to console with a comma until nvnvgntc
! Also let a centilliard = 1000 nvnvgntc = cd
----> write them out to console with a comma until nvnvgntccd
... i got no more ideas after this :p
maybe im not making sense
valid jetty
lol nope i have no idea what youโre talking about
jade stone
is there a way to do a constant array in rust without having to change the length every time i add something
fleet cedar
Make it a &[&str]
hoary sluice
@royal nymph https://youtu.be/z_itQLvQxtk
i wanted to ping rosie how did it ping vee
???
@valid jetty
dont mind the upload date
hoary sluice
did you watch the video
valid jetty
is there a way to do a constant array in rust without having to change the lengt...
pub static RESERVED_KEYWORDS: &[&'static str] = &[
"as", "mut", "enum", "match", "static", "super", "do", "macro", "step", "of", "class", "var",
"impl", "type"
];
just make it &str
and you also need & on the array on the rhs iirc
jade stone
is it possible to do something like this
dawn ledge
yeah if youre just adding things then go with concat
lavish frigate
my solution wasnt completely atrocious?
dawn ledge
although idk if concat accepts identifiers
lavish frigate
it doesnt
dawn ledge
yep then const_format is what you need
jade stone
https://docs.rs/const_format/latest/const_format/
why the fuck do you need a crate for this 
dawn ledge
what do you not need a crate for
jade stone
what do you not need a crate for
string formatting
spark tiger
why is format! not able to do so 
spark tiger
can't you do like .to_string() or something
spark tiger
the fact that you need a 3rd party crate for that sounds so dumb to me
jade stone
thats what im saying
jade stone
how do you create a top-level variable if let is a syntax error and const / static require constant expressions
jade stone
concat! no?
concat isn't formatting
valid jetty
whatโs stopping you from just doing concat!(โdisloโ, TARGET) tho donโt you get the same result
jade stone
i dont want to have to chain 3+ to get what i want
valid jetty
hm
valid jetty
how do you create a top-level variable if `let` is a syntax error and const / st...
you create a static mut and do unsafe assignment to it from within the main function probably
jade stone
you create a static mut and do unsafe assignment to it from within the main func...
are you joking
jade stone
love rust's learning cliff
valid jetty
itโs probably just hard because top level variables are bad practice
dawn ledge
or is that only for literals
literals yeah
dawn ledge
you create a static mut and do unsafe assignment to it from within the main func...
just use const_format atp
i would only use LazyCell or mut static vars if the data is like dynamic or cant be constant at all
if its just simply a string that wont change i'd much rather cope with adding an extra dependency
what does 2 more do to an already insane amount of 300
valid jetty
@jade stone
dawn ledge
please jeez this is even worse
valid jetty
its beautiful
you can just write a macro to get the value out idk
once_cell is in std now you can probably just use that even
dawn ledge
X Y ahh solution
jade stone
what does 2 more do to an already insane amount of 300
Now you're thinking in javascript!
hoary sluice
@valid jetty how do u handle linebreaks in codeblocks in typst
dawn ledge
both bloated
dawn ledge
<@581573474296791211> how do u handle linebreaks in codeblocks in typst
like normal?
valid jetty
use std::cell::OnceCell;
let cell = OnceCell::new();
assert!(cell.get().is_none());
let value: &String = cell.get_or_init(|| {
"Hello, World!".to_string()
});
assert_eq!(value, "Hello, World!");
assert!(cell.get().is_some());
what
hoary sluice
like normal?
ah ok thanks ill do it like normal
jade stone
how would you do something like this
valid jetty
why is it not doing that automatically wth are you doing lol
hoary sluice
why is it not doing that automatically wth are you doing lol
what am i supposed to do
valid jetty
oh because youre returning it from the closure
hoary sluice
https://typst.app/docs/reference/text/text/#parameters-hyphenate
i dont want hyphens
winged mantle
valid jetty
i wonder if you do
#show raw.where(block: true): block.with(
width: 100%,
)
that might not work actually
dawn ledge
how would you do something like this
.as_str()
hoary sluice
#raw(
"username:\u{2060}$6$VH6ZrhwD0XmxmZYH$ftK/\u{2060}droDPnK6loNiY7GeUvXki0u39CjZk4qHb41Ubm5uH6Qfm8BGDjVyFhGuGuUpV.IoLdGGDbgHu7C0wuzK1:1006:1006::/home/username:/bin/sh",
)
isnt word joiner counter intuitive
hoary sluice
idc i want it to break the hash across lines
dawn ledge
you do it manually then
jade stone
how can you return a Path if it doesn't have a known size and a reference would be dropped
hoary sluice
you do it manually then
im using typst specifically not to do that
might as well write it with a pen on paper and scan it
dawn ledge
how can you return a `Path` if it doesn't have a known size and a reference woul...
you make a variable
|name| {
let file = format!("{name}.cpp");
Path::new(&file)
}
same error
jade stone
i'm aware, but i'd rather fix the error first
valid jetty
wait yeah why are they manually adding the extension lmao
i just noticed that
@nimble bone
jade stone
that works, but it's fucking insane that you have to do it that way
valid jetty
with_extension is saner actually
because you can pass into it /foo/bar/baz.xyz and with_extension will replace the xyz with something else for you
jade stone
its more that the docs suck
valid jetty
(iirc)
dawn ledge
because you can pass into it /foo/bar/baz.xyz and with_extension will replace th...
yop
valid jetty
i use it in elle to maintain the same path but put the IR and executable in the same place with the same name but different extension its useful
dawn ledge
jade stone
when i run into an error and can't find anything on google, i don't want to have to look at every method to see if there's something that might come in handy
esp. in rust where viewing the LSP is the worst ive ever used for listing methods on an object
valid jetty
only annoying thing is turning a path back into a string kinda sucks
path.to_str().unwrap().to_string() โค๏ธ
jade stone
(more about the LSP being ass when it comes to viewing methods on something unless theres a way to do it that i don't know)
dawn ledge
its not really that hard, just open up the docs for path and ctrl+f extension
well ig if im running into an error saying size cannot be known and my solution is to use a random method on path its not really that intuitiv
dawn ledge
but then again it links up once you understand why its throwing the error
str ref -> (formatted) String -> converted back to a ref and returned but also being dropped -> dont allocate a String that drops -> look for extension api
valid jetty
a beginner-ish rust developer is NOT gonna think like that lmao
jade stone
but then again it links up once you understand why its throwing the error
str re...
||tbh i didnt even think something like with_extension was a thing as i've never used it in any other lang i've used||
how am i supposed to think like that when i'm starting out.
how am i supposed to learn and gain experience to be able to thing like that when i need to think like that to do basic things
valid jetty
read the rust book
jade stone
i tried, it sucks
valid jetty
(i say that while having not read it)
jade stone
*not that it's bad, but it didn't help me
dawn ledge
honestly i havent read the rust book
valid jetty
idk the best way to learn is to just get into the depths of a big project in rust and come across times when you need that kind of knowledge
dawn ledge
my entire process of learning a language is fuck around and find about
jade stone
what would be nice is common patterns in other languages and how they're best done in rust
valid jetty
then once you learn it it becomes engraved in your head because you think you might need the info later on
jade stone
and just basic thing side by side
valid jetty
my entire process of learning a language is fuck around and find about
EXACTLY
thats what i do
dawn ledge
i always learn "good practices" and "conventions" last when learning a language
that shit just stalls you
valid jetty
thats why i know like 5 languages to varying degrees lmao
dawn ledge
lol
valid jetty
all modern languages are basically the same except for syntax
its just small differences in semantics and conventions (although rust is quite different)
jade stone
my entire process of learning a language is fuck around and find about
yea, same. but how am i supposed to do that when i run into things like this often when learning rust that take an ungodly amount of time compared to other languages.
valid jetty
things like swift, js, C, py, objc, ruby, go, php
even though there are differences
you can do the same thing more or less a similar way in all of them
valid jetty
yea, same. but how am i supposed to do that when i run into things like this oft...
rust is a very "production" language
ive heard people go to prototype in other languages like python then move to rust to build the production thing
because rust has a lot of boilerplate you cant really let your developer freedom run when prototyping in rust because youll constantly get yelled at
dawn ledge
i am not a productive person
even much less in rust
idek why i like rust so much atp
dawn ledge
ive heard people go to prototype in other languages like python then move to rus...
yeah i do this
prototype in js/py
valid jetty
i like rust because it feels very polished compared to other languages
jade stone
ive heard people go to prototype in other languages like python then move to rus...
that's not what i'm really talking about and you still have the same issue
valid jetty
everything just clicks into place
valid jetty
that's not what i'm really talking about and you still have the same issue
thats what i meant tho
you run into those issues when writing the "production" version of the code and thats when you learn
dawn ledge
yea, same. but how am i supposed to do that when i run into things like this oft...
you are an llm
you are being put through regression training
suffer
valid jetty
you dont need to use another language its just a common thing for people to do
fallen nebula
fun fact : pressing the ' key on French Azerty Keyboards create this error in the log of discord
react_devtools_backend.js:4026 [KeyboardLayoutMapUtils] KeyboardMapper - Key code mismatch for key ': 222 !== 52
you can just always write in rust, learn and understand its pitfalls, and eventually be able to prototype in it
there is a reason everyone says rust has a very high learning curve
jade stone
fun fact : pressing the `'` key on French Azerty Keyboards create this error in ...
that looks like a logged error, not something thrown
dawn ledge
you run into an error
you look it up
if you dont find a solution you ask around, just like you did here
and then you find the solution
and it goes to your mental library
and slowly you start picking up patterns
fallen nebula
that looks like a logged error, not something thrown
yeah just some log, it doesn't seem to do anything
fallen nebula
you run into an error
you look it up
if you dont find a solution you ask around,...
basically how you learn to code indeed
valid jetty
that can be said for any langauge but especially in rust
jade stone
you run into an error
you look it up
if you dont find a solution you ask around,...
yes, that's what i do with all languages
but it's hard when rust takes at least 2x as long, if not more
because when it takes that much longer, it's a lot easier to lose motivation and give up
dawn ledge
its gonna get easier over time
valid jetty
yes, that's what i do with all languages
but it's hard when rust takes **at lea...
but then you cant say "written in rust btw"
and anyway, once rust becomes engraved in your head, youll see that the errors from the compiler are actually very helpful lmao
dawn ledge
the rust learning curve is
/\____
until you get to async
then you get euler spirals
valid jetty
async rust is NOTHING like normal rust
fuck async rust whoever came up with Pin<Box<dyn Future: Send> is insane
jade stone
fuck async rust whoever came up with `Pin<Box<dyn Future: Send>` is insane
WHAT IS THAT
i know what pin is
idfk what box is
fallen nebula
yes, that's what i do with all languages
but it's hard when rust takes **at lea...
i think that's an issue with some people
personally i'm learning rust rn
like reading the book and trying things out
but i don't think i'll get a lot this way, i'll just start to get a basic feeling
the way i'll truly learn is when i'll truly decide to code some project in it
also the time spent learning doesn't matter, because you should be constantly learning
i'm currently an intern at some place because it's needed to finish my bachelor and i actually did make my internship master learn things, because i had knowledge that i did just bring in
on the other hand, i'm learning a hella lot because i'm doing OOP typed python stuff that i had never done
valid jetty
i know what pin is
idfk what box is
box is just a safe heap allocated pointer
lmao
jade stone
is dyn Future: Send a triat that extends send
valid jetty
Send is a trait
formal belfry
valid jetty
Future is a struct iirc, dyn allows for dynamic dispatch
you can have a Result<(), dyn Error> to allow for ANY error resolved at runtime
uhhhh probably not a good idea to worry about that now
the rabbit hole extends far
jade stone
Future is a struct iirc, `dyn` allows for dynamic dispatch
whats dynamic dispatch 
i might know what it is, but ive never heard that name
dawn ledge
Future is a struct iirc, `dyn` allows for dynamic dispatch
nah its a trait
you cant dyn a struct
valid jetty
oh wait yeah
dawn ledge
since its meant for traits
valid jetty
whats dynamic dispatch <:wires:1262562427422244874>
i might know what it is, bu...
uhhhh basically the type is resolved at runtime
so like in js you can have a
function add(x, y) {
return x + y;
}
assert(add("a", "b") === "ab");
assert(add(1, 2) === 3);
its similar to that
its kinda in the name, "dispatch the right thing dynamically based on the type (at runtime)"
dawn ledge
probably
valid jetty
allows for any type that implements the Future and Send traits
dawn ledge
to maintain my sanity i have never looked at async types
valid jetty
jade stone
its `dyn Future + Send` right
Is there a colon operator for types then
jade stone
valid jetty
you can specify that something is bound by multiple traits via +
valid jetty
it does lol
jade stone
it does lol
How
dawn ledge
X: Y is basically X implements Y
valid jetty
just make a trait and impl that trait for your struct
although some built in structs dont allow for trait extensions
jade stone
just make a trait and impl that trait for your struct
Iirc that doesn't work with name collisions
valid jetty
oh you wanna override existing methods?
jade stone
oh you wanna override existing methods?
No
dawn ledge
a generic T defined as where T: Clone would mean whatever T is, it implements clone
valid jetty
^
jade stone
I'll send a kotlin example when I get home
valid jetty
okk
dawn ledge
although some built in structs dont allow for trait extensions
rust orphan rules yeah
valid jetty
you can do this in elle because fuck orphan rules
jade stone
a generic `T` defined as `where T: Clone` would mean whatever T is, it implement...
Yea, I've seen where clauses and managed to piece together what it means
valid jetty
oh my god they blocked the cat word with 2 ws
fn u32::cat_word(u32 self) {
for i in 0..self {
$println("cat_word");
}
}
fn main() {
39.cat_word();
}
you can do that]
just in your main entrypoint
valid jetty
Yea, I've seen where clauses and managed to piece together what it means
tbf it doesnt NEED to be where
idk why theres 2 ways to write it but there is
lavish frigate
https://fixupx.com/tsoding/status/1910622956838932718
ill do this with vee
valid jetty
fn foo<T>(x: T) where T: Clone {}
OR
fn foo<T: Clone>(x: T) {}
rust doesnt give a fuck about same identifiers
struct Foo {
bar: u32
}
impl Foo {
fn bar(&self) -> u32 {
self.bar + 123
}
}
trait Bar {
fn bar(&self) -> u64;
}
impl Bar for Foo {
fn bar(&self) -> u64 {
u64::MAX
}
}
fn main() {
let foo = Foo { bar: 123 };
println!("{}", foo.bar);
println!("{}", foo.bar());
println!("{}", <Foo as Bar>::bar(&foo));
}
the magic of rust i guess
dawn ledge
```rs
fn foo<T>(x: T) where T: Clone {}
```
OR
```rs
fn foo<T: Clone>(x: T) {}
`...
i personally prefer having where clauses instead of elongating my function signature
dawn ledge
since Foo has a bar function i have to hint the compiler that im invoking the bar function from the Bar trait implementation of Foo instead of Foo's own implementation
dawn ledge
it works too
valid jetty
thats a thing in elle too iirc but not the 3rd one :3
dawn ledge
but what is the <>
its like turbofish
but inverse
like how you'd write Foo::foo(&foo) but you need to cast it to Bar but you cant use () instead you have to use <>
leaden crater
it works too
is this rust playground
dawn ledge
dawn ledge
is this rust playground
yes
valid jetty
woooo slay
valid jetty
like how you'd write Foo::foo(&foo) but you need to cast it to Bar but you cant ...
horror
dawn ledge
valid jetty
traits feel a lot like partial classes in c#
dawn ledge
you can also choose to write Trait::function instead of <Type as Trait>::function
but i like the latter since its more concise
valid jetty
where you define a piece of a class
dawn ledge
i usually see traits as interfaces in ts
valid jetty
i see traits as abstract classes but is there really a difference between that and interfaces
dawn ledge
brainrot terminology has ruined typescript abbreviation for me
dawn ledge
i see traits as abstract classes but is there really a difference between that a...
cant write function bodies in interfaces :^)
valid jetty
i guess
i mean i guess it is really similar to interfaces
because you can do like class Foo implements Bar
in TS
and it shouts at you like it does in rust when you dont implement some method
HOW
yeah i was right
dawn ledge
now that i think about it traiots are closer to abstract clases than interfaces
since traits can also have default implementations
valid jetty
valid jetty
since traits can also have default implementations
oh they can??
dawn ledge
trait Bar {
fn bar() -> i32 {
-1
}
}
royal nymph
since traits can also have default implementations
so can interfaces (in java)
valid jetty
not in TS
dawn ledge
i dont speak of languages that are supposed to be turned into fossil fuel
valid jetty
TO BE FAIR js has abstract classes too
royal nymph
ts*
royal nymph
the entire point of abstract classes is to force you to implement methods on a type level
so yeah js doesnt have that xd
valid jetty
good point
royal nymph
they are in es6
dawn ledge
there are insane people who write the function form of classes
valid jetty
function Foo(x) {
this.x = x;
return this;
}
Foo.prototype.bar = function() {
return this.x + 123;
}
``` classes โค๏ธwhat i'm trying to do is overload, not overwrite methods on standard types
dawn ledge
```js
function Foo(x) {
this.x = x;
return this;
}
Foo.prototype.bar = ...
forgor the if (this instance of Foo) crap
dawn ledge
what i'm trying to do is overload, not overwrite methods on standard types
rust overloading is non existent
well
you CAN do it
but its a hack
jade stone
rust overloading is non existent
really?
dawn ledge
yeah
valid jetty
what i'm trying to do is overload, not overwrite methods on standard types
rust just kinda doesnt have overloading in general
jade stone
insane
dawn ledge
rust doesnt have function overloading
dawn ledge
you can "emulate" it by using generics
or you can implement Fn traits directly
valid jetty
you can achieve it pretty easily with smart usage of macros, generics, and traits
dawn ledge
generally if you need overloading in rust what you really need is generics or an enum
valid jetty
yea
jade stone
generally if you need overloading in rust what you really need is generics or an...
at least it's better than typescript overloading
royal nymph
because ts overloading isnt real
jade stone
(very low bar)
jade stone
because ts overloading isnt real
yop
valid jetty
ts overloading is NOT overloading
i love if (typeof(x) === "string" && typeof(y) === "string")
jade stone
also why are you using parens
shrewd canopy
ts overloading is NOT overloading
Python overloading
winged mantle
(love)
valid jetty
how does py overload
jade stone
how does py overload
it doesnt?
valid jetty
oh
shrewd canopy
how does py overload
You decorate function with typing.overload
valid jetty
isnt py dynamic tho
jade stone
same as ts then im guessing
valid jetty
how does it know what to dispatch
shrewd canopy
same as ts then im guessing
Yeah
valid jetty
oh ok
jade stone
@valid jetty insane overloaded function i wrote
winged mantle
i am worried if i try to refactor my ts project to use camelCase there will be something typed as any which breaks
jade stone
i am worried if i try to refactor my ts project to use camelCase there will be s...
ts rename is cross-file
just run tsc --noEmit after to type check it
winged mantle
ts rename is cross-file
just run `tsc --noEmit` after to type check it
won't check for things which aren't typed as the right interface
jade stone
won't check for things which aren't typed as the right interface
wdym
winged mantle
also renaming everything will take forever
jade stone
won't check for things which aren't typed as the right interface
send example
royal nymph
you could make a BetterOverload library along the lines of
const myFunc = overloads(
{
params: [String, Object],
call(stringArg /*: string */, objectArg) {}
},
{
params: [Number, Object],
call(numberArg /*: number */, objectArg) {}
}
); /* type is (arg1: string | number, arg2: object)
cursed tho
nimble bone
<@886685857560539176>
valid jetty
<:k_:1334683387486539797>
NO
winged mantle
send example <:blobcatcozy:1026533070955872337>
just because this will fit into interface it doesn't mean it will get refactored i imagine
supple whale
<@581573474296791211> insane overloaded function i wrote
perish
valid jetty
even when its not here i can feel its presence...
winged mantle
i guess there would be errors
what if something was somehow typed as any and that avoided errors i can't think of an example but it seems possible
nimble bone
one day everyone will find out that you sleep scrobble and we will do #RosieIsOverParty
winged mantle
eh the effort is worth it
nimble bone
and i will finally be #1 in scrobble lb
winged mantle
inconsistent case feels like it would scare of contributors
jade stone
just because this will fit into interface it doesn't mean it will get refactored...
me when i dont type my shit
:Error or satisfies Error or as Error would work
winged mantle
eh the effort is worth it
if there are no compile time errors bugs will be found eventually
best to do it sooner rather than later
royal nymph
just because this will fit into interface it doesn't mean it will get refactored...
this is just wrong code
jade stone
^
winged mantle
i was just trying to use a very unlikely example to prove my point
๐ฆ
mistakes like that are likely to go unnoticed
well... actually that's pretty likely
this is more likely
you might not notice you forgot to type the return
winged mantle
like yes you shouldn't do this
that doesn't mean it would never happen
๐ญ
idk what your point is
valid jetty
this is more likely
no camel case in ts...
royal nymph
thats snake case girl
jade stone
you might not notice you forgot to type the return
the handy noImplicitAny
valid jetty
thats
royal nymph
๐
valid jetty
its hard to express tone via text
royal nymph
the handy noImplicitAny
it wouldnt do shit here
valid jetty
i meant like "it should be camel case.."
royal nymph
it infers return type
jade stone
it wouldnt do shit here
wait, yeah im stupid
valid jetty
as const for extra fancy inference
winged mantle
true but it also wouldn't rename automatically
jade stone
the handy noImplicitReturns
winged mantle
so still some wasted time
winged mantle
would help me catch these mistakes i guess
valid jetty
the handy noImplicitReturns
the handy rustReturnMode
jade stone
the handy rustReturnMode
valid jetty
(my behated)
winged mantle
noImplicitAny would be fine with me if you could just make it do unknown instead of any
and not emit a compilation error
valid jetty
like wdym i have to manually type every non-void function (tbf it probably makes the compiler more elegant, i have a similar issue in elle)
jade stone
and not emit a compilation error
hop on esbuild (or anything that just strips types at compile time)
supple whale
it infers return type
yo what infers that for u?
winged mantle
hop on esbuild (or anything that just strips types at compile time)
i use node
supple whale
or did u type that out manually?
jade stone
you gotta trick the compiler by doing as keyof typeof var
what
royal nymph
yo what infers that for u?
typescript
if u mean the inline hint that's just a vscode setting
jade stone
i use node
--experimental-strip-types
winged mantle
yes
supple whale
typescript
if u mean the inline hint that's just a vscode setting
remember what its called?
valid jetty
how did this chat move from rust to TS so elegantly
winged mantle
what <:wires:1262562427422244874>
this code does not compile with noImplicitAny despite it being perfectly safe
function doThingWithObject(obj: object) {
const valueInObject = obj["someKey"]; // emits error
// even though i'm actually being sensible and checking the value type
if (typeof valueInObject !== "string")
return;
console.log("someKey = " + valueInObj);
}
ultrawide gaming, i'm good
supple whale
if (canvas.width && canvas.height && subtitles.renderer?._canvas) context.drawImage(subtitles.renderer._canvas, 0, 0, canvas.width, canvas.height)
i love ultrawide
royal nymph
funny
royal nymph
clearer highlight
winged mantle
this does not work
you can fix it but now it thinks the type is never for some reason
kind of feels stupid
jade stone
@winged mantle
supple whale
obj: object
brotha man
you just defined an empty object that cant have keys
then said "yep this is a key of this object without keys"
valid jetty
like wdym i have to manually type every non-void function (tbf it probably makes...
so actually continuing from this @fleet cedar hi slightly random question
ok so currently my compiler is single pass, which means that you have to do the behated forward declaring of functions to make them be mutally recursive
i want to move away from that, and compile the headers of functions first before their bodies
the problem is that most functions dont have their return type set on the function header; its inferred from the body of the function
so now theres a paradox: to prevent forward declaring, you have to parse the header of functions first, but usually the return type of a function is in the body of a function so you have to also parse the body, but what if the function returns a call to another function which also is non-void, its just kinda an infinite problem and im not sure how to solve it while keeping the elegance of inferred return types
right now it seems like either:
- keep forward declaring and allow implicit returns
- force explicit return types on every function
but im wondering if you know of any other way to do it which prevents both of those
jade stone
you just defined an empty object that cant have keys
nevermind, you're right
winged mantle
the object type allows any keys
royal nymph
object just isnt the right type here
use any or something like Record<PropertyKey, unknown>
valid jetty
Record<PropertyKey, any> my beloved
hoary sluice
so actually continuing from this <@236588665420251137> hi slightly random questi...
force explicit returns
hoary sluice
mainly for readability
valid jetty
force explicit returns
for small functions its so bad
winged mantle
which just feels weird... why can't it just be unknown if you have noImplicitAny turned on
supple whale
hmmm idk how i like this
jade stone
Record<PropertyKey, any> my beloved
hop on keyof never instead of PropertyKey
hoary sluice
for small functions its so bad
why
royal nymph
which just feels weird... why can't it just be unknown if you have noImplicitAny...
because your code makes no sense
valid jetty
fn foo<T>(T x, T y) -> T {
return x + y;
}
``` the `-> T` just doesnt need to be thereif it can be inferred why shouldnt it
hoary sluice
yes it does
royal nymph
your cast to keyof obj does nothing because obj has no keys
hoary sluice
if it can be inferred why shouldnt it
less confusion that way
winged mantle
your cast to keyof obj does nothing because obj has no keys
i mean.. it does make the compiler be quiet
valid jetty
i wonder if thats how rust can prevent forward declaring
hoary sluice
if you let people write ugly unreadable code they will do it, just look at js and ts
jade stone
which just feels weird... why can't it just be unknown if you have noImplicitAny...
because the flag is called noImplicitAny, not implicitUnknown
supple whale
speaking of keys, i couldnt get this working:
_fillOutKeys (entry: StoredMedia, variables: VariablesOf<typeof Entry>) {
const keys = ['status', 'score', 'repeat', 'progress'] as const
for (const key of keys) {
// @ts-expect-error idk how to fix this tbf
entry.mediaListEntry[key] = variables[key] ?? null
}
}
implicitUnknown would be avoiding implicit any in a sense
valid jetty
if you let people write ugly unreadable code they will do it, just look at js an...
idk about js but in ts you can hover over the function name to see the return type with a good lsp
winged mantle
just by making it something safer
hoary sluice
i wonder if thats how rust can prevent forward declaring
i mean you can just recursively check implicit returns but explicit returns are more readable
royal nymph
less confusion that way
implicit return type isnt confusing
hoary sluice
idk about js but in ts you can hover over the function name to see the return ty...
or just put it in the code
jade stone
speaking of keys, i couldnt get this working:
```ts
_fillOutKeys (entry: StoredM...
can you send the type of StoredMedia and the type VariablesOf
valid jetty
i mean you can just recursively check implicit returns but explicit returns are ...
but what about mutually recursive functions
supple whale
can you send the type of StoredMedia and the type VariablesOf
cant, char limit XD
jade stone
also just upload as file
royal nymph
idk about js but in ts you can hover over the function name to see the return ty...
or it literally shows inline as a hint xD
supple whale
type StoredMedia = {
id: number;
isFavourite: boolean;
mediaListEntry: {
id: number;
status: "CURRENT" | "PLANNING" | "COMPLETED" | "DROPPED" | "PAUSED" | "REPEATING" | null;
progress: number | null;
repeat: number | null;
score: number | null;
customLists: unknown;
} | null;
}
variables: {
score?: number | null | undefined;
repeat?: number | null | undefined;
progress?: number | null | undefined;
status?: "CURRENT" | "PLANNING" | "COMPLETED" | "DROPPED" | "PAUSED" | "REPEATING" | null | undefined;
id: number;
lists?: (string | null)[] | null | undefined;
}
actually i forgot i used Pick<>
hoary sluice
implicit return type isnt confusing
function get big, you have multiple places where it returns, its returns abstract factory builder, yes it gets confusing
valid jetty
fn foo() {
return bar();
}
fn bar() {
return foo();
}
``` how do you determine the return type of thisso its small
royal nymph
```rs
fn foo() {
return bar();
}
fn bar() {
return foo();
}
``` how do ...
you dont
hoary sluice
```rs
fn foo() {
return bar();
}
fn bar() {
return foo();
}
``` how do ...
you dont
jade stone
```ts
type StoredMedia = {
id: number;
isFavourite: boolean;
mediaLi...
the second isn't generic
supple whale
the second isn't generic
uuuuuh?
jade stone
also it's just a syntax error lol
supple whale
Type 'number | "CURRENT" | "PLANNING" | "COMPLETED" | "DROPPED" | "PAUSED" | "REPEATING" | null' is not assignable to type 'null'.
Type 'number' is not assignable to type 'null'.t
idk
valid jetty
tbf it does that in elle too, if you have a recursive function the return type is either:
- if the first return type is non-recursive, that thing's type
- void
fleet cedar
so actually continuing from this <@236588665420251137> hi slightly random questi...
I guess you could do something where the types are computed lazily (and error if loop), but dunno if that'd be any good
jade stone
@supple whale just upload the relevant code to tsplayground or smth
winged mantle
your cast to keyof obj does nothing because obj has no keys
how about this don't you think this feels weird
enum Colors {
RED,
GREEN,
VIOLET,
}
const colorNames = {
[Colors.RED]: "red",
[Colors.GREEN]: "green",
[Colors.VIOLET]: "violet"
};
function getColorName(color: Colors): string | undefined {
if (!Object.hasOwn(colorNames, color))
return undefined;
return colorNames[color as keyof typeof colorNames];
}
fn foo(i32 x) {
if x == 1 { return 1; }
else { return foo(x - 1); }
}
``` it knows that foo's return is `i32` hereit feels weird to me that you need to do a cast
jade stone
this shit is like 3GB of depenendencies deep
how is a type 3GB big
hoary sluice
omg so much typescript slop i cant read the actual conversation
supple whale
also it uses a ts server plugin, to convert gql strings to TS types
valid jetty
I guess you could do something where the types are computed lazily (and error if...
hmm yeah but idk how you would approach that
jade stone
also it uses a ts server plugin, to convert gql strings to TS types
insane
valid jetty
omg so much typescript slop i cant read the actual conversation
true
supple whale
how is a type 3GB big
its a type schema of an entire GQL DB
so i can write any gql query and get types out of that query
automagically
jade stone
its a type schema of an entire GQL DB
how is that all in one type
valid jetty
how about this don't you think this feels weird
```ts
enum Colors {
RED,
GR...
hi! so theres this thing called.......... an โจ object โจ
jade stone
horror
hoary sluice
I guess you could do something where the types are computed lazily (and error if...
this is probably how fp does it and @valid jetty should take a day to implement that and lazy function evaluation too
winged mantle
hi! so theres this thing called.......... an โจ object โจ
elaborate
hoary sluice
partial application in elle ๐ฅบ
jade stone
how about this don't you think this feels weird
```ts
enum Colors {
RED,
GR...
enums in typescript are just fucked lol
hoary sluice
```rs
fn foo(i32 x) {
if x == 1 { return 1; }
else { return foo(x - 1); ...
i feel like this is a lot slower than just parsing the return type explicitly, and its a lot more readable here
valid jetty
elaborate
const colorNames = {
RED: "red",
GREEN: "green",
VIOLET: "violet"
};
type Colors = keyof typeof colorNames;
function getColorName(color: Colors): string | undefined {
if (!Object.hasOwn(colorNames, color))
return undefined;
return colorNames[color];
}
and you just get lsp autocomplete for RED, GREEN, VIOLET instead of doing Colors.RED, ...
hoary sluice
kotlin does it perfectly, you have to specify the return type unless its an expression function that fits on 1 line
valid jetty
heck you can even just do this
const colorNames = {
RED: "red",
GREEN: "green",
VIOLET: "violet"
};
type Colors = keyof typeof colorNames;
function getColorName(color: Colors): string | undefined {
return colorNames[color];
}
itll return undefined anyway if its not in the object
no need to manually check
winged mantle
why would you do | undefined in the type
it will always return string if you have to pass in a key
supple whale
<@521819891141967883> nvm https://www.typescriptlang.org/play/#code/ATBmFcDsGMBc...
notably he type defs cant be modified, they are inferred
from the DB schema
valid jetty
why would you do | undefined in the type
i just copied it from what you sent
winged mantle
oh wait
valid jetty
it will always return string if you have to pass in a key
what if i do getColorName("FOOBAR")
valid jetty
i get a type error but it still returns undefined
supple whale
heck you can even just do this
```ts
const colorNames = {
RED: "red",
GREEN:...
why... are you defining types there?
they are inferred just fine?
winged mantle
i think the issue was with name -> enum mappings i was trying to do
i think i made a mistake i think you would not need as keyof typeof there
as keyof typeof is just my enemy
i love typescript
โค๏ธ
supple whale
its trully a love/hate relationship
winged mantle
maybe