Learn You a Haskell for Great Good

They were PL researchers. Used to ML, Common Lisp, Ada, and, most importantly, Mathematics and Category and Type Theory.

`data` introduces an algebraic data type, so it makes sense to use data as a keyword. `type` and `newtype`, on the other hand, are programmer's conveniences: both carry no runtime cost, they are not actually part of the semantics of the backend language.

`map` is a function that's really just a specialization of `fmap`. Now, my category theory is a bit weak, but if I'm thinking correctly here, `fmap f` is an endofunctor in the category of functors, and so it makes perfect sense to call "mappable" Functor. There's also "Traversable," which works pretty much like a fully-fledged "mappable" with all extras, but also requires a Functor instance.

Keywords, and idiosyncrasies of a syntactic nature are really just superficial. The actual elegance of the language is its type system. (The actual warts of the language are, for the most part, also in the type system; records for example.) The latter criticism about `mappable` is really just due to the fact that you haven't gotten used to the underlying theory (and I don't blame you, it's hard.) But getting used to it can be rewarding. I'm not saying it's going to make you a better programmer (I'm not necessarily of that opinion,) but it's rewarding in its own right.

Oh, and the difference between data constructors, type names, and, later, kind names (with promotion, since 7.4,) can be confusing. I sometimes find it an oversight that they are not distinguished syntactically, I think that would greatly help most newbies, and sometimes even make things easier to read and understand for veterans, too.

Take this in p52 for instance:

maximum' :: (Ord a) => [a] -> a

maximum' [] = error "Maximum of empty list!"

maximum' [x] = x

maximum' (x:xs) = max x (maximum xs)

Now, you may think that implies that you could do something like this to print a string one character at a time:

rsoat (x:xs) = show x (rsoat xs)

Buy you can't. If you try that Haskell complains "The function 'show' is applied to two arguments, but its type 'a0 -> String' has only one...."

Fair enough, one might reason - you're just passing max two things when it wants one so we can do something like this:

rsoat [] = []

rsoat [x] = show x

rsoat (x:xs) = rsoat xs

But no, that just gets you the tail of your string because x:xs doesn't match x so it never prints the other bits.

What you may end up doing is something like this:

rsoat [] = []

rsoat [x] = [x]

rsoat (x:xs) = show x ++ (rsoat xs)

But that's still not really doing what you wanted to do in the first place. It's sticking all your characters into a string and then reading that string all at once. And it's not a particularly obvious solution either if you don't know the language.

This may seem a silly example. But what happens when, as is frequently the case, someone wants to retrieve the nth element of a list? (list !! n) Haskell, as learnt through Learn You a Haskell, can easily be expected to drive someone up the wall who starts asking such questions - it's not a whole bunch of fun to play with.

No, I know what it does. That's how the book describes it however:

"The most commonly used function that operate on instances of this type class is show, _which prints the given value as a string_"

> Uh, no. It doesn't give you the tail of the string, it gives you a list containing just the last element of the argument (if the argument's not empty), or the empty list (if the argument is empty) - which you can read directly from your definition.

I continually forget that tail means the rest of the thing.

> Furthermore, " x:xs doesn't match x" doesn't make a whole lot of sense - it's not supposed to match x, it's supposed to match a non-empty list. Which it does, and the first element of such a list gets bound to the parameter x - but you do not use the parameter in your right-hand side of the definition, so you effectively discard it.

We're far enough away from what each other are thinking that this just isn't worth talking about as written.

You've already matched your list to x earlier in the program so x:xs doesn't get a chance to run. You're not showing x and then falling through to pass xs to the function again and chopping the first element off of that to show - and so on.

> Note that both pattern matching and the Show typeclass (and the corresponding function) are discussed in the book prior to the minimum example.

This:

http://i.imgur.com/7NKReoL.jpg

is not a discussion of the show type class and corresponding function.

I've tinkered with other functional languages (Erlang, Scheme and Clojure), but Haskell is a stranger beast.