It would seem that the better you get at python, the more you really want a functional language. I know I went through this too (and I have moved onto functional languages for personal projects since..)
I remember that the "Real World Haskell" was one of the first books sold-out at the OReilly booth at Pycon 2009, if you want more supporting (anecdotal) evidence.
To add to the evidence, I'm an experienced Python programmer who is currently waiting very impatiently for his Amazon shipment of "Real World Haskell" and "Purely Functional Data Structures". (Oh, and "Garfield Minus Garfield".)
The last of those books opens with "Objective Caml (OCaml) is a popular, expressive, high-perfomance dialect of ML...". This must be some hitherto unknown usage of the word "popular"...
I write what I believe to be functional style Python, and have great coverage and fairly easy multithreading (normally using 2.6 Queue objects) as a result. I really like the clean syntax of Python, the less I have to look at on screen the better. Do you think there's a functional programming language I'd like? I've looked at Erlang but not been persuaded.
Clojure is a particularly interesting functional language for a python programmer IMO. It shares a number of asthetic and cultural properties with python that other lisps and other functional languages don't provide.
Syntactically they are approximately distantish cousins. Clojure's syntax is much more restricted that pythons (obviously ;) but more prominent than other the other big lisps. Of note there is literal support for Vectors (much closer to pythons lists than the functional singly linked list), Maps, Sets, and these are used in the special forms too. A comparison (lets use identical implementations of factorial - taking some liberties so that the code is actually semantically identical, There are more idiomatic versions down the thread)
def fac(n):
"A function to calculate factorial in python"
return reduce(lambda x, y: x * y, range(1, n + 1))
(defn fac
"A function to calculate factorial in clojure"
[n]
(reduce #(* %1 %2) (range 1 (+ n 1)))
In particular there is the vector in the form ([n]) used for the arguments list. The other thing to comment on is the funny looking #(* %1 %2) bit, thats an anonymous function/expression. There are two ways to write functions in clojure, that way and using a fn form. That same expression would look like
(fn [x y] (* x y))
Clearly this becomes a matter of readability in most cases. Like python it means you have two ways to express a function. In this case you could actually just drop * in instead of the lambda, because it is just a symbol referencing a function like any other name. Python would require importing the operators library to do the same thing.
Both languages are quite opinionated about the right way to do things. You are probably familiar with pythons. Clojure has a strong philosophy behind it, but its still pragmatic. Clojure promotes pure functional programming wherever its possible, and provides an excellent range of tools to break out of that where needed.
Like Python, Clojure has good package management, good core data structures, lazy sequences (much stronger than pythons generators), quite a few batteries included (in particular if you consider clojure.contrib) though not as many as python.
So if there are so many similarities, why would you switch? A number of reasons have made me do more and more of my development in python rather than clojure.
First up i want to do more functional programming. Like many long time python programmers i started using functools and itertools, generators etc more and more, but functional style is not encouraged by certain parts of the community.
Secondly, concurrency. I've written a bit of concurrent code in python (usually in an actor style using the queue objects) but python is ill suited to this, Clojure's persistent datastructures are much stronger here. In addition there is no GIL so concurrent code is able to run fast, not just asynchronously. On top of this, clojures references types provide _many_ options for concurrency which often simplify your design considerably compared to writing a message passing thing in python.
Packaging and deployment is much better. If you are using a unix system http://github.com/technomancy/leiningen is a must get. This is a build tool that manages dependancies for you automatically. It integrates with the clojars.org repository. This pairing replaces pip/easy_install and the cheeseshop as well as tools like virtualenv.
The community is great.
If you want to get started, the following comment by hga might serve you well https://qht.co/item?id=1033503 Rich Hickey's various presentations and lectures make a compelling case for the language, and teach you a lot about how to use it at the same time. Even if you never end up writing code in clojure, these videos will teach you a huge amount, i highly recommend them.
As you can probably tell from the amount of blather here, clojure has impressed me, and i would recommend any python programmer who has become interested in functional stuff check it out.
Clojure is actually one of the languages I've moved to, from Python, and is currently my favourite programming language to work in. Functional programming, immutable data structures, great built in data structure support, macros, excellent concurrency support, a good standard library and direct access to Java libraries all make Clojure a beautifully powerful and easy language to work in. The clojure community is also very friendly and growing every day, so if you need it, getting suppor is not hard.
I do still like Python, but theres so much more nice things out there. Besides clojure, I'm playing with Yeti and hope to give F# a look soon too. Maybe some day I'll have some time to play with Haskell also; its been on my todo list for a long time.
Ive dabbled in Haskell and F# myself; I found Haskell to be the amazing mind awakening experience people talk about, but it also frustrates the hell out of my sometimes. All the syntax around types confuses my simple brain.
F# on the other hand felt a lot like a functional python for .Net. Complete with the syntactic whitespace and a light weight class syntax that feels very similar to pythons classes (completely with explicit self).
Both worth exploring IMO. I've not look at yeti, so i'm going to check that out, thanks!
Yeti is a small and simple ML-derived language for the JVM. I found it refreshingly simple (an afternoon with the tutorial and I felt comfortable with it, though I have yet to write anything "real" in it) and the "community" is quick to respond to queries (community is in quotes because theres only about five of us on the mailing list...).
I plan on using Yeti as the "formula" language in a spreadsheet type program :-)
Clojure is very fast. It generally runs quickly, but then you can profile and add a couple of type hints and watch it run about as fast as java.
It's still a dynamic language, but names can only be defined in specific forms (eg def, let etc). This means that the compiler pulls you up on referencing symbols that don't exist. This is a huge productivity win.
