[Haskell-beginners] Extend instance for List

[Graham Gill]

The NICTA course <https://github.com/NICTA/course> includes exercises on 
the type class Extend, in Course/Extend.hs. Extend is a superclass of 
Comonad. Here's the class definition:
> -- | All instances of the `Extend` type-class must satisfy one law. 
> This law
> -- is not checked by the compiler. This law is given as:
> --
> -- * The law of associativity
> --   `∀f g. (f <<=) . (g <<=) ≅ (<<=) (f . (g <<=))`
> class Functor f => Extend f where
>   -- Pronounced, extend.
>   (<<=) ::
>     (f a -> b)
>     -> f a
>     -> f b
>
> infixr 1 <<=

Could someone please motivate the Extend instance for List? (Its 
implementation is left as an exercise. In the course, type List a is 
isomorphic to [a].) Some of the tests (<<=) is expected to pass are 
shown, and make clear what ought to happen.
> -- | Implement the @Extend@ instance for @List at .
> --
> -- >>> length <<= ('a' :. 'b' :. 'c' :. Nil)
> -- [3,2,1]
> --
> -- >>> id <<= (1 :. 2 :. 3 :. 4 :. Nil)
> -- [[1,2,3,4],[2,3,4],[3,4],[4]]
> --
> -- >>> reverse <<= ((1 :. 2 :. 3 :. Nil) :. (4 :. 5 :. 6 :. Nil) :. Nil)
> -- [[[4,5,6],[1,2,3]],[[4,5,6]]]

The following (wrong, according to the tests) Extend instance for List 
nevertheless obeys the types and obeys the Extend law of associativity.
> instance Extend List where
>   (<<=) ::
>     (List a -> b)
>     -> List a
>     -> List b
>   (<<=) f = (:. Nil) . f
(:. Nil) is analogous to (: []), create a singleton list.

I can't find a good reference on the Extend type class to convince me 
why the correct Extend instance for List in the course is the desirable 
one. (I'm not saying my version is desirable, in fact it seems fairly 
useless, but it works.)

Graham

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/beginners/attachments/20151213/85064018/attachment.html>