F# has a DSL for monads called Computation Expressions so monads 'look' different in F#. Also, I think that once you have a monad implementation, the DSL makes it easier to use the implementation in your code.
So F# provides some extra language support for monads.
However, unlike Scala, F# does not have higher-kinded types so you cannot compose two monad implementations together (as easily).
I struggled with monads at first but then I realized that monads are really about function composition. Here is blog post that emphasizes this aspect of monads that may help with the understanding:
Nice interview! Looks like C# is turning out to be a great language.
For now though, I am enjoying the succinctness of F# without losing anything. I have to admit learing F# was harder than I thought as I did not have a funcitonal programming background.
My question is more appropriate for the CLR team but I will ask anyway. It seems that OO-based platform (such as CLR and JVM) are not super optimized for symbolic computing (I learned while reading "F# for Scientists" by John Harrop). Are there any plans for supporting symbolic computing more efficiently? To be honest I don't even know what that even means in terms of CLR changes. I suspect it has to do with creation and garbage collection of extra objects that perhaps can be avoided if the CLR is further optimized for functional languages.
Considering that both CLR and JVM have added special support for dynamic languages (so that dynamic method dispatch is optimized) can something similar be done for F# and other functional languages (Scala and Clojure)?
It seems that Greg is a propnent of Scala and it is one of the languages on my list to learn.
The major issue with Scala is that the JVM does not support tailcall optimization (the CLR does).
Not having tailcall optimization is a serious limitation for functional languages. Scala does create loops out of simple recursive calls but in complex composition it can still run into stack overflow issues.