09:55 <d_bot_> <reynir> @VPhantom I updated let-if with if%true: it transforms `if%true cond then something` into `let c = cond in if c then something; c` https://github.com/reynir/let-if

11:51 <d_bot_> <VPhantom> Nice! Hey I already had this repo starred so I guess I saw it before in my crazy adventures. 😉

14:39 <d_bot_> <VPhantom> I just whipped up a little pattern match on Godbolt: <https://godbolt.org/z/cWh7a6enT> I'm not familiar with much of assembly but is it normal that I don't see the strings `"use"` nor `"documentzz"` in the generated output? I do see the three failure strings but not those pattern strings. I'm trying to understand if the compiler compares strings once per case or if it groups them in a tree but I can't figure much out from the a

14:40 <d_bot_> <VPhantom> (This is part of my "trying to know what I'm doing" series. 😛)

14:41 <d_bot_> <VPhantom> Note that I extended "document" with "zz" to make sure it was over 8 bytes long, in case the compiler felt frisky and decided to compare strings as integers.

14:44 <d_bot_> <VPhantom> I don't even see a reference to Stdlib's `compare` function in there. 🤔

14:51 <d_bot_> <reynir> line 105 or so

14:52 <d_bot_> <reynir> seems like the compiler does integer comparison with "document" and then "zz"

14:54 <olle> Any news in type-land this week?

15:02 <d_bot_> <VPhantom> Oh wow, nice! So it _does_ compare strings as integers when they're short (which they usually are). That's a really neat trick!

15:04 <d_bot_> <VPhantom> Seems to use 63-bit integers too, because dropping to "documen" removed the second check. Thanks for the tip! I totally missed it.

15:05 <d_bot_> <reynir> yea, it took me some time staring at the code to spot it

18:29 <d_bot_> <mbacarella> well that's awesome

18:30 <d_bot_> <mbacarella> it's still faster to match on sum types? because each variant is actually mapped to an integer?

18:32 <d_bot_> <mbacarella> assertion check. trying to avoid internalizing "actually, matching short strings is fast!"

18:32 <d_bot_> <mbacarella> slash faster than matching on sum types

18:33 <d_bot_> <mbacarella> er, is matching on short strings faster than matching on polymorphic variants? 🤔

18:34 <d_bot_> <mbacarella> or, at least, equivalent?

18:34 <d_bot_> <mbacarella> i understand sum types compute to jump tables but polymorphic variants compute to if-then-else-if-then-else

18:38 <d_bot_> <VPhantom> Polymorphic variants without arguments are unboxed btw, the same as regular variants.

18:39 <d_bot_> <VPhantom> I'm a rookie but I would expect a <7 character string, an int, a variant without arguments and a polymorphic variant without arguments to be handled similarly or identically in the resulting assembly. 🤔

18:39 <d_bot_> <mbacarella> to the godbolt!

18:46 <d_bot_> <mbacarella> https://godbolt.org/z/ePEaME8WY

18:46 <d_bot_> <mbacarella> i think the regular variant clearly wins

18:51 <dh`> oops, from way back in the scroll:

18:51 <dh`> <companion_cube> dh`: what is the point of using async IOs if you're going to block on them immediately, though?

18:51 <dh`> exercising the async I/O path

18:52 <dh`> that is, if you have a separate async I/O path it'll be rarely used and it's quite likely to not actually work

18:52 <dh`> if you have only the one I/O path any problems will turn up immediately

18:52 <companion_cube> I guess it makes sense

18:52 <companion_cube> if you have both, that is, but that sounds bad :D

18:53 <dh`> this is more important inside kernels than in language runtimes though

18:53 <dh`> most language runtimes don't do anything particularly complicated for generic I/O, so it's just a thin wrapper around the OS

18:54 <dh`> (unless trying to do things like fake up async I/O using threads)

18:54 <dh`> whereas in the OS the I/O path is nontrivial and it's easy for it to be bust

19:08 <sleepydog> the recent io_uring vulnerability comes to mind ...

19:43 <servytor> can someone explain to me how https://github.com/inhabitedtype/ocaml-aws is 215k lines of OCaml code, 334k lines of json, but https://github.com/cognitect-labs/aws-api is only 4k of Clojure and 10k of json?

19:43 <d_bot_> <VPhantom> @mbacarella I'm surprised, but it does appear that the stock compiler is more aggressive with regular variants. I tried flambda and `-O2` and same difference.

19:44 <d_bot_> <Et7f3 (@me on reply)> you can't otherwise how do you know at runtime short/long string one is a pointer and other is not

19:44 <d_bot_> <VPhantom> I'm not saying they're handled _interchangeably_, just in a similar way.

19:45 <d_bot_> <Et7f3 (@me on reply)> but the ocaml compiler when we match on many string try to find best char to look for difference

19:49 <d_bot_> <Et7f3 (@me on reply)> 😳 the string was "abcdefghi"

19:49 <d_bot_> <Et7f3 (@me on reply)> https://cdn.discordapp.com/attachments/436568060288172044/951929994198798346/unknown.png

19:53 <d_bot_> <VPhantom> We can see the endianness.

20:10 <dh`> (I didn't read the scroll, suppose I should have)

20:10 <dh`> oops

20:13 <d_bot_> <RegularSpatula> I didn’t really read your message well enough and thought at first that Cognitect had started writing ocaml and got really excited…

20:13 <companion_cube> servytor: maybe the clojure code is generated on the fly from the json files?

20:13 <sleepydog> servytor: I assume you're asking in good faith. the ocaml version generates a separate module for each product. the clojure project looks to do more at runtime