Use lazy

Author: garyb

src/Control/Comonad/Cofree.purs

@@ -10,10 +10,12 @@ module Control.Comonad.Cofree
 
 import Prelude
 
-import Control.Comonad (class Comonad)
 import Control.Alternative (class Alternative, (<|>), empty)
+import Control.Comonad (class Comonad)
 import Control.Extend (class Extend)
+
 import Data.Foldable (class Foldable, foldr, foldl, foldMap)
+import Data.Lazy (Lazy, force, defer)
 import Data.Traversable (class Traversable, traverse)
 
 -- | The `Cofree` `Comonad` for a functor.
@@ -23,12 +25,12 @@ import Data.Traversable (class Traversable, traverse)
 -- |
 -- | The `Comonad` instance supports _redecoration_, recomputing
 -- | labels from the local context.
-data Cofree f a = Cofree a (Unit -> f (Cofree f a))
+data Cofree f a = Cofree a (Lazy (f (Cofree f a)))
 
 -- | Create a value of type `Cofree f a` from a label and a
 -- | functor-full of "subtrees".
 mkCofree :: forall f a. a -> f (Cofree f a) -> Cofree f a
-mkCofree a t = Cofree a \_ -> t
+mkCofree a t = Cofree a (defer \_ -> t)
 
 infixr 5 mkCofree as :<
 
@@ -38,12 +40,12 @@ head (Cofree h _) = h
 
 -- | Returns the "subtrees" of a tree.
 tail :: forall f a. Cofree f a -> f (Cofree f a)
-tail (Cofree _ t) = t unit
+tail (Cofree _ t) = force t
 
-_tail :: forall f a. Cofree f a -> Unit -> f (Cofree f a)
+_tail :: forall f a. Cofree f a -> Lazy (f (Cofree f a))
 _tail (Cofree _ t) = t
 
-_lift :: forall f a b. Functor f => (a -> b) -> (Unit -> f a) -> Unit -> f b
+_lift :: forall f a b. Functor f => (a -> b) -> Lazy (f a) -> Lazy (f b)
 _lift = map <<< map
 
 hoistCofree :: forall f g. Functor f => (f ~> g) -> Cofree f ~> Cofree g
@@ -56,7 +58,8 @@ unfoldCofree
   -> (s -> a)
   -> (s -> f s)
   -> Cofree f a
-unfoldCofree s e n = Cofree (e s) \u -> map (\s1 -> unfoldCofree s1 e n) (n s)
+unfoldCofree s e n =
+  Cofree (e s) (defer \u -> map (\s1 -> unfoldCofree s1 e n) (n s))
 
 instance functorCofree :: Functor f => Functor (Cofree f) where
   map f = loop where