Haskell seems pretty left brained to me!

Actually at the bottom of page 2 of Maynard's preprint he states: "We emphasize that the above result does not incorporate any of the technology used by Zhang to establish the existence of bounded gaps between primes."

So it seems like it is actually a coincidence, though they were both building off of the same previous work (GPY) so maybe it's not that surprising.

That is only a tactic move. it is Zhang's work inspired him to look for a quick better alternative. Zhang showed " there is gold! " And then Maynard ran towards that.

Why not F#?

I've been playing with it some. It's nice, but I still prefer Haskell. I want to be able to separate pure from impure code, but F# doesn't seem to enforce that. (Unless I'm missing something?)

It doesn't. In fact, F# feels like it started off as a fairly pure functional language but some Microsoft PM said "it has to support every API in .NET" and so a lot of OOP stuff was bolted on the side. It feels like 2 different worlds in one language. You can easily get by never using the impure stuff but it's still there, taking up space.

F#'s design was almost completely handled by Don Syme, in MS Research Cambridge. It is highly unlikely some PM jumped in and insisted it must do things.

The OOP part is rather coherent; I'm not sure what's bolted on - any examples? In fact, things like object expressions do parts of OOP even better than Java/C#. Overall the syntax for OOP is rather concise and neat.

Having proper interop with .NET and hence the OOP is ... pretty key to making a successful .NET language. Otherwise you lose one major point of being able to use .NET libraries.

> The OOP part is rather coherent; I'm not sure what's bolted on - any examples? In fact, things like object expressions do parts of OOP even better than Java/C#. Overall the syntax for OOP is rather concise and neat.

I'm saying I'm not sure why the OOP exists at all. Someone else pointed at that OCaml has those elements as well, and maybe that's the reason. Just in my own use, I never felt the inclination to use the OOP at all, and their existence felt like this part of the language that I didn't understand, didn't want to understand, but was there nonetheless.

F# has its origins in OCaml which has the same set of properties (ability to write impure code and has an object system, albeit one that not many people use). F# replaced that object system with the .NET one.

A good question, remember Don Syme and Simon Peyton Jones even work in the same building...

I think the main difference is that SLIME is for Common Lisp and Geiser is for Guile/Racket. More than that, I don't know enough about SLIME to say.

SLIME can actually be made to work with many different lisps, including several Scheme implementations. I use it (actually, SLIMV, which is the same thing, only for VIM) with Chicken Scheme.

Thank you for mentioning SLIMV, I am a schemer-in-training and was 'afraid' I would have to abandon my beloved vim.

Ah that might be it, I'm also quite ignorant of Scheme and thought that most Schemes would be able to run without problems; seems like only Scheme48, MITScheme and Kawa are supported.

Haskell certainly has a big learning curve, but the experience will be much more rewarding than learning Clojure or F#. Haskell is a (relatively) uncompromising language and Clojure and F# are really just trying to take some of the features of Haskell and bring them into the mainstream. So if you learn F# or Clojure it may help you if you ever try to learn Haskell, but if you learn Haskell, F# and Clojure will be trivial to learn.

You don't actually need the second lambda since all Haskell functions take one argument, so you can just do

  f = \x y -> x + y

and you'll have an implicit lambda before the y.

Yes, but that has an obvious lack of syntactic parallelism, one especially important when talking about currying since you might be tempted to relate that to the coffee script

    (X, y) -> x+y

It also has a subtly different performance characteristic in GHC, it turns out. Same semantics though.

And of course it has operator segmenting so you can just write

    f = (+)

Or simply:

  f x y = x + y

Python implementations do not have tail call optimization but that doesn't really have anything to do with functional programming.

Common Lisp has mutable data structures by default and actually I think one of the most elegant parts of CL is the setf macro http://www.lispworks.com/documentation/HyperSpec/Body/m_setf..., which is a very clean interface to changing state.

The best functional lisps to use right now would be Clojure and Racket. They both use immutable data structures by default, though neither is "pure". Clojure if you want all the good JVM bits and maybe actually convincing your manager to use it and Racket if you just want to learn using a language that's more beginner-friendly (http://htdp.org/ and the DrRacket IDE) or (mostly) compatible with Scheme (SICP, Little Schemer, etc.).

I've found there aren't really any widely used purely functional languages out there except Haskell (which needs it due to laziness).

Purity is a false idol. CL is a functional programming llanguage. Functional as in programming with functions. Maintenance of referential transparency is the duty of the programmer. As long as you have HOFs and some form of lexical closure as basic language features, you can call a language functional. tail-call optimization, default immutability, automated structure cloning, parameteric datatypes, default currying and h-m type inference are language features that make mathematical reasoning easier, but they are neither essential nor definitive requirements of a functional programming language.

Then python is also a functional language just like cl. Except no-one calls python a functional language, and everyone seems to call cl a functional language.

I'm a grad student that works in Racket and fwiw I find that I prefer emacs for editing but DrRacket for testing and debugging. It has great tools for documentation, locating errors and macro expansion and of course it all works out of the box. I also use Geiser, but I've found it buggy and unreliable (including instantly shutting down my OSX machine if I tell emacs to kill it when I quit, plus I still haven't figured out how to limit its memory consumption).

If you're going to try Scheme and you're scared of emacs/vim, I'd suggest Racket. It's got a nice IDE (DrRacket) and a lot of the community is focused on teaching so there's a lot of resources for newbies http://racket-lang.org/learning.html

I'm an emacs lover myself, but for that use-case it seems like all you need is rlwrap: http://utopia.knoware.nl/~hlub/rlwrap/#rlwrap