Visual C++ as well, because since the XP SP2 issues, Microsoft has come up with SAL, which you can also use on your own code,
Then specialized tooling just for this purpose, just two examples,
Regarding C, I would really like some kind of -fsafe-mode, but I guess we need to contend with -Wall -Werror and -fanalyse.
And regarding threads, we would use cooperative concurrency, and also take ownership of the timer interrupt.
Anything is easy when there is an abstraction implemented as library.
Games and demoscene tricks.
ML, depending on the flavour gets pretty how one combines functors, aka generic modules, which is similar to component based programming like COM, or just plain objects as in OCaml.
Now the immutability isn't as hard to adapt to as one may think.
Also I bet that The Art of Metaobject Protocol reference implementation can be ported into Clojure without major issues.
"A protocol is a named set of named methods and their signatures"
Such protocols are not a language feature of CLOS.
AMOP describes a 'Metaobject Protocol' (MOP) and has a tiny example implementation (called Closette). This is entirely different from what the 'protocols' feature does in Clojure. A 'protocol' in AMOP is informal.
What AMOP actually describes with its MOP, is a meta-level of meta-classes and generic functions, which implement large parts of CLOS itself. Such the classes, generic functions, methods, slot descriptors, etc. are CLOS objects themselves.
Clojure supports a form of multiple dispatch, but the dispatch mechanism is also very different from CLOS - for example it uses a dispatch method per generic function, selects one method and has no idea of a next method. CLOS for example uses a built-in dispatch mechanism, multiple class-based dispatch hierarchies for multiple arguments, using a set of methods which are selected based on the class hierarchy.
Typically it is not a good idea if Clojure uses a name for a feature, to generally think that this is similar to a feature with a similar name in Common Lisp -> 'protocols' and 'meta-object protocol' are two very different things.
Porting the CLOS MOP to Clojure would be possible, when one first implements CLOS in Clojure. Otherwise it makes very little sense, since Clojure does not by default support the (older) view of object-oriented programming of CLOS. Something which the Clojure designer thought of a feature: getting rid of things like mutable objects, class based inheritance, class-based OO, etc.
Many of which did have a REPL.
Also the dynamic language runtime originally designed for Iron languages, Python and Ruby, precedes F#.