The Universe of Discourse : Why I never finish my Haskell programs (part 3 of ∞)

Why I never finish my Haskell programs

Summary for those who don't want to read 3 blog posts: "because I start generalizing too early instead of doing useful progress".

Yeah, in Haskell it's super easy to parameterize over X, whatever X is. But this should be driven by need, not by mere possibility. So next time you add another dependency to instantiate Contravariant (yes, I know it's in the base 4.12 now) or add another typeclass, or do something similar, think again, why do you do it: is it important for your problem or you just like to feel smart?

The worst that can happen is when you start generalizing a concept of which you only saw a single instance.

u/mjd has another complaint about how Haskell typing is difficult.

This is actually a harder one than last time -- it boils down to using a parameter at two different types, with the mild complication of the Functor typeclass thrown in. He's working with matrices, represented as lists of lists, and has to convert them back and forth from another functor (to get different list behavior).

He wants to define a function to do both directions:

twice zl m = zl (fmap zl m)

but this uses zl at two different types.

The solution is rank-2 types, which is rather a lot of machinery for something that seems like it should be doable more easily. It's also not exactly trivial to find and describe the problem.

But in terms of actual modifications to use, it's fairly simple:

Add

{-# LANGUAGE RankNTypes #-}

and change

twice :: (Functor f, Functor g) => (f a -> g a) -> f (f a) -> g (g a)

to

twice :: (Functor f, Functor g) => (forall a. f a -> g a) -> f (f b) -> g (g b)

.

To simplify newtype wrapping-unwrapping, perhaps he could make use of coerce:

import Data.Coerce

matrix :: [[a]] -> ZipList (ZipList a)
matrix = coerce

unmatrix :: ZipList (ZipList a) -> [[a]]
unmatrix = coerce

And, using the extra functions from coercible-utils he could write:

matrixplus :: Num a => [[a]] -> [[a]] -> [[a]]
matrixplus = under2 matrix $ \m n -> (liftA2 . liftA2) (+) m n

Which is slightly more elegant because you only have to give the packer, not the packer and the unpacker both.

Also, if he had defined matrix like this:

import Data.Functor.Compose

matrix :: [[a]] -> Compose ZipList ZipList a
matrix = coerce

then he would only have needed a single liftA2 in matrixplus:

matrixplus :: Num a => [[a]] -> [[a]] -> [[a]]
matrixplus = under2 matrix $ \m n -> liftA2 (+) m n

To solve the posters original problem, I'd like to point out the nifty little function zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]. Let's play with this for a moment. What's the type of zipWith (+)? GHCI says Num c => [c] -> [c] -> [c]. Which looks an awful lot like vector addition to me. Which we can leverage to create matrix addition: zipWith (zipWith (+)) has the type Num c => [[c]] -> [[c]] -> [[c]] and indeed does what we wish it to do. (zipWith (zipWith (+))) [ [1,2], [3,4] ] [ [10,20], [30,40] ] returns [[11,22],[33,44]].

This is a lesson everyone has to learn the hard way. When you're trying to do something simple in Haskell, and the type checker is fighting you, and you find yourself enabling all sorts of crazy extensions, that generally means you missed a left turn in Albuquerque. Learning a new language is hard. Go back, look at other functions, other type classes. You've missed something.

The function ‘twice’ seems like a very obscure generalisation to me... Maybe my bar is just much lower, and I would be happy with a simple zipWith and stop there 🙂.