Hat.Control.Monad

Documentation

class Functor f where

Methods

gfmap :: RefSrcPos -> RefExp -> R (Fun (Fun a b) (Fun (f a) (f b)))

sfmap :: R (Fun (Fun a b) (Fun (f a) (f b)))

Instances

Functor List

Functor IO

Functor Maybe

Ix a => Functor (Array a)

class Monad m where

Minimal complete definition

(!>>=), greturn, (|>>=), (|>>), sreturn, sfail

Methods

(!>>=) :: RefSrcPos -> RefExp -> R (Fun (m a) (Fun (Fun a (m b)) (m b)))

(!>>) :: RefSrcPos -> RefExp -> R (Fun (m a) (Fun (m b) (m b)))

greturn :: RefSrcPos -> RefExp -> R (Fun a (m a))

gfail :: RefSrcPos -> RefExp -> R (Fun String (m a))

(|>>=) :: R (Fun (m a) (Fun (Fun a (m b)) (m b)))

(|>>) :: R (Fun (m a) (Fun (m b) (m b)))

sreturn :: R (Fun a (m a))

sfail :: R (Fun String (m a))

Instances

Monad List

Monad IO

Monad Maybe

class Monad m => MonadPlus m where

Methods

gmzero :: RefSrcPos -> RefExp -> R (m a)

gmplus :: RefSrcPos -> RefExp -> R (Fun (m a) (Fun (m a) (m a)))

smzero :: R (m a)

smplus :: R (Fun (m a) (Fun (m a) (m a)))

Instances

MonadPlus List

MonadPlus Maybe

gmapM :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (m b)) (Fun (List a) (m (List b))))

amapM :: RefAtom

hmapM :: Monad m => R (Fun a (m b)) -> R (List a) -> RefExp -> R (m (List b))

gmapM_ :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (m b)) (Fun (List a) (m Tuple0)))

amapM_ :: RefAtom

hmapM_ :: Monad m => R (Fun a (m b)) -> R (List a) -> RefExp -> R (m Tuple0)

gforM :: Monad m => RefSrcPos -> RefExp -> R (Fun (List a) (Fun (Fun a (m b)) (m (List b))))

gforM_ :: Monad m => RefSrcPos -> RefExp -> R (Fun (List a) (Fun (Fun a (m b)) (m Tuple0)))

gsequence :: Monad m => RefSrcPos -> RefExp -> R (Fun (List (m a)) (m (List a)))

gsequence_ :: Monad m => RefSrcPos -> RefExp -> R (Fun (List (m a)) (m Tuple0))

(!=<<) :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (m b)) (Fun (m a) (m b)))

(+=<<) :: RefAtom

(*=<<) :: Monad m => R (Fun a (m b)) -> R (m a) -> RefExp -> R (m b)

(!>=>) :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (m b)) (Fun (Fun b (m c)) (Fun a (m c))))

(+>=>) :: RefAtom

(*>=>) :: Monad m => R (Fun a (m b)) -> R (Fun b (m c)) -> RefExp -> R (Fun a (m c))

(!<=<) :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun b (m c)) (Fun (Fun a (m b)) (Fun a (m c))))

gforever :: Monad m => RefSrcPos -> RefExp -> R (Fun (m a) (m b))

aforever :: RefAtom

hforever :: Monad m => R (m a) -> RefExp -> R (m b)

gvoid :: Functor f => RefSrcPos -> RefExp -> R (Fun (f a) (f Tuple0))

gjoin :: Monad m => RefSrcPos -> RefExp -> R (Fun (m (m a)) (m a))

ajoin :: RefAtom

hjoin :: Monad m => R (m (m a)) -> RefExp -> R (m a)

gmsum :: MonadPlus m => RefSrcPos -> RefExp -> R (Fun (List (m a)) (m a))

amsum :: RefAtom

hmsum :: MonadPlus m => R (List (m a)) -> RefExp -> R (m a)

gfilterM :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (m Bool)) (Fun (List a) (m (List a))))

afilterM :: RefAtom

hfilterM :: Monad m => R (Fun a (m Bool)) -> R (List a) -> RefExp -> R (m (List a))

gmapAndUnzipM :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (m (Tuple2 b c))) (Fun (List a) (m (Tuple2 (List b) (List c)))))

amapAndUnzipM :: RefAtom

hmapAndUnzipM :: Monad m => R (Fun a (m (Tuple2 b c))) -> R (List a) -> RefExp -> R (m (Tuple2 (List b) (List c)))

gzipWithM :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b (m c))) (Fun (List a) (Fun (List b) (m (List c)))))

azipWithM :: RefAtom

hzipWithM :: Monad m => R (Fun a (Fun b (m c))) -> R (List a) -> R (List b) -> RefExp -> R (m (List c))

gzipWithM_ :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b (m c))) (Fun (List a) (Fun (List b) (m Tuple0))))

azipWithM_ :: RefAtom

hzipWithM_ :: Monad m => R (Fun a (Fun b (m c))) -> R (List a) -> R (List b) -> RefExp -> R (m Tuple0)

gfoldM :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b (m a))) (Fun a (Fun (List b) (m a))))

afoldM :: RefAtom

hfoldM :: Monad m => R (Fun a (Fun b (m a))) -> R a -> R (List b) -> RefExp -> R (m a)

gfoldM_ :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b (m a))) (Fun a (Fun (List b) (m Tuple0))))

afoldM_ :: RefAtom

hfoldM_ :: Monad m => R (Fun a (Fun b (m a))) -> R a -> R (List b) -> RefExp -> R (m Tuple0)

greplicateM :: Monad m => RefSrcPos -> RefExp -> R (Fun Int (Fun (m a) (m (List a))))

areplicateM :: RefAtom

hreplicateM :: Monad m => R Int -> R (m a) -> RefExp -> R (m (List a))

greplicateM_ :: Monad m => RefSrcPos -> RefExp -> R (Fun Int (Fun (m a) (m Tuple0)))

areplicateM_ :: RefAtom

hreplicateM_ :: Monad m => R Int -> R (m a) -> RefExp -> R (m Tuple0)

gguard :: MonadPlus m => RefSrcPos -> RefExp -> R (Fun Bool (m Tuple0))

aguard :: RefAtom

hguard :: MonadPlus m => R Bool -> RefExp -> R (m Tuple0)

gwhen :: Monad m => RefSrcPos -> RefExp -> R (Fun Bool (Fun (m Tuple0) (m Tuple0)))

awhen :: RefAtom

hwhen :: Monad m => R Bool -> R (m Tuple0) -> RefExp -> R (m Tuple0)

gunless :: Monad m => RefSrcPos -> RefExp -> R (Fun Bool (Fun (m Tuple0) (m Tuple0)))

aunless :: RefAtom

hunless :: Monad m => R Bool -> R (m Tuple0) -> RefExp -> R (m Tuple0)

gliftM :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a b) (Fun (m a) (m b)))

aliftM :: RefAtom

hliftM :: Monad m => R (Fun a b) -> RefExp -> R (Fun (m a) (m b))

gliftM2 :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b c)) (Fun (m a) (Fun (m b) (m c))))

aliftM2 :: RefAtom

hliftM2 :: Monad m => R (Fun a (Fun b c)) -> RefExp -> R (Fun (m a) (Fun (m b) (m c)))

gliftM3 :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b (Fun c d))) (Fun (m a) (Fun (m b) (Fun (m c) (m d)))))

aliftM3 :: RefAtom

hliftM3 :: Monad m => R (Fun a (Fun b (Fun c d))) -> RefExp -> R (Fun (m a) (Fun (m b) (Fun (m c) (m d))))

gliftM4 :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b (Fun c (Fun d e)))) (Fun (m a) (Fun (m b) (Fun (m c) (Fun (m d) (m e))))))

aliftM4 :: RefAtom

hliftM4 :: Monad m => R (Fun a (Fun b (Fun c (Fun d e)))) -> RefExp -> R (Fun (m a) (Fun (m b) (Fun (m c) (Fun (m d) (m e)))))

gliftM5 :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b (Fun c (Fun d (Fun e f))))) (Fun (m a) (Fun (m b) (Fun (m c) (Fun (m d) (Fun (m e) (m f)))))))

aliftM5 :: RefAtom

hliftM5 :: Monad m => R (Fun a (Fun b (Fun c (Fun d (Fun e f))))) -> RefExp -> R (Fun (m a) (Fun (m b) (Fun (m c) (Fun (m d) (Fun (m e) (m f))))))

gap :: Monad m => RefSrcPos -> RefExp -> R (Fun (m (Fun a b)) (Fun (m a) (m b)))