20:27 <tom1212> hi! how could you have implicit casts for instance promote an integer to a rational number?

20:28 <tom1212> i find it a bit heavy to explicitly write down such casts

20:28 <discocaml> <Kali> there is no way to do this implicitly

20:28 <discocaml> <Kali> you can make the conversions shorter, if you need to

20:29 <discocaml> <Kali> i often do `let iof = int_of_float`

20:29 <tom1212> :'( sniff

20:29 <tom1212> that's sad

20:29 <discocaml> <Kali> the other option is to make a variant type that has all the different number types you want and run it through a function that converts them under some condition

20:30 <discocaml> <Kali> i can't imagine this would be very good for performance

20:30 <discocaml> <Kali> you really should just convert them explicitly

20:31 <tom1212> okay, thanks for the heads up!

20:31 <tom1212> or maybe with objects? that have different constructors, like in C++?

20:32 <discocaml> <Kali> that would be even worse for performance

20:33 <tom1212> because the choice of constructor happens at runtime?

20:34 <discocaml> <Kali> objects in general are slow, the way they are designed means every method call requires a hashtable lookup at minimum

20:34 <discocaml> <Kali> this is not good for numerical calculation

20:34 <discocaml> <Kali> it is suitable for GUIs and such

20:35 <discocaml> <._null._> You can also make your cast a prefix operator, they have high precedence so they can be a single character long

20:35 <discocaml> <Kali> prefix operators: operators that begin with ~ or !

20:36 <discocaml> <Kali> ! has the highest precedence and ~ has second-highest

20:36 <discocaml> <._null._> or `?`. The only 1-long operator is `(!)` and already taken though, but all 2-long operators are free

20:37 <discocaml> <Kali> is `?` a valid operator? i was under the impression it wasn't

20:37 <discocaml> <Kali> https://cdn.discordapp.com/attachments/436568060288172044/1140746144788517055/Screenshot_20230814_163748.png

20:37 <discocaml> <._null._> No more than `(~)`, but `(?*)` is

20:38 <discocaml> <._null._> No more than `(~)`, but `(?* )` is

20:38 <discocaml> <._null._> No more than `(~)`, but `(?+)` is

20:38 <discocaml> <Kali> oh, i see

20:38 <discocaml> <Kali> that makes more sense

20:39 <discocaml> <Kali> (remember that editing reissues the message)

20:39 <tom1212> maybe explicit casts aren't that bad after all, there's less magic happening it's easier to figure out what is actually happening

20:39 <discocaml> <Kali> yes, it is nice to know exactly when they happen

20:39 <discocaml> <Kali> it is a little annoying sometimes but you quickly realize it is nicer explicitly

21:11 <tom1212> the fact that instatiating a module with a first-class modules/functors with the same input arguments yield different modules

21:11 <tom1212> can be problematic

21:12 <tom1212> this means that one needs to initially initialize a module once and reuse it

23:25 <discocaml> <quantumcat.> What do you guys think of Elm? I just discovered it and it seems pretty cool. I'm not sure how it plays with OCaml but I was wondering what people in the community thought of it. Also, what its relationship with OCaml is, if any,.

23:25 <discocaml> <quantumcat.> What do you guys think of Elm? I just discovered it and it seems pretty cool. I'm not sure how it plays with OCaml but I was wondering what people in the community thought of it. Also, what its relationship with OCaml is, if any.

23:25 <discocaml> <Kali> #offtopic🎲

23:27 <discocaml> <Kali> although, my short opinion: elm's model is cool, but elm is completely unmaintained and has been for the past few years, which makes me wary of using it

23:28 <discocaml> <Kali> last release was 2019...

23:29 <discocaml> <Kali> it doesn't haave any relation to OCaml other than being an ML-style functional language

23:29 <discocaml> <Kali> *have

23:30 <discocaml> <Kali> and the ability to compile to javascript

23:31 <discocaml> <Kali> although for OCaml that was a useful 3rd-party afterthought rather than the key point of Elm