{-# OPTIONS_GHC -Wall #-}
module Debian.Debianize.Monad
    ( CabalInfo
    , CabalT
    , runCabalT
    , evalCabalT
    , execCabalT
    , CabalM
    , runCabalM
    , evalCabalM
    , execCabalM

    -- * modify cabal to debian package version map
    -- , mapCabal
    -- , splitCabal

    , DebianT
    , evalDebianT
    , evalDebian
    , execDebianT
    , liftCabal

    , ifM
    , whenM
    , unlessM
    ) where

import Control.Lens
import Control.Monad.State (evalState, evalStateT, execState, execStateT, runState, State, StateT(runStateT))
import Debian.Debianize.DebInfo (DebInfo)
import Debian.Debianize.CabalInfo (CabalInfo, debInfo)
import Debian.Orphans ()
import Prelude hiding (init, log, unlines)

type CabalT m = StateT CabalInfo m -- Better name - CabalT?
type CabalM = State CabalInfo

execCabalT :: Monad m => CabalT m a -> CabalInfo -> m CabalInfo
execCabalT :: forall (m :: * -> *) a.
Monad m =>
CabalT m a -> CabalInfo -> m CabalInfo
execCabalT CabalT m a
action CabalInfo
atoms = forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m s
execStateT CabalT m a
action CabalInfo
atoms

evalCabalT :: Monad m => CabalT m a -> CabalInfo -> m a
evalCabalT :: forall (m :: * -> *) a. Monad m => CabalT m a -> CabalInfo -> m a
evalCabalT CabalT m a
action CabalInfo
atoms = forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT CabalT m a
action CabalInfo
atoms

runCabalT :: CabalT m a -> CabalInfo -> m (a, CabalInfo)
runCabalT :: forall (m :: * -> *) a. CabalT m a -> CabalInfo -> m (a, CabalInfo)
runCabalT CabalT m a
action CabalInfo
atoms = forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT CabalT m a
action CabalInfo
atoms

execCabalM :: CabalM a -> CabalInfo -> CabalInfo
execCabalM :: forall a. CabalM a -> CabalInfo -> CabalInfo
execCabalM CabalM a
action CabalInfo
atoms = forall s a. State s a -> s -> s
execState CabalM a
action CabalInfo
atoms

evalCabalM :: CabalM a -> CabalInfo -> a
evalCabalM :: forall a. CabalM a -> CabalInfo -> a
evalCabalM CabalM a
action CabalInfo
atoms = forall s a. State s a -> s -> a
evalState CabalM a
action CabalInfo
atoms

runCabalM :: CabalM a -> CabalInfo -> (a, CabalInfo)
runCabalM :: forall a. CabalM a -> CabalInfo -> (a, CabalInfo)
runCabalM CabalM a
action CabalInfo
atoms = forall s a. State s a -> s -> (a, s)
runState CabalM a
action CabalInfo
atoms

type DebianT m = StateT DebInfo m

evalDebianT :: Monad m => DebianT m a -> DebInfo -> m a
evalDebianT :: forall (m :: * -> *) a. Monad m => DebianT m a -> DebInfo -> m a
evalDebianT = forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT

evalDebian :: DebianT Identity a -> DebInfo -> a
evalDebian :: forall a. DebianT Identity a -> DebInfo -> a
evalDebian = forall s a. State s a -> s -> a
evalState

execDebianT :: Monad m => DebianT m () -> DebInfo -> m DebInfo
execDebianT :: forall (m :: * -> *).
Monad m =>
DebianT m () -> DebInfo -> m DebInfo
execDebianT = forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m s
execStateT

liftCabal :: Monad m => StateT DebInfo m a -> StateT CabalInfo m a
liftCabal :: forall (m :: * -> *) a.
Monad m =>
StateT DebInfo m a -> StateT CabalInfo m a
liftCabal = forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom Lens' CabalInfo DebInfo
debInfo

ifM :: Monad m => m Bool -> m a -> m a -> m a
ifM :: forall (m :: * -> *) a. Monad m => m Bool -> m a -> m a -> m a
ifM m Bool
m m a
t m a
f = m Bool
m forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ Bool
b -> if Bool
b then m a
t else m a
f

whenM :: Monad m => m Bool -> m () -> m ()
whenM :: forall (m :: * -> *). Monad m => m Bool -> m () -> m ()
whenM m Bool
m m ()
r = m Bool
m forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ Bool
b -> if Bool
b then m ()
r else forall (m :: * -> *) a. Monad m => a -> m a
return ()

unlessM :: Monad m => m Bool -> m () -> m ()
unlessM :: forall (m :: * -> *). Monad m => m Bool -> m () -> m ()
unlessM m Bool
m m ()
r = m Bool
m forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ Bool
b -> if Bool
b then forall (m :: * -> *) a. Monad m => a -> m a
return () else m ()
r