OCaml 4.10

I even saw someone compare OCaml build methods as 'Jane Street Way' vs 'Other Ways'. It's hard to ignore such an influential company like that when the question about who uses them comes up!

Here are a few others:

- both polymorphic variants and GADTs are extremely powerful mechanisms to let you keep track of invariants, in a manner that cannot be replicated readably in Rust so far;

- OCaml's pattern-matching is a bit more flexible than Rust's ;

- (thanks to the GC) OCaml's closures are much more flexible than Rust closures;

- I guess OCaml's blindingly fast exceptions can be useful for some algorithms, although I haven't really experienced the need for them myself.

Again, that's not to say that Rust doesn't have great stuff for it (affine types 4eva!) or that OCaml doesn't have its own limitations – Rust is currently my main language and I do not regret it.

But there are some algorithms that I really don't want to write in Rust. Recently, for instance, I stumbled upon this: http://weblog.jamisbuck.org/2010/12/29/maze-generation-eller... . Trivial algorithm, trivial to write in OCaml, feasible but much less straightforward in Rust.

The lightweight type structure where you can easily make Union types and the pattern matching are pretty much identical to how OCaml does it.

Of course, the big difference is going to be in how easily you can interop with the .Net stuff in each language, obviously much easier in F#. This is great if you happen to have some kind of weird C# code that generates an IEnumerable, just pop that into F# and start working with it.

For example, I have C# classes to read files to an IEnumerable of strings, you can just call List.ofSeq on it, and then start doing some really elegant things in F# with it. You can pattern match log files based on how the line starts and then run different functions whether it’s an error, info, debug, etc

We use it in production at Olo, and I used it in production at my last company.

Since learning F#, languages where if statements aren't expressions and that don't have option types feel broken to me =)

The syntax is very similar but it solves many of Ocaml's pain points and you will get better tooling and more libraries thanks to .Net.

Basically, if you do use F#, be aware that it has its own idioms that you must learn; it's not a drop-in replacement for e.g. OCaml/Haskell/etc.

https://caml.inria.fr/pub/docs/oreilly-book/html/index.html

https://caml.inria.fr/pub/docs/u3-ocaml/

https://ocaml.github.io/ocamlunix/

You could give https://ocaml.org/learn/tutorials/ a try as well, specifically this: https://ocaml.org/learn/tutorials/setting_up_with_oasis.html

For profiling: https://ocaml.org/learn/tutorials/performance_and_profiling....

For debugging: https://ocaml.org/learn/tutorials/debug.html and https://caml.inria.fr/pub/docs/manual-ocaml/debugger.html

For unit testing: https://www.cs.cornell.edu/courses/cs3110/2019fa/textbook/da... and https://www.cs.cornell.edu/courses/cs3110/2019fa/textbook/te...

You may find https://github.com/gildor478/ounit#examples useful for both OUnit (unit testing) and OASIS (build system).