Haskell class wrap-up

[From the old-posts-that-I've-sat-on-for-entirely-too-long-for-no-apparent-reason department...]

Back in December, I finished FP101x, Introduction to Functional Programming. I'm stoked that I finally learned me a (little) Haskell, after wanting to get around to it for so long.

The first part of the course was very straight-forward covering the basics of programming in the functional style. But the difficulty ramped up quickly.

A couple of labs were particularly mind-bending, not just for me judging by the message boards. Both were based on Functional Pearl papers and featured monads prominantly. The first was on monad parser combinators and the second was based on A Poor Man's Concurrency Monad. Combining concurrency (of a simple kind), monads and continuation passing is a lot to throw at people at once.

The abrupt shift to more challenging material is part of a philosophy of "teaching the students to fish for themselves". So is introducing new material in the labs rather than in the lectures. This style of teaching alienated a number of students. It's not my favorite, but I can roll with it.

Just be aware that the course requires some self-directed additional reading and don't flail around trying to solve to homeworks without sufficient information.

More Haskell

Now that the class is over, I'd like to find time to continue learning Haskell:

• Finish Learn You a Haskell
• Write yourself a Scheme in 48 hours
• 99 Haskell Problems
• Typeclassopedia
• Chris Allen, aka bitemyapp has a really great How to learn Haskell guide as well as some interesting thoughts about furthering your functional education
• The Haskell Road to Logic, Maths and Programming

One reason I wanted to learn Haskell is to be able to read some of the Haskell-ish parts of the programming languages literature:

• Why Functional Programming Matters - John Hughes
• Theorems for free! - Philip Wadler
• The essence of functional programming - Philip Wadler
• A history of Haskell: being lazy with class - Paul Hudak, John Hughes, Simon Peyton Jones, Philip Wadler

What the #@$% is a Monad?

Monads are like fight club. The first rule of monads is don't blog about monads.

Kind of a design pattern for functional programming, monads are already the subject of more than enough well intentioned but confusing tutorials. We'll not commit the monad tutorial fallacy here. But, monads are needed for a couple of the labs from FP101x, an online class in Haskell - labs with a throw-'em-into-the-deep-end quality to them.

Here's a quick list of some of the better resources I found, while struggling to get a handle on these super-abstract objects of mystery.

Starting points

• Functors, Applicatives, And Monads In Pictures, by Aditya Bhargava, is a friendly place to start.
• Brian Beckman: Don't fear the Monad
• FPComplete's School of Haskell explains what monads are and why to use them.

Phillip Wadler

It's been said that "Monads are hard because there are so many bad monad tutorials getting in the way of finally finding Wadler’s nice paper." Find it here:

• Monads for functional programming

Need more?

Those got me over the first hump, but here are some I may want to come back to later:

• You Could Have Invented Monads! (And Maybe You Already Have)
• Monads for the Curious Programmer by Bartosz Milewski who used to be in Black Sabbath. See also Milewki's easiest way to understand Monads.
• Monads and Gonads a Google Tech-Talk by Douglas Crockford
• Is There Anything Left to Say about Monads?
• Monads in small bites
• Monads for Dummies
• What are monads and why are they useful?

To put monads in a more general context, here's a really great guide to Getting started with Haskell.

Haskell class, so far

Well, I'm about 5 weeks into Introduction to Functional Programming, a.k.a. FP101x, an online class taught in Haskell by Eric Meijer. The class itself is a couple weeks ahead of that; I'm lagging a bit. So, how is it so far, you ask?

The first 4 weeks covered basic functional concepts and how to express them in Haskell, closely following chapters 1-7 of the book, Graham Hutton's Programming in Haskell:

• Defining and applying functions
• Haskell's type system
  • parametric types
  • type classes
  • type signatures of curried functions
• pattern matching
• list comprehensions
• recursion
• higher-order functions

Haskell's hierarchy of type classes is elegant, but some obvious things seem to be missing. For example, you can't show a function. But, it would be really helpful to show something like a docstring, or at least the function's type signature. Also machine-word sized Int's don't automatically promote, so if n is an Int, n/5 produces a type error.

Most of the concepts were familiar already from other functional languages, Scheme via SICP, OCAML via Dan Grossman's programming languages class, and Clojure via The Joy of Clojure. So, this early part was mostly a matter of learning Haskell's syntax.

Some nifty examples

• a recursive definition of factorial:

  factorial :: Integer -> Integer
  factorial 0 = 1
  factorial n = n * (factorial (n-1))

• sum of the first 8 powers of 2:

  sum (map (2^) [0..7])

• a recursive definition of map:

  map :: (a -> b) -> [a] -> [b]
  map f [] = []
  map f (x:xs) = f x : map f xs

• get all adjacent pairs of elements from a list:

  pairs :: [a] -> [(a,a)]
  pairs xs = zip xs (tail xs)

• check if a list of elements that can be ordered is sorted by confirming that each pair of elements is ordered:

  sorted :: Ord a => [a] -> Bool
  sorted xs = and [x <= y |(x,y) <- pairs xs]

Haskell attains its sparse beauty by leaving a lot implied. One thing I figured out during my brief time with OCAML also seems to apply to Haskell. Although these languages lack the forest of parentheses you'll encounter in Lispy languages, it's not that the parentheses aren't there; you just can't see them. A key to reading Haskell is understanding the rules of precedence, associativity and fixity that imply the missing parentheses.

Pre- cedence	Left associative	Non- associative	Right associative
9	!!		.
8			^,^^,**
7	*, /, `div`, `mod`, `rem`, `quot`
6	+,-
5			:,++
4		==, /=, <, <=, >, >=, `elem`, `notElem`
3			&&
2			||
1	>>, >>=
0			$, $!, `seq`

Another key is reading type signatures of curried functions, as currying is the default in Haskell and is relied upon extensively in composing functions, particularly in the extra terse "point-free" style.

Currently, I'm trying to choke down Graham Hutton's Addendum on Monads. If I end up understanding that, it'll get me a code-monkey merit badge, for sure.