OCaml seems like the ideal language for me on the surface, but the onboarding process is... suboptimal IMO. There's a lack of good soft/hard documentation (AKA the "no, type signatures are not sufficient documentation" problem), but my biggest turn off is the multiple standard libraries. Some might see that as a plus, but when I'm just trying to get a small learning project off the ground, and I find out there's a critical library I need that's incompatible with the stdlib I'm using is a huge bummer.

Not saying these are insurmountable, unforgivable problems, just really annoying.

I feel like the biggest thing missing from OCaml is a Cargo-like build tool (probably using OPAM under the hood for dependency management). It would also be nice if OPAM had better cross platform support. The only way I could get it working on Windows was through one of the distributions that bundled Cygwin.

F# does have operator overloading.

but F# doesn't have Ocaml's performance, which I believe was the point being made for ML over Haskell

I honestly don't know how F# compares to Haskell over performance

F# is essentially just C#, which should be reasonably performant? It's possible the persistent data structures aren't optimized I guess?

Pity something's busted in the benchmarks game: http://benchmarksgame.alioth.debian.org/u64q/fsharp.html

It wasn't busted with .NET Core 1.0.1 005db40cd1.

Is F# working with .NET Core 2.0 Preview 1 for you?

Haven't tried out .NET Core 2 yet, actually.

But it's missing the module system, which is IMHO OCaml's best feature.

Also the multicore concurrency.

Some people also complain about a tiny set of syntactic issues. Other than that I like both ml and ocaml.

Having learned ML languages via Caml Light, I never understood what those complaints are about.

Maybe the only thing I would complain would be the separation between integer and floating point math.

not even the monomorphism, I forgot but there's a few warts at the syntactic level only.

A few months ago I read monomorphism is the way to go performance wise.

Something about people writing fast code with Flow/TypeScript than with plain JavaScript because the typing leads to less polymorphic code which is easier to optimize for the compiler.

In this context, "monomorphism" just meant that OCaml requires you to write "+" to add integers and "+." to add floats (and yet other things to add bignums or whatever).

This has nothing to do with performance per se. It doesn't make OCaml code faster than languages that allow you to write "+" for both int+int and float+float. The compiler knows anyway.

But that's what most devs do, right? If it doesn't look like C it's ugly, haha.

Anyway, Reason seems to have a bit nicer syntax than OCaml, I think.

Reason seeks to destandardize syntax, a fascinating experiment I'd prefer to watch in a language not already held back by community fragmentation.