Problem is, when confronted with it, part of my brain kicks into gear, and complains. This looks suspiciously like math! And you suck at math! You don’t belong here! This language is not for you! You will not be able to understand the more complicated constructions!

And that is exactly one of the reasons why I want to learn it… or at least, more of it. I want to challenge myself. I don’t know how far I will get. It’s very alien territory. Along the way, I expect to encounter:

• a completely different way of building programs, and thinking about them
• static typing (naturally), something I dislike greatly because it gets in my way
• language zealotry (already saw some of that while casually browsing haskell-cafe; no need for a link though)
• intellectual pretentiousness
• lots of hairy math (category theory?!)
• notions of what is considered “good programming style and habits”, that fly in the face of what I am used to
• limited practical usefulness at first (until I understand the deeper aspects of the language, and how to use it properly)

And I will have to deal with this somehow. How it will work out, I don’t know. Maybe I’ll come back screaming after a few days; I might not be ready for it. But we’ll see.

Another reason for wanting to learn it is this article: Why I’m interested in Haskell. One of the points the author makes is that Haskell is one of the few languages where actual new stuff is being invented. Actual new stuff, not rehashed concepts that Lisp or Smalltalk had decades ago.

(I have been looking for such a language for a long time. Python was a “paradigm shift” for me when I first learned it started understanding the power of dynamic languages. But for the last few years I have been wondering what there would be “after” Python. Is there a language that would give you similar gains over Python, as Python gave over C/C++/Pascal and their ilk? Maybe Lisp, but aside from the syntactic flexibility (by way of macros), it isn’t that different, as the aforementioned article points out. Haskell on the other hand, is a completely different beast — hard to understand, but with definite benefits, and possibly worth the effort.)

In any case, for right now this will just be another hobby project of mine… Interesting developments, if any, will be reported here.

Unlike its general-purpose counterpart, Hayoo seems to return the best results. For example, you can look for all packages that have a function foldl, or for the functions in the Data.Tree.AVL package.

Now if we only had such a beast for Python… :-)

f :: Int -> [ (Int, Int, Int) ]

f n = [ (x, y, z) |
x <- [ 1 .. n ],
y <- [ x+1 .. n ],
z <- [ y+1 .. n ],
(x * x) + (y * y) == (z * z) ]

I first thought there was some special magic going on, like maybe some Prolog-like matching, but then I realized that you can do the same in Python:

def f(n):
    return [(x,y,z)
            for x in range(1, n+1)
            for y in range(x+1, n+1)
            for z in range(y+1, n+1)
            if x*x + y*y == z*z]
print f(20)

(Which isn’t so surprising after all, as Python “borrowed” list comprehensions from Haskell… but still.)