
SML#: a new Standard ML family programming language - 0x1997
http://www.pllab.riec.tohoku.ac.jp/smlsharp/
======
Mindless2112
"Functional record update" [1] was the one missing feature that bothered me
most about Standard ML. If you want to change one element in a record, you've
got to specify explicitly that every other element in the record didn't
change.

[1]
[http://www.pllab.riec.tohoku.ac.jp/smlsharp/docs/1.0/en/Ch4....](http://www.pllab.riec.tohoku.ac.jp/smlsharp/docs/1.0/en/Ch4.S4.html)

~~~
mackwic
You can also update one field in OCaml, I really like this language.

~~~
p4bl0
I wouldn't use "update" since it imply that there is a modification of the
value in the original record. This is possible with mutable field of course,
but I think the feature of OCaml (and apparently, SML#) you're talking about
is the `with` keyword:

    
    
        # type foo = { bar: int ; baz: string };;
        type foo = { bar : int; baz : string; }
        # let a = { bar = 42; baz = "hello" };;
        val a : foo = {bar = 42; baz = "hello"}
        # let b = {a with baz = "bye"};;
        val b : foo = {bar = 42; baz = "bye"}
        # a;;
        - : foo = {bar = 42; baz = "hello"}

~~~
mackwic
You are completely right, thanks for the precision and code sample.

------
alegrn
SML# is one of the lesser known SML implementations, although it's a quite
good one. The only thing that I found impractical,... you can only link 32bit
libs, which is very odd on todays 64bit Systems.

Nevertheless, the thing I like most at SML# is the excellent FFI. You can just
pass SML-records or SML-functions to C. SML# is very powerful if you code your
applications in SML and C.

~~~
silentOpen
The recently released ocaml-ctypes <[https://github.com/ocamllabs/ocaml-
ctypes](https://github.com/ocamllabs/ocaml-ctypes) > library by Jeremy Yallop
does something similar. It uses GADTs to represent the C type system in
OCaml's type system with as-you-would-expect OCaml signatures. For example,
you can pass an OCaml comparator to a C sort function that takes a function
pointer and it works.

It's not quite as smooth, as far as I know, but it will soon include C header
consumption and C stub generation to both improve binding accuracy/safety and
remove dynamic paths for performance.

------
cyrus_
Strange choice of name given that it doesn't build on Microsoft's CLI at all.

~~~
616c
You mean CLR?

~~~
cyrus_
[https://en.wikipedia.org/wiki/Common_Language_Infrastructure](https://en.wikipedia.org/wiki/Common_Language_Infrastructure)

~~~
Zecc
TL;DR: the CLI is the specification, of which the CLR is Microsoft's own
implementation. Another/the other implementation of the CLI is Mono.

Which begs the question: you've written "Microsoft's CLI", which does make
sense because they were the ones who've come up with it, but can't that be
interpreted as a synonym for CLR? Maybe that's what 616c meant.

~~~
cyrus_
Microsoft authored and controls the standard, so I don't think it is
unreasonable to call it Microsoft's CLI, but sure.

------
rohshall
Good to know about this alternative. SML was a great language, and deserves to
live on. OCaml is not really a successor to SML because of its object-oriented
features and its lack of backward compatibility to SML.

------
nnq
sorry to ask, but _who_ uses SML nowadays and _for what_ do they use it? (I
know about it's descendants or languages influenced/inspired by it, like
OCaml, F# and the less related Haskell, but nothing hits the news about SML
projects.)

~~~
alegrn
Although SML is such a beautiful and pragmatic language and has many Compilers
and Runtimes, I am not aware of any real world projects with impact other than
the well-known SML compilers (Mlton, SMLNJ, MosML, Poly ... to only name a
few).

Usage of SML results in very short, readable and efficient programs, so I
wonder why there is only so little industry adoption.

~~~
thirsteh
Most of the people who would be using SML are using Haskell, hence why Robert
Harper is so bitter, constantly writing blog posts about how much "Haskell
sucks", and how "unsafe" it is.

edit: or OCaml, or F#.

~~~
more_original
I'm not sure it is right to speak of "most people". Many people use OCaml
these days. For instance, I have the impression that in work on program
verification and static analysis OCaml is more popular than Haskell. Coq is
written in OCaml, for example. The Haskell community much more vocal though.

Harper has strong opinions, but he has a few points. Haskell may be great, but
one should be aware that it is not an improvement on SML in each and every
respect. For example, SML has a much better module system than Haskell.

~~~
thirsteh
F# might already be more popular than both, but it's hard to tell for sure.

~~~
more_original
Yes, that's my point. We shouldn't say that most people use X because it
doesn't seem clear cut at this point.

~~~
thirsteh
It's not really an ethical problem, just an estimation. If SML was the only
similar language, surely a lot more people would be using it.

