Hi Max, neat idea! Haskell supports laziness even on the type level ;) I tried to play with your code but did not get very far. I quickly ran into two problems. On Oct 22, 2010, at 7:37 PM, Max Bolingbroke wrote:
The annoying part of this exercise is the the presence of a "Force" in the functor definition (e.g ListF) means that you can't make them into actual Functor instances! The fmap definition gives you a function of type (a -> b) and you need one of type (Force a -> Force b). However, you can make them into a category-extras:Control.Functor.QFunctor instance
I think `Control.Functor.Categorical.CFunctor` is a more natural replacement for functor here. One can define instance CFunctor (ListF a) ForceCat Hask and I was hoping that I could define `fold` based on CFunctor but I did not succeed. The usual definition of `fold` is fold :: Functor f => (f a -> a) -> Fix f -> a fold f = f . fmap (fold f) and I tried to replace this with fold :: CFunctor f ForceCat Hask => ... but did not find a combination of type signature and definition that compiled. My second problem came up when writing a `Show` instance for the `List` type. This works: instance Show a => Show (List a) where show Nil = "Nil" show (Cons x xs) = "(Cons " ++ show x ++ " " ++ show xs ++ ")" But trying to avoid TypeSynonymInstances leads to a non-terminating `show` function: instance (Show a, Show (Force rec)) => Show (ListF a rec) where show Nil = "Nil" show (Cons x xs) = "(Cons " ++ show x ++ " " ++ show xs ++ ")" Shouldn't both work? Sebastian