import Data.Functor.Foldable (cata)
import Control.Comonad.Cofree (Cofree)
import Control.Comonad.Trans.Cofree as CofreeT (CofreeF(..))
import Data.Fix (Fix(..))

forget :: Functor f => Cofree f a -> Fix f
forget = cata (\(_ CofreeT.:< z) -> Fix z)

注意：注意Cofree和:<是从哪里导入的。一个来自Control.Comonad.Cofree，另一个来自Control.Comonad.Trans.Cofree（作为CofreeF数据类型的一部分）。
如果从....Trans.Cofree导入Cofree，则cata看起来如下所示：

import Data.Functor.Identity (Identity(..))
import Data.Functor.Compose (Compose(..))
import Data.Functor.Foldable (cata)
import Control.Comonad.Trans.Cofree as CofreeT (Cofree, CofreeF(..))
import Data.Fix (Fix(..))

forget :: Functor f => Cofree f a -> Fix f
forget = cata (\(Compose (Identity (_ CofreeT.:< z))) -> Fix z)

说明

只看类型，我们就可以证明实现forget只有一种方法。让我们从cata的类型开始：

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

这里t ~ Cofree f a和Cofree的Base的类型示例给出：

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

其中CofreeF是：

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

即花式对类型。让我们用一个实际的pair类型来代替它，以使事情更清楚：

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

现在我们用一个更具体的b，即Fix f来专门化cata：

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

forget在a和f中是参数化的，所以我们给予cata的函数不能对这对中的a做任何事情，实现剩余f (Fix f) -> Fix f的唯一合理方法是Fix Package 器。
在操作上，Fix是恒等式，所以(\(_ :< z) -> Fix z)实际上是(\(_ :< z) -> z)，这对应于删除注解的直觉，即对(_ :< z)的第一个分量。