The Tar Pit

While recently fiddling with the latest version of GHC¹, I noticed that the standard Prelude library now contains a few rather contrived constructions. For example, this is what querying foldl's type yields:

Prelude> :t foldl
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b

This change is the result of the so-called "Functor-Applicative-Monad Proposal" (AMP), and more specifically the "Foldable/Traversable Proposal" (FTP), both being proposed and developed to meet a few very technical issues regarding the standard library. More precisely, the Monad type class naturally inherits Applicative, which in turn inherits Functor; additionally, according to FTP, the Foldable and Traversable classes should be moved into the base library, thus implying that certain functions, such as foldl above, are then given their most general type signature.

These proposals have a few -- again, purely technical -- advantages, the most notable of which being orthogonality. Previously, maintaining for example Monad and Applicative as unrelated classes would have required programmers to provide implementations for both pure and return, despite the fact that the two functions have equivalent semantics. Similarly, providing Foldable and Traversable as part of separate libraries resulted many times in name clashes between the standard foldl and the one in, say, Data.Foldable.

The major downside of this change is however that it makes Haskell completely unsuitable for teaching functional programming in undergraduate courses. To give just an example, the Programming Paradigms course (held in Romanian) at UPB, where I'm a teaching assistant, introduces functional programming using Racket², then focusing on Haskell to illustrate type systems. By taking a look at the course's syllabus, the astute reader would notice that type classes are the very last topic approached by the course.

This begs the question: how would the average teacher would thus use Haskell to explain simple concepts such as folds on lists? and furthermore, how would fundamental principles such as "types-as-documentation" be illustrated using the mess of a signature that GHC 7.10 (and later versions, I presume) provides? How is this even possible, when one of the first type signatures the student ever reads begins with :: Foldable t =>?

To further twist the knife in this wound, it seems that trying to use standards such as Haskell98 or Haskell2010 is now impossible. Previous versions of GHC include a haskell98 alternative to base, which makes it possible to run GHCi the following way:

$ ghci -hide-all-packages -package haskell98

Searching through the mailing lists to find if I could make this possible in the new GHC, I find out that the developers are planning to drop support for the two standards altogether³, because "nobody uses them anyway". This is the same kind of idiotic attitude that projects such as systemd are trying to push, and while they're winning in the face of community resignation, that doesn't make these changes any less outrageous.

Right now, Haskell teachers are left with very few alternatives:

• Putting political pressure on the GHC community to provide support for Haskell98/Haskell2010⁴,
• Reviving Hugs, or
• Replacing Haskell itself with a purely functional language that is more oriented towards teaching⁵.

It's nothing but bitter irony that Haskell, a language praised by the greats⁶, the language for which the term "avoid success at all costs" was coined, is now falling prey to its own popularity, thus becoming in a way the C++ of functional languages⁷. If that's the case, then sure, it's time to move on.

Filed under: olds.
RSS 2.0 feed. Comment. Send trackback.