John Goerzen: Haskell Fun
Bryan O'Sullivan noted over at the Real World Haskell blog that Haskell made quite the impact at OSCon. And I can attest to Simon Peyton-Jones having trouble leaving the building because of all the people that wanted to talk to him about Haskell. It was interesting to think about "why now" for Haskell's popularity. Bryan's post has links to the video of Simon's talks, which are great. (Sample quote: "Oh look, a whiteboard has appeared as if by magic! What joy!")
I followed Bryan's link to the Haskell/OSCon-related blog posts at Technorati. Here's an interesting one by chromatic, who gave some Perl talks at OSCon. Favorite quote:
So what is this business about Haskell functions taking only one argument? Let's look at a quick example. Say I wanted to write a function to multiply two numbers. I'd write:
I could give the type of this function like this:
You could read that as "mul takes two Ints and returns an Int". And you can think of it this way. But you could also write the type this way:
It means the exact same thing and is valid to Haskell. To read it, you'd say "mul takes an Int and returns a function that takes an Int and returns an Int." And truly this is what Haskell functions that take multiple parameters are doing. Now, I can say:
mulByThree has type
This is a tremendously useful feature. For instance:
I've applied >= to only one argument here. That's fine; it returns a function that's exactly what filter wants.
I've been watching the video of Simon's Taste of Haskell talk. I could *hear* when the audience grasped the utility of this because there was a collective "Oooooo!" from them.
By the way, Haskell has type inference, so I didn't have to give types at all. Oh, and you can also refer to the function itself by not giving any arguments.
This is one small reason I like to say "Haskell manipulates functions with the same ease that Perl manipulates strings." Mind-bending, isn't it?
I followed Bryan's link to the Haskell/OSCon-related blog posts at Technorati. Here's an interesting one by chromatic, who gave some Perl talks at OSCon. Favorite quote:
I sat next to Nat Torkington at the tutorial. He kept rubbing his temples. At one point I leaned over and said, The interesting thing about Haskell is that its functions only take one argument. He turned green.
In all seriousness, well-factored Haskell code resembles well-factored Smalltalk code: if you have functions (or methods) longer than a handful of lines, you re probably doing too much. Lower level languages such as C rarely give the opportunity for composition and abstraction that you can get out of functional languages. The presence of pure functions functions which never change global state and which return the same output for the same input is also immensely important.
It s actually the combination of the two features which give these languages such power. When Haskell forces you to mark impure functions explicitly, it gives you tools to isolate behavior which can change global state in the smallest possible scopes, and prevents you from composing impure and pure code together accidentally. When Haskell lets you compose functions into larger functions, not only does it help you write code more concisely, but it provides well-defined units of behavior which work along well-defined and isolated boundaries.
So what is this business about Haskell functions taking only one argument? Let's look at a quick example. Say I wanted to write a function to multiply two numbers. I'd write:
mul a b = a * bI could give the type of this function like this:
mul :: Int -> Int -> IntYou could read that as "mul takes two Ints and returns an Int". And you can think of it this way. But you could also write the type this way:
mul :: Int -> (Int -> Int)It means the exact same thing and is valid to Haskell. To read it, you'd say "mul takes an Int and returns a function that takes an Int and returns an Int." And truly this is what Haskell functions that take multiple parameters are doing. Now, I can say:
fifteen = mul 3 5
mulByThree = mul 3
fifteen' = mulByThree 5
fifteen'' = (mul 3) 5
mulByThree has type
Int -> Int; it's a function that we got by simply not applying "mul" to all its arguments. fifteen'' illustrates what is going on internally when you write "mul 3 5". It turns out that being able to call a function with multiple arguments is just some syntactic sugar to Haskell.This is a tremendously useful feature. For instance:
filter (>= 10) [1..20]I've applied >= to only one argument here. That's fine; it returns a function that's exactly what filter wants.
I've been watching the video of Simon's Taste of Haskell talk. I could *hear* when the audience grasped the utility of this because there was a collective "Oooooo!" from them.
By the way, Haskell has type inference, so I didn't have to give types at all. Oh, and you can also refer to the function itself by not giving any arguments.
mul = (*)This is one small reason I like to say "Haskell manipulates functions with the same ease that Perl manipulates strings." Mind-bending, isn't it?
* I officially hate Mumbai traffic, now. Many thanks to people who did RSVP and didn’t appear.
But how about keywords not being availble in grml-tips collection yet? What about keywords other users request but don’t get a match? Thanks to 
Do you want to submit the keyword 'nfs' to grml's keyword database?
The grml team will write tips for the most requested and useful keywords.
To use and contribute to this feature you'll need a working networking connection.
No personal data will be transmitted to the database.
Send "nfs" to grml's keyword database? [y N]
Keyword 'nfs' has been submitted to grml's keyword database.
Thanks.
%
All what’s missing now is a bot that writes all the missing tips on its own. 
Conclusion: make it easy for your users to submit information you might be interested in - to help your users.
