Monad.hs

module Hat.Control.Monad
  (Functor(gfmap,sfmap),Monad((!>>=),(!>>),greturn,gfail,(|>>=),(|>>),sreturn
      ,sfail),MonadPlus(gmzero,gmplus,smzero,smplus),gmapM,amapM,hmapM,gmapM_
    ,amapM_,hmapM_,gforM,gforM_,gsequence,gsequence_,(!=<<),(+=<<),(*=<<),(!>=>)
    ,(+>=>),(*>=>),(!<=<),gforever,aforever,hforever,gvoid,gjoin,ajoin,hjoin
    ,gmsum,amsum,hmsum,gfilterM,afilterM,hfilterM,gmapAndUnzipM,amapAndUnzipM
    ,hmapAndUnzipM,gzipWithM,azipWithM,hzipWithM,gzipWithM_,azipWithM_
    ,hzipWithM_,gfoldM,afoldM,hfoldM,gfoldM_,afoldM_,hfoldM_,greplicateM
    ,areplicateM,hreplicateM,greplicateM_,areplicateM_,hreplicateM_,gguard
    ,aguard,hguard,gwhen,awhen,hwhen,gunless,aunless,hunless,gliftM,aliftM
    ,hliftM,gliftM2,aliftM2,hliftM2,gliftM3,aliftM3,hliftM3,gliftM4,aliftM4
    ,hliftM4,gliftM5,aliftM5,hliftM5,gap) where

import qualified Hat.PreludeBasic 
import qualified Prelude 
import Hat.Hack 
import qualified Hat.Hat as T 
import Hat.Hat  (WrapVal(wrapVal))
import Hat.Prelude 
import Hat.Monad 

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

sforM ::
  Monad m => T.R (T.Fun (T.List a) (T.Fun (T.Fun a (m b)) (m (T.List b))))

gforM pforM p = T.uconstUse pforM p sforM

sforM =
  T.uconstDef T.mkRoot aforM
    (\ p -> T.uap1 T.mkNoSrcPos p (gflip T.mkNoSrcPos p) (gmapM T.mkNoSrcPos p))

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

sforM_ :: Monad m => T.R (T.Fun (T.List a) (T.Fun (T.Fun a (m b)) (m T.Tuple0)))

gforM_ pforM_ p = T.uconstUse pforM_ p sforM_

sforM_ =
  T.uconstDef T.mkRoot aforM_
    (\ p ->
      T.uap1 T.mkNoSrcPos p (gflip T.mkNoSrcPos p) (gmapM_ T.mkNoSrcPos p))

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

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

(!>=>) (%>=>) p = T.ufun2 (+>=>) (%>=>) p (*>=>)

(*>=>) ff fg p =
  T.ufun1 T.mkLambda T.mkNoSrcPos p
    (\ fx p ->
      T.uap2 T.mkNoSrcPos p (T.mkNoSrcPos !>>= p) (T.uap1 T.mkNoSrcPos p ff fx)
        fg)

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

(|<=<) ::
  Monad m => T.R (T.Fun (T.Fun b (m c)) (T.Fun (T.Fun a (m b)) (T.Fun a (m c))))

(!<=<) (%<=<) p = T.uconstUse (%<=<) p (|<=<)

(|<=<) =
  T.uconstDef T.mkRoot (+<=<)
    (\ p -> T.uap1 T.mkNoSrcPos p (gflip T.mkNoSrcPos p) (T.mkNoSrcPos !>=> p))

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

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

gforever pforever p = T.ufun1 aforever pforever p hforever

hforever fa p =
  let
    ga' pa' p = T.uconstUse pa' p sa'
    sa' =
      T.uconstDef p a31v19v31v30a'
        (\ p ->
          T.uap2 T.mkNoSrcPos p (T.mkNoSrcPos !>> p) fa (ga' T.mkNoSrcPos p)) in
    (ga' T.mkNoSrcPos p)

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

svoid :: Functor f => T.R (T.Fun (f a) (f T.Tuple0))

gvoid pvoid p = T.uconstUse pvoid p svoid

svoid =
  T.uconstDef T.mkRoot avoid
    (\ p ->
      T.uap1 T.mkNoSrcPos p (gfmap T.mkNoSrcPos p)
        (T.uap1 T.mkNoSrcPos p (gconst T.mkNoSrcPos p)
          (T.con0 T.mkNoSrcPos p T.Tuple0 T.aTuple0)))

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

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

gfoldM_ pfoldM_ p = T.ufun3 afoldM_ pfoldM_ p hfoldM_

hfoldM_ ff fa fxs p =
  T.uap2 T.mkNoSrcPos p (T.mkNoSrcPos !>> p)
    (T.uwrapForward p (hfoldM ff fa fxs p))
    (T.uap1 T.mkNoSrcPos p (greturn T.mkNoSrcPos p)
      (T.con0 T.mkNoSrcPos p T.Tuple0 T.aTuple0))

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

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

greplicateM preplicateM p = T.ufun2 areplicateM preplicateM p hreplicateM

hreplicateM fn fx p =
  T.uap1 T.mkNoSrcPos p (gsequence T.mkNoSrcPos p)
    (T.uwrapForward p (hreplicate fn fx p))

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

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

greplicateM_ preplicateM_ p = T.ufun2 areplicateM_ preplicateM_ p hreplicateM_

hreplicateM_ fn fx p =
  T.uap1 T.mkNoSrcPos p (gsequence_ T.mkNoSrcPos p)
    (T.uwrapForward p (hreplicate fn fx p))

tControl_Monad = T.mkModule "Control.Monad" "Control/Monad.hs" Prelude.False

aforM = T.mkVariable tControl_Monad 150001 150027 3 0 "forM" Prelude.False

aforM_ = T.mkVariable tControl_Monad 190001 190028 3 0 "forM_" Prelude.False

(+>=>) = T.mkVariable tControl_Monad 230003 230005 3 2 ">=>" Prelude.False

(+<=<) = T.mkVariable tControl_Monad 270002 270023 3 0 "<=<" Prelude.False

aforever = T.mkVariable tControl_Monad 310001 310036 3 1 "forever" Prelude.False

avoid = T.mkVariable tControl_Monad 350001 350022 3 0 "void" Prelude.False

afoldM_ = T.mkVariable tControl_Monad 390001 390046 3 3 "foldM_" Prelude.False

areplicateM =
  T.mkVariable tControl_Monad 440001 440043 3 2 "replicateM" Prelude.False

areplicateM_ =
  T.mkVariable tControl_Monad 480001 480044 3 2 "replicateM_" Prelude.False

a31v19v31v30a' = T.mkVariable tControl_Monad 310019 310030 3 0 "a'" Prelude.True