Hat.Monad

Documentation

class Monad m => MonadPlus m where

Minimal complete definition

gmzero, gmplus

Methods

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

smzero :: R (m a)

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

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

Instances

MonadPlus List

Methods

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

smzero :: R (List a)

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

smplus :: R (Fun (List a) (Fun (List a) (List a)))

MonadPlus Maybe

Methods

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

smzero :: R (Maybe a)

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

smplus :: R (Fun (Maybe a) (Fun (Maybe a) (Maybe a)))

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)

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)

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

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)

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))))))

class Monad m where

Minimal complete definition

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

Methods

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

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

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

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

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

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

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

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

Instances

Monad List

Methods

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

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

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

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

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

sreturn :: R (Fun a (List a))

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

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

Monad IO

Methods

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

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

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

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

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

sreturn :: R (Fun a (IO a))

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

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

Monad Maybe

Methods

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

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

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

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

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

sreturn :: R (Fun a (Maybe a))

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

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

class Functor f where

Minimal complete definition

gfmap

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

Methods

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

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

Functor IO

Methods

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

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

Functor Maybe

Methods

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

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

Ix a => Functor (Array a)

Methods

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

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

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)

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)