使用 catamorphism 忘记 Cofree 注释

Question

I have an AST that I'm annotating using Cofree :

data ExprF a
  = Const Int
  | Add a
        a
  | Mul a
        a
  deriving (Show, Eq, Functor)

I use type Expr = Fix ExprF to represent untagged ASTs, and type AnnExpr a = Cofree ExprF a to represent tagged ones. I've figured out a function to transform tagged ASTs into untagged ones by throwing away all the annotations:

forget :: Functor f => Cofree f a -> Fix f
forget = Fix . fmap uncofree . unwrap

This looks like it might be some sort of catamorphism (I'm using the definition from Kmett's recursion-schemes package).

cata :: (Base t a -> a) -> t -> a
cata f = c where c = f . fmap c . project

I'd think the above rewritten using a catamorphism would look something like this, but I can't figure out what to put for alg to make it typecheck.

forget :: Functor f => Cofree f a -> Fix f
forget = cata alg where
  alg = ???

Any help figuring out if this really is a cata/anamorphism, and some intuition for why it is/isn't would be greatly appreciated.

Answer 1

forget :: Functor f => Cofree f a -> Fix f
forget = cata (\(_ :< z) -> Fix z)
-- (Control.Comonad.Trans.Cofree.:<)
-- not to be confused with
-- (Control.Comonad.Cofree.:<)

Explanation

Looking only at the types, we can show that there is really only one way to implement forget . Let's start with the type of cata :

cata :: Recursive t => (Base t b -> b) -> t -> b

Here t ~ Cofree fa and the type instance of Base for Cofree gives:

type instance Base (Cofree f a) = CofreeF f a

Where CofreeF is:

data CoFreeF f a b = a :< f b
-- N.B.: CoFree also defines a (:<) constructor so you have to be
-- careful with imports.

ie, a fancy pair type. Let's replace it with an actual pair type to make things clearer:

cata :: Functor f => ((a, f b) -> b) -> Cofree f a -> b

Now we're really specializing cata with a more concrete b , namely Fix f :

-- expected type of `cata` in `forget`
cata :: Functor f => ((a, f (Fix f)) -> Fix f) -> Cofree f a -> Fix f

forget is parametric in a and f , so the function we give cata can do nothing with the a in the pair, and the only sensible way to implement the remaining f (Fix f) -> Fix f is the Fix wrapper.

Operationally, Fix is the identity, so (\\(_ :< z) -> Fix z) is really (\\(_ :< z) -> z) which corresponds to the intuition of removing the annotation, ie, the first component of the pair (_ :< z) .