Poly/ML – A Standard ML Implementation
github.com
github.com
ML also has an interesting module system, which achieves similar goals as object-oriented programming, but in a very different way. While mainstream "class-based" OOP identifies the data type with the unit of encapsulation, ML has "modules," which are separate entities from types, and which may both define types and values as members. However, a downside of this approach is that you sacrifice late binding, as the module language and "core" language are stratified into different layers. Instead, dependency injection is achieved through module-level functions, called functors,
A lesser-known fact is that ML originated as the scripting language for the LCF proof assistant (which is where the name "ML," or meta language, comes from). In the LCF tradition, the inferences rules of the logic are implemented in a trusted kernel, then clients use those inference rules to write tactic scripts that construct theorem objects. This design was supported by ML's module system: theorems were defined as an abstract type in a "kernel" module, and the inference rules were defined as functions inside the module. Here is a tutorial that explains the LCF design better than I can: https://www.cs.cmu.edu/~fp/courses/15317-f17/recitations/rec...
I had a weird introduction to programming. I spent my first half year doing php, and them went all in on scheme and sml. Which is nice in many ways, but I do have a hard time accepting many of the completely braindead (subjective opinion, of course) choices of most of the popular languages.
I do think clojure is a pretty nice compromise. Rich has good taste, obviously. Clojure's core.async could be less async and more CML in my taste. Wrapping a simpler async api in cml is easy. Implementing CML on top on core.async is either very hard or full of compromises.
a classic example of something that is trivial in cml but requires a mediator in CSP or go is two fibers swapping values atomically where a fiber can pull out at any time. in cml it is about 20 lines of code that can be in a library. it composes with other events.
in csp it is a "server" that manages the swap which means you lose the sectability.
Evert time you want to have any kind of protocol, cml wins.
I mostly worked with HOL Light which started as a CAML project and now runs on OCaml.
At least it is still officially developed getting new features, unlike C++/CLI and VB that only get bug fixes and updates to keep running on top of recent .NET versions.
This is why we can't have nice things.
Java with Streams and "functions" is a lot better than what I left behind 15 years ago. But it is still extremely primitive compared to what F#, Rust and Scala offers. And I know this because I have spent 10+ years EACH using all of these in anger. So 20+ years.
Thing is, for 99% of corporate software, it hardly makes a difference, even more so with AI generated stuff going forward.
So yeah, we can't have nice things, especially when money and profit are part of it.
But sure, with AI, maybe this will matter less because people don't care about the code anymore.
F# is as it is.
Scala in 2026, especially after Scala 3, isn't doing great either.
Most Scala companies, nowadays also do Java and Kotlin, and in countries like Netherlands, according to discussions on Reddit, most consulting offers seems to have vanished.
Rust hit jackpot with the adoption across all major OS vendors and hyperscalers, being slowly certified for deployment into high integrity computing, and landing on the Linux kernel.
However even with all that, just look at Android, where Google proudly talks about their Rust adoption, yet Rust is not officially supported for app development, Java and Kotlin are, with NDK still only allowing C and C++, and that is mostly for game developers anyway.
Scala is not doing great, probably because they took too long to get 3 finished and good.
Yes. Companies are going back to Java because this is what all the convervative guys and girls want to use. That fact is what I am criticizing. You want fast horses, you don't want nice things.
So now you have Maven, semi-typed code intermingled with container logic because you cannot abstract over anything, you have millions of lines of impenetrable tests. Just like we all did in 2006. You all love this because learning things is not your forte :) That other stuff is for academics and niche.
I still fondly remember my introduction to ML ecosystem via Caml Light, OCaml was still Objective Caml, and Haskell was still getting beyond Miranda.
Instead as you well put it we keep we talking about faster horses, with the leading horse being C, and how to replace it by another one.
Or at least that was the path, until vibe coding became a thing, hopefully the bubble will burst.
But I claim that Rust is actually a high level language. Higher level than Java. My argument is that in Rust (, F# and Scala) you can encode in structure, what has to be operational code in Java.
So in the stronger languages you can reason about larger swaths about domain concepts easily, whereas in Java you have to trust the test panel on faith and wade through deep sections of "magic code" (compare with magic numbers. Why is there a 427/ these 7 lines of logic here? What does it do?)
This is interesting! My impression was that SML/NJ was the de facto "standard" Standard ML implementation (maybe analogous to SBCL in the Lisp world), and (FWIW) Gemini agrees, describing it as "the oldest and most widely used". So I'm surprised to see someone stick it in the rear behind Poly/ML and MLton.
I don't really know what to make of that, except that I guess there's a surprisingly vibrant SML ecosystem and don't listen to any one person (myself included) about it: try them all and see which SML implementation is right for you :)
I'm surprised Gemini says SML/NJ its the most widely used. I've been an active Standard ML user for close to 30 years, and while that was certainly true for the first half of that time, I found most projects around me drifted to defaulting to want to compile with mlton or polyml. SML/NJ's heap2exec was a bit clunky compared to the others. It's great that they're slowly moving it over to LLVM.
> SML/NJ's heap2exec was a bit clunky compared to the others.
Unlike the others, SML/NJ implements call/cc, so it's going to need to do something funkier.
SMLofNJ.Cont.callcc
> val it = fn : ('a ?.Cont.cont -> 'a) -> 'aLLM hallucination: Poly/ML has been in use since at least 1986 (see e.g. Paulsons preliminary user's manual for Isabelle).
Hmmm....