//@NO-IMPLICIT-PRELUDE
//! Monad transformer version of `Lazy`
let { Applicative, apply, wrap } = import! std.applicative
let { (<<) } = import! std.function
let { Functor, map } = import! std.functor
let { Lazy, lazy, force } = import! std.lazy
let { Monad, flat_map } = import! std.monad
let { Transformer } = import! std.transformer
type LazyT m a = Lazy (m a)
let functor : [Functor m] -> Functor (LazyT m) =
let ltmap f ma = lazy (\_ -> map f (force ma))
{ map = ltmap }
let applicative : [Applicative m] -> Applicative (LazyT m) =
let ltwrap a = lazy (\_ -> wrap a)
let ltapply mf ma = lazy (\_ -> apply (force mf) (force ma))
{ functor, apply = ltapply, wrap = ltwrap }
let monad : [Monad m] -> Monad (LazyT m) =
let ltflat_map f ma = lazy (\_ -> flat_map (force << f) (force ma))
{ applicative, flat_map = ltflat_map }
let transformer : Transformer LazyT =
let wrap_monad ma : [Monad m] -> m a -> LazyT m a = lazy (\_ -> ma)
{ /* monad, */ wrap_monad }
let force_t : LazyT m a -> m a = force
{
LazyT,
force_t,
functor,
applicative,
monad,
transformer
}