
After 11 years, a new "Programming in Standard ML" [pdf] - jimwise
http://www.cs.cmu.edu/~rwh/smlbook/
======
swannodette
Download this, download this
(<http://www.cs.cmu.edu/~rwh/theses/okasaki.pdf>), and block some play time.

~~~
pumpmylemma
How different is this PDF from the book version? (see:
[http://www.amazon.com/Purely-Functional-Structures-Chris-
Oka...](http://www.amazon.com/Purely-Functional-Structures-Chris-
Okasaki/dp/0521663504)) Regardless, thanks for the link.

~~~
silentbicycle
The book expands upon his thesis, and has Haskell source code in an appendix.
I'm more familiar with the book than that PDF (and definitely recommend it),
but comparing their tables of contents would probably help.

------
chwahoo
The members of the research group I work in are pretty heavy users of OCaml
and I'm a big proponent of languages of the ML style. I generally have the
impression that OCaml has become the de facto ML implementation. Can anyone
make a case why I might want to consider using SML rather than OCaml?

~~~
kwantam
A few years ago, I had some time off from work and decided to spend the week
learning *ML. I spent a bunch of time with Standard ML, including the entirety
of the older version of the Harper book, and implemented a bunch of nontrivial
toys in it.

In the end, after having covered the whole book, I became frustrated with the
language and jumped ship (to Haskell with a quick stopover at OCaml). My main
reason was fragmentation: SML/NJ, MLton, etc. all have somewhat different
"standard" libraries, which means that in many cases you can't use libraries
written for one compiler with another. I ended up having to choose which
compiler and set of libraries I wanted per project in order to optimize the
availability of libraries for that particular project, which is a frustrating
experience. I'd rather learn the idiosyncrasies of one compiler than two.

Before jumping to Haskell, I dabbled in OCaml. I did not implement anything
serious with it; rather, I went back and reimplemented a couple of the small
toys I'd done in SML using OCaml. I decided that if I had to choose between
one of these and the other, I'd probably end up going with OCaml: since
there's only one major implementation, you won't run into the frustrating
experience of trying to merge two disjoint but frustratingly similar
ecosystems. To my sensibilities, however, OCaml is a bit uglier syntactically
than SML. In the end, I just never clicked with OCaml, and decided that
Haskell would scratch my itch better (and it has).

Having said all that, I don't mean this to imply that you shouldn't read this
book! Reading Harper's book on SML made it much easier to pick up OCaml and
Haskell, and I definitely consider it an excellent use of my time. SML is a
really nice language and a good introduction to Hindley-Milner, but the SML
ecosystem is something of a jungle and you'll probably get frustrated if you
stay too long. The biggest thing going for SML vs OCaml, in my opinion, is
that the syntax is just plain nicer.

~~~
dhess
Interesting. The parallels between ML and Scheme, two languages invented in
the '70s and in an academic setting, are striking: the core language is great,
but the community is divided into ever-so-slightly incompatible
implementations, so, in practice, there's very little sharing. Therefore, it's
impractical to do most "large" projects in the language, due to lack of
critical mass of useful libraries. ML/Scheme end up being learning languages,
for the most part, and then everyone moves on to {OCaml, Haskell}/Common Lisp
to get real work done.

I would say these similar outcomes are a repudiation of the idea that multiple
implementations of the same language is a good thing, but that hasn't hurt C's
popularity. More likely, it has something to do with their roots in
programming language research. Maybe ML and Scheme are _too_ good for their
own good, and other academics can't resist using them as a basis for their own
pet ideas. Perhaps a truly successful (read, "widely-adopted") programming
language has to be flawed just enough to discourage anyone from trying to
improve on it. Worse is better strikes again?

~~~
kwantam
Yeah, I concluded the same thing. Languages with standards seem to be largely
worse off than languages with canonical implementations with regard to
interoperability and ecosystem coherence. I think maybe the problem is that if
your standard isn't restrictive enough to ensure general interoperability, you
end up without it.

It seems strange that Haskell seems to be a special case to this, but even
there you see language extensions that ghc supports but Hugs et al do not.
It's just that, for most people, ghc just wins outright. SML/NJ vs MLton is a
harder question to decide given the freakish performance that MLton can
achieve.

------
redo2
What is the point of ML now that we have Haskell? This is not meant to be a
troll; I'm seriously asking. Haskell proponents mention ML and Miranda only in
passing and as lesser (in terms of purity and ease of use) antecedents of
Haskell. What reasons are there to still use it?

~~~
oct
Just because Haskell is purer that doesn't mean ML is pointless. Under the
right circumstances even a functional program can benefit from mutable state.
One example (perhaps the only real example; I don't know) can be found in the
SML New Jersey implemetation of splay trees, which modifies the tree during
certain operations.

Even without the purity question there are other things to consider. ML is
evaluated strictly, for example. I don't know much Haskell but I don't believe
it has any direct counterpart to ML's functors, either. There are probably
many other differences. Haskell is definitely more popular and is still a
niche language, so the reason you don't hear much about ML's benefits is
probably just because it has so few users.

~~~
redo2
Thanks.

