humasect has quit [Read error: Connection reset by peer]
cr1901 has quit [Read error: Connection reset by peer]
cr1901 has joined #ocaml
humasect has joined #ocaml
<discocaml>
<youngkhalid> I might try F# for fun one day (but honestly knowing OCaml and being aware of both of their histories, I don't really appreciate F#'s as much, I could be wrong though). Also maybe their use cases are very different, from what I heard F# was an attempt to port OCaml to the .NET ecosystem
<discocaml>
<youngkhalid> Thanks for the recommendations ! I'm not really searching for "OCaml alternatives", but all this time I've noticed many people who use OCaml also use Reason, so I'm trying to figure out what specific things is Reason good at, and what people are using it for, since it seems quite interesting (the syntax looks like OCaml with some syntactic sugar)
amadaluzia has joined #ocaml
<discocaml>
<youngkhalid> Also, out of curiosity (if you don't mind :)), what do you like about F# in general ? (or, if that's the case, what makes you appreciate it more than OCaml ?)
<discocaml>
<yawaramin> Reason has JSX support built-in so it's easy to write React components with it
<discocaml>
<astreamingcomesacrossthesky> I have only ever dabbled in F# but if I may cut in on this conversation I am quite keen on computation expressions
<discocaml>
<youngkhalid> I saw earlier that it was created by the same guy who started creating React at Facebook. So you'd say is mostly for the web, or even, an OCaml for the web that has builtin compilation to JS ?
<discocaml>
<yawaramin> i would describe it as 'OCaml that looks like JS'. compilation to JS is done the compiler backends like Melange and JSOO
<discocaml>
<astreamingcomesacrossthesky> Is there a clear and unified explanation of what the deal is with buckle script and all that? I've been interested in checking out reason too but the compatibility issues seem a little onerous to me, compared to other compile to JS langs I've used
<discocaml>
<astreamingcomesacrossthesky> I know that the ecosystems have basically broken in two and that seems unfortunate to me but are there meaningful implications for writing apps
<discocaml>
<yawaramin> it depends on what kind of workflow you want. if you want a developer experience similar to TypeScript, then go with ReScript. if you want a developer experience and compatibility with OCaml, go with JSOO. if you want something in between, go with Melange.
<discocaml>
<astreamingcomesacrossthesky> Yeah I've messed around with JSOO and I like it. Do you think the JS interop is about as good across all the options?
<discocaml>
<yawaramin> if you want to compile to WebAssembly, go with JSOO
<discocaml>
<astreamingcomesacrossthesky> Like using JS libs that is
<discocaml>
<yawaramin> JS interop is i think best with ReScript, almost as good with Melange, and slightly more difficult with JSOO. but a lot of people _love_ JSOO and Daniel Buenzli's `brr` for interop, so i guess it depends on tastes 🤷♂️
<discocaml>
<astreamingcomesacrossthesky> Noted thanks. I guess I'm partial to JSOO bc I like OCaml syntax and want to stick with that but I guess I could try to get over my prejudicez
<discocaml>
<astreamingcomesacrossthesky> Noted thanks. I guess I'm partial to JSOO bc I like OCaml syntax and want to stick with that but I guess I could try to get over my prejudices
Frostillicus has quit [Remote host closed the connection]
Frostillicus has joined #ocaml
Tuplanolla has quit [Quit: Leaving.]
humasect has quit [Remote host closed the connection]
humasect has joined #ocaml
humasect has quit [Remote host closed the connection]
myrkraverk_ has quit [Read error: Connection reset by peer]
myrkraverk_ has joined #ocaml
humasect has joined #ocaml
humasect has quit [Remote host closed the connection]
humasect has joined #ocaml
humasect has quit [Remote host closed the connection]
humasect has joined #ocaml
humasect has quit [Remote host closed the connection]
cr1901 has quit [Read error: Connection reset by peer]
cr1901 has joined #ocaml
casastorta has quit [Ping timeout: 260 seconds]
casastorta has joined #ocaml
Frostillicus has quit [Ping timeout: 252 seconds]
LainIwakura has joined #ocaml
humasect has joined #ocaml
humasect has quit [Quit: Leaving...]
myrkraverk__ has joined #ocaml
myrkraverk_ has quit [Ping timeout: 252 seconds]
j0lol has quit [Remote host closed the connection]
j0lol has joined #ocaml
Serpent7776 has joined #ocaml
LainIwakura has quit [Ping timeout: 272 seconds]
inline has quit [Quit: Leaving]
LainIwakura has joined #ocaml
bartholin has joined #ocaml
pie_ has quit []
Mister_Magister_ has joined #ocaml
Mister_Magister has quit [Ping timeout: 276 seconds]
casastorta has quit [Ping timeout: 252 seconds]
Mister_Magister_ is now known as Mister_Magister
casastorta has joined #ocaml
pie_ has joined #ocaml
Haudegen has joined #ocaml
Frostillicus has joined #ocaml
Frostillicus has quit [Ping timeout: 252 seconds]
casastorta has quit [Ping timeout: 252 seconds]
Tuplanolla has joined #ocaml
<discocaml>
<shalokshalom> Yes, their use cases are indeed more different, than their shared similarities suggest.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> Not only is F# simpler, since OCaml has stuff such as higher order modules, polymorphic variants, structured typing and HKT's, it is also a bit more modern, having rounded edges, and some neat things such as an advanced object system, computation expressions, and so on.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> OCaml is the more powerful language, and F# is simpler.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> .NET is a blessing, and a curse.
<discocaml>
<shalokshalom> I use it mostly, because the Nu game engine is written in it. 🙂
<discocaml>
<shalokshalom> Yeah, it's one of its most appealing features.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> As most attempts to control side effects end in overly complicated integrations.
<discocaml>
<shalokshalom> I don't appreciate it more.
<discocaml>
<shalokshalom> OCaml has developed the ML community for decades, and is the core reason, why the language family is still thriving, and F# has based almost all its concepts directly on it.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> I do see F# as a port of OCaml, more than its own language - it's simply a dialect, and not a competitor.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> As said, to me the difference lies mostly in its ecosystem, and the overall focus on guaranteed type inference and simpler codebases.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> It reaches that due to lacking advanced features.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> Both OCaml and F# miss multiple dispatch, which I truly miss.
casastorta has joined #ocaml
<discocaml>
<shalokshalom> OCaml has developed the ML community for decades, and is the core reason why the language family is still thriving. 🙂
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> Also, F# is based almost entirely on OCaml, semantically and syntactically.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> That's why I do see F# more as a port of OCaml, than its own language:
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> It's simply a dialect, and not a direct competitor. 🤷🏻♂️
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> The difference I do see, is the overall focus on guaranteed type inference, due to a lack of features who introduce undecidability, plus the ecosystem.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> Both OCaml and F# lack multiple dispatch, which I truly miss.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> I don't know how good polymorphic variants are compared to it.
Frostillicus has joined #ocaml
Frostillicus has quit [Ping timeout: 276 seconds]
Frostillicus has joined #ocaml
inline has joined #ocaml
amadaluzia has joined #ocaml
casastorta has quit [Ping timeout: 260 seconds]
Frostillicus has quit [Ping timeout: 245 seconds]
Frostillicus has joined #ocaml
spynxic has quit [Read error: Connection reset by peer]
spynxic has joined #ocaml
Frostillicus has quit [Remote host closed the connection]
Frostillicus has joined #ocaml
bartholin has quit [Remote host closed the connection]
casastorta has joined #ocaml
LainIwakura has quit [Ping timeout: 272 seconds]
Frostillicus has quit [Ping timeout: 248 seconds]
LainIwakura has joined #ocaml
Frostillicus has joined #ocaml
Frostillicus has quit [Ping timeout: 245 seconds]
Frostillicus has joined #ocaml
Frostillicus has quit [Read error: Connection reset by peer]
Frostillicus has joined #ocaml
Frostillicus has quit [Read error: Connection reset by peer]
johnridesabike has joined #ocaml
YuGiOhJCJ has quit [Quit: YuGiOhJCJ]
Everything has joined #ocaml
Haudegen has quit [Quit: Bin weg.]
LainIwakura has quit [Ping timeout: 272 seconds]
LainIwakura has joined #ocaml
<discocaml>
<Kali> ocaml doesn't have HKTs
Frostillicus has joined #ocaml
om has joined #ocaml
LainIwakura has quit [Ping timeout: 272 seconds]
om82 has joined #ocaml
om82 has quit [Client Quit]
om has quit [Ping timeout: 272 seconds]
<discocaml>
<octachron> It does at the module level `functor (X:sig type 'a t end) -> ...` .
casastorta has quit [Ping timeout: 260 seconds]
LainIwakura has joined #ocaml
tronexte has quit [Ping timeout: 252 seconds]
tronexte has joined #ocaml
zozozo has quit [Ping timeout: 272 seconds]
Haudegen has joined #ocaml
casastorta has joined #ocaml
bibi_ has quit [Quit: Konversation terminated!]
Frostillicus has quit [Read error: Connection reset by peer]
Frostillicus has joined #ocaml
inline has quit [Quit: Leaving]
casastorta has quit [Ping timeout: 244 seconds]
LainIwakura has quit [Ping timeout: 272 seconds]
casastorta has joined #ocaml
<discocaml>
<froyo> and f# doesn't have ml modules and functors, idk if it counts as ml with that considered. it's a big semantic difference.
<discocaml>
<froyo> also i believe in f# "everything is an object" holds? if so, that's another big difference
<discocaml>
<froyo> f# is more like an ocaml flavored c# tbh
<discocaml>
<froyo> do compexprs do more than our let syntax
<discocaml>
<froyo> (please all avoid editing messages here)
<discocaml>
<Kali> semantically no, it's just that the f# compiler has special heuristics for compiling them efficiently
Serpent7776 has quit [Ping timeout: 265 seconds]
<discocaml>
<astreamingcomesacrossthesky> Is that really the case? Maybe you could also do this with letops but computation expressions can also be used for things like defining DSLs
<discocaml>
<Kali> and a bit of extra syntax for yield, match, etc
<discocaml>
<dr.shuppet> Did original ML have those? I thought those were added later
<discocaml>
<Kali> hm, i have never seen that before, do you have an example
<discocaml>
<astreamingcomesacrossthesky> Yeah I like the OCaml HTML DSLs well enough. I suppose my stance on something like Bolero's approach is that it's clever and elegant but I don't have any particular attachment to it beyond the aesthetic.
<discocaml>
<polyml> ml modules were added with caml special light, caml and caml light didn't have a ml module system
inline has joined #ocaml
<discocaml>
<hi_im_bored> could someone assist with running bonsai under wasm?
<discocaml>
<Kali> please ask in one of the help channels, this is not the right channel
<discocaml>
<Kali> it's bridged to IRC where multiline messages have to be split into individual messages and edits resend the entire contents of the message
<discocaml>
<hi_im_bored> My sincere apologies, will post in the correct place
<discocaml>
<shalokshalom> In a lot of cases, people use them, because they can, not really because they are the smartest choice of all.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> They do tend to make the code more complicated, and break type inference.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> Ideally, they would be available and used responsibly.
<discocaml>
<shalokshalom> But when building an ecosystem, people are either going overboard, or the language keeps them in check.
LainIwakura has joined #ocaml
<discocaml>
<shalokshalom> Also, does every SML support higher order modules?
<discocaml>
<shalokshalom> I thought SML/NJ and Mascow are the only two?/
<discocaml>
<shalokshalom> So Mlton is also not a true ML?
<discocaml>
<shalokshalom> I thought SML/NJ and Moscow are the only two?
<discocaml>
<shadowkestrel> re: people going overboard, i recently installed a tiny rust cli that could easily be a shellscript, with almost 300 dependencies (incl. transitive). `opam list | wc` gives me 117 (so 115 packages), and ocaml is my go-to language for personal projects. i dont even want to think about npm land
<discocaml>
<shalokshalom> Yeah, I think OCaml is a very good language to replace Rust.
<discocaml>
<shadowkestrel> i see rust used in a lot of places where its performance is just unnecessary, and it would take a *lot* of convincing me that it's much more 'ergonomic' than a lot of modern GC'd langs
<discocaml>
<shalokshalom> yep, absolutely
<discocaml>
<shalokshalom> the good old hammer = nail equation 😂
<discocaml>
<shalokshalom> but I wont lie, I am happy that lots of software gets rewritten in Rust
<discocaml>
<shalokshalom> It's a suitable language to do that, and we should have reimplemented lots of that decades old C code sooner or later anyway.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> I am happy, its in a language like Rust
<discocaml>
<shadowkestrel> as someone who has to compile a lot of the software i run (arch btw), my cpu is not happy that lots of software gets rewritten in rust :p
<discocaml>
<shalokshalom> Although I would not like to use it myself, to be honest.
<discocaml>
<shalokshalom> I am also on Arch, but I almost never have to compile myself.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> See the Chaotics-AUR repo.
<discocaml>
<diligentclerk> this sounds like every Go programmer
<discocaml>
<diligentclerk> "In a lot of cases, people use them, because they can, not really because they are the smartest choice of all. ... Ideally, they would be available and used responsibly."
<discocaml>
<diligentclerk> Reminds me a lot of that Go programmer who once said:
<discocaml>
<diligentclerk> "Security consultant here. The fact that Golang has no generic is a huge thing. I've read countless amount of code that abused generics (unfortunarely developers think they have to use generics all the time if they are available) and is probably completely insecure for the simple reason that very few people manage to audit/understand the code. If it generics could only be used when necessary, yes, but there are no technical way to enforc
Frostillicus has joined #ocaml
<companion_cube>
how do generics make code insecure, hu
LainIwakura has quit [Ping timeout: 272 seconds]
<discocaml>
<shalokshalom> Most secure is very subjective.
LainIwakura has joined #ocaml
<discocaml>
<yawaramin> i don't want to learn it, therefore it's insecure
Haudegen has joined #ocaml
LainIwakura has quit [Quit: Client closed]
LainIwakura has joined #ocaml
LainIwakura has quit [Client Quit]
undermine has quit [Quit: Bye]
<discocaml>
<froyo> ShalokShalom:
<discocaml>
<froyo> > and break type inference
<discocaml>
<froyo> you can have a completely principal inference with ml modules. in fact, one of if not the most advanced of its implementations, ocaml's, retains principal inference. could you explain how they break inference?
<discocaml>
<froyo> > higher order modules
<discocaml>
<froyo> do you mean higher order functors? every sml supports modules and functors (with principal inference again)
<discocaml>
<froyo> if you mean higher order functors, that moves the goalposts of what's considered ml
<discocaml>
<shalokshalom> I understand OCamls higher order modules are implemented as higher order functors
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> And that the stratification between the module system and the value system is the reason you, (or others) may not consider it a true 'higher order' module system?
<discocaml>
<shalokshalom> But none the less, higher-order functors require explicit type annotations, as functor parameters must be explicitly typed, or..?
Frostillicus has quit [Read error: Connection reset by peer]
Frostillicus has joined #ocaml
<discocaml>
<polyml> F# does not have a ML module system. SML has a ML module system. OCaml has a ML module system. Just because OCaml has extensions to its module system does not make SML not have a ML module system.
<discocaml>
<shalokshalom> idk what you mean with 'ML module system'
<discocaml>
<shalokshalom> I understood that as 'higher order module system'
<discocaml>
<shalokshalom> but apparently it's not.
Anarchos has joined #ocaml
xenu has quit [Quit: leaving]
zozozo has joined #ocaml
piper_ has joined #ocaml
piper_ has left #ocaml [#ocaml]
Frostillicus has quit [Ping timeout: 248 seconds]
lthms has quit [Read error: Connection reset by peer]
<discocaml>
<lecondorduplateau> by "higher order module" maybe you mean first class modules
lthms has joined #ocaml
<discocaml>
<lecondorduplateau> which SMLs don't have
<discocaml>
<froyo> naming aside, yes the module language is rather expressive and hard to infer, which is why in all MLs you need to give modules signatures
<discocaml>
<eval.apply> they mean high order functors: functors that have functors in the result module
<discocaml>
<froyo> module arguments of functors*
<discocaml>
<eval.apply> oh you said already
<discocaml>
<froyo> if you want both to coexist and interact freely, that's 1ml and i think its inference is undecidable (?)
<discocaml>
<froyo> both as in the module and the value layers
<discocaml>
<froyo> but i'm not really asking that out of f#
<discocaml>
<froyo> just a your average normal run of the mill ml module system isn't there
<discocaml>
<froyo> just your*
Anarchos has joined #ocaml
<discocaml>
<froyo> I can't make a strong assertion on 1ml's type system because idk enough about type systems, but i believe with great confidence that you can't really have both full inference and first-class modules.
inline_ has joined #ocaml
Serpent7776 has joined #ocaml
inline has quit [Ping timeout: 276 seconds]
<discocaml>
<froyo> > you can have a completely principal inference with ml modules
<discocaml>
<froyo> in all fairness i may have also caused confusion by saying this when i wasn't considering the module language itself. that is, you can if you accept the loss of type inference in the module language
<discocaml>
<froyo> but is f#'s type system even decidable? some features in it seem suspect
<discocaml>
<polyml> a ML module system would at the very least have the semantics described in the modules sections of The Definition of Standard ML
<discocaml>
<polyml> OCaml extends this to support first class modules, applicative as well as generative functors, separate compilation, higher order functors, etc
<discocaml>
<polyml> well everything except for transparent ascription which is nice to have in SML but not strictly needed to be considered a ML module system, especially with separate compilation
Haudegen has quit [Quit: No Ping reply in 180 seconds.]
Haudegen has joined #ocaml
<discocaml>
<eval.apply> there's an RFC for transparent ascription so soon ocaml will live up to ML standards
<discocaml>
<shalokshalom> F# does not need type annotations for any of its features.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> It is convention, to do it on APIs, (top level functions) for obvious reasons, and the compiler can infer that for you as well.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> F# type system is 100% decidable, and the creator of the language made that a hard requirement on all features that are introduced into the language, from day one.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> It's one of those neat things, you get by **reducing** features, instead of adding more and more on top.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> OCaml can choose here, and that's great, since in a sense, you can eat your cake and eat it too.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> You can go all powerful, and you can go full concise, simple and easy to read.
<discocaml>
<shalokshalom>
<discocaml>
<shalokshalom> The only I see here, is that the community develops accordingly, and the actual codebases you face, (if you read others code) do contain all the stuff, that makes it more complicated.
johnridesabike has quit [Quit: johnridesabike]
<discocaml>
<Kali> please stop putting a line between every sentence, the irc bridge has to send each line as a separate medsage
<discocaml>
<Kali> *message
<discocaml>
<yawaramin> also i think if we are going to do an in-depth discussion of F# and other languages maybe we should just move it to #offtopic🎲
<discocaml>
<deepspacejohn> Honest question, are multi-line messages really problematic for IRC? I thought we just discouraged pasting code because they’re dozens of lines long and IRC doesn’t format the code
<discocaml>
<diligentclerk> @shalokshalom I honestly don't understand what you're criticizing. What is undecidable about OCaml?
Anarchos has quit [Quit: Vision[]: i've been blurred!]
<discocaml>
<diligentclerk> In OCaml module signatures are used to control what is public vs private for a module so it doesn't strike me as a realistic concern that you can't automatically infer a principal solution for a higher-order functor, if this is indeed a problem (I don't know how much OCaml's module system has departed from academic theory with principal signatures). You would want to put a signature on it anyway in many cases, not let the signature be in
Serpent7776 has quit [Ping timeout: 252 seconds]
bartholin has quit [Remote host closed the connection]
Tuplanolla has quit [Quit: Leaving.]
<discocaml>
<._null._> deepspacejohn: messages are split along newlines and posted in short succession, so it gets quite annoying to have a dozen or two messages in 5 seconds
infinity0 has quit [Ping timeout: 245 seconds]
<discocaml>
<deepspacejohn> Right, but we don’t discourage fast message traffic in general, and I don’t understand why it would be annoying either way. But I guess if IRC users say it is then I can’t disagree.