{-# LANGUAGE Safe #-}{-# LANGUAGE FunctionalDependencies #-}{-# LANGUAGE FlexibleInstances #-}{-# LANGUAGE MultiParamTypeClasses #-}-- Search for UndecidableInstances to see why this is needed{-# LANGUAGE UndecidableInstances #-}-- Needed because the CPSed versions of Writer and State are secretly State-- wrappers, which don't force such constraints, even though they should legally-- be there.{-# OPTIONS_GHC -Wno-redundant-constraints #-}------------------------------------------------------------------------------- |-- Module : Control.Monad.State.Class-- Copyright : (c) Andy Gill 2001,-- (c) Oregon Graduate Institute of Science and Technology, 2001-- License : BSD-style (see the file LICENSE)---- Maintainer : libraries@haskell.org-- Stability : experimental-- Portability : non-portable (multi-param classes, functional dependencies)---- MonadState class.---- This module is inspired by the paper-- /Functional Programming with Overloading and Higher-Order Polymorphism/,-- Mark P Jones (<http://web.cecs.pdx.edu/~mpj/>)-- Advanced School of Functional Programming, 1995.-----------------------------------------------------------------------------moduleControl.Monad.State.Class(MonadState (..),modify ,modify' ,gets )whereimportControl.Monad.Trans.Cont(ContT)importControl.Monad.Trans.Except(ExceptT)importControl.Monad.Trans.Identity(IdentityT)importControl.Monad.Trans.Maybe(MaybeT)importControl.Monad.Trans.Reader(ReaderT)importqualifiedControl.Monad.Trans.RWS.LazyasLazyRWSimportqualifiedControl.Monad.Trans.RWS.StrictasStrictRWSimportqualifiedControl.Monad.Trans.State.LazyasLazyimportqualifiedControl.Monad.Trans.State.StrictasStrictimportqualifiedControl.Monad.Trans.Writer.LazyasLazyimportqualifiedControl.Monad.Trans.Writer.StrictasStrictimportControl.Monad.Trans.Accum(AccumT)importControl.Monad.Trans.Select(SelectT)importqualifiedControl.Monad.Trans.RWS.CPSasCPSRWSimportqualifiedControl.Monad.Trans.Writer.CPSasCPSimportControl.Monad.Trans.Class(lift)-- ----------------------------------------------------------------------------- | Minimal definition is either both of @get@ and @put@ or just @state@classMonadm =>MonadState s m |m ->s where-- | Return the state from the internals of the monad.get ::m s get =forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state (\s
s ->(s
s ,s
s ))-- | Replace the state inside the monad.put ::s ->m ()put s
s =forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state (\s
_->((),s
s ))-- | Embed a simple state action into the monad.state ::(s ->(a ,s ))->m a state s -> (a, s)
f =dos
s <-forall s (m :: * -> *). MonadState s m => m s
get let~(a
a ,s
s' )=s -> (a, s)
f s
s forall s (m :: * -> *). MonadState s m => s -> m ()
put s
s' forall (m :: * -> *) a. Monad m => a -> m a
returna
a {-# MINIMALstate |get ,put #-}-- | Monadic state transformer.---- Maps an old state to a new state inside a state monad.-- The old state is thrown away.---- > Main> :t modify ((+1) :: Int -> Int)-- > modify (...) :: (MonadState Int a) => a ()---- This says that @modify (+1)@ acts over any-- Monad that is a member of the @MonadState@ class,-- with an @Int@ state.modify ::MonadState s m =>(s ->s )->m ()modify :: forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify s -> s
f =forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state (\s
s ->((),s -> s
f s
s ))-- | A variant of 'modify' in which the computation is strict in the-- new state.---- @since 2.2modify' ::MonadState s m =>(s ->s )->m ()modify' :: forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify' s -> s
f =dos
s' <-forall s (m :: * -> *). MonadState s m => m s
get forall s (m :: * -> *). MonadState s m => s -> m ()
put forall a b. (a -> b) -> a -> b
$!s -> s
f s
s' -- | Gets specific component of the state, using a projection function-- supplied.gets ::MonadState s m =>(s ->a )->m a gets :: forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets s -> a
f =dos
s <-forall s (m :: * -> *). MonadState s m => m s
get forall (m :: * -> *) a. Monad m => a -> m a
return(s -> a
f s
s )instanceMonadm =>MonadState s (Lazy.StateTs m )whereget :: StateT s m s
get =forall (m :: * -> *) s. Monad m => StateT s m s
Lazy.getput :: s -> StateT s m ()
put =forall (m :: * -> *) s. Monad m => s -> StateT s m ()
Lazy.putstate :: forall a. (s -> (a, s)) -> StateT s m a
state =forall (m :: * -> *) s a. Monad m => (s -> (a, s)) -> StateT s m a
Lazy.stateinstanceMonadm =>MonadState s (Strict.StateTs m )whereget :: StateT s m s
get =forall (m :: * -> *) s. Monad m => StateT s m s
Strict.getput :: s -> StateT s m ()
put =forall (m :: * -> *) s. Monad m => s -> StateT s m ()
Strict.putstate :: forall a. (s -> (a, s)) -> StateT s m a
state =forall (m :: * -> *) s a. Monad m => (s -> (a, s)) -> StateT s m a
Strict.state-- | @since 2.3instance(Monadm ,Monoidw )=>MonadState s (CPSRWS.RWSTr w s m )whereget :: RWST r w s m s
get =forall (m :: * -> *) r w s. Monad m => RWST r w s m s
CPSRWS.getput :: s -> RWST r w s m ()
put =forall (m :: * -> *) s r w. Monad m => s -> RWST r w s m ()
CPSRWS.putstate :: forall a. (s -> (a, s)) -> RWST r w s m a
state =forall (m :: * -> *) s a r w.
Monad m =>
(s -> (a, s)) -> RWST r w s m a
CPSRWS.stateinstance(Monadm ,Monoidw )=>MonadState s (LazyRWS.RWSTr w s m )whereget :: RWST r w s m s
get =forall w (m :: * -> *) r s. (Monoid w, Monad m) => RWST r w s m s
LazyRWS.getput :: s -> RWST r w s m ()
put =forall w (m :: * -> *) s r.
(Monoid w, Monad m) =>
s -> RWST r w s m ()
LazyRWS.putstate :: forall a. (s -> (a, s)) -> RWST r w s m a
state =forall w (m :: * -> *) s a r.
(Monoid w, Monad m) =>
(s -> (a, s)) -> RWST r w s m a
LazyRWS.stateinstance(Monadm ,Monoidw )=>MonadState s (StrictRWS.RWSTr w s m )whereget :: RWST r w s m s
get =forall w (m :: * -> *) r s. (Monoid w, Monad m) => RWST r w s m s
StrictRWS.getput :: s -> RWST r w s m ()
put =forall w (m :: * -> *) s r.
(Monoid w, Monad m) =>
s -> RWST r w s m ()
StrictRWS.putstate :: forall a. (s -> (a, s)) -> RWST r w s m a
state =forall w (m :: * -> *) s a r.
(Monoid w, Monad m) =>
(s -> (a, s)) -> RWST r w s m a
StrictRWS.state-- ----------------------------------------------------------------------------- Instances for other mtl transformers---- All of these instances need UndecidableInstances,-- because they do not satisfy the coverage condition.instanceMonadState s m =>MonadState s (ContTr m )whereget :: ContT r m s
get =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall s (m :: * -> *). MonadState s m => m s
get put :: s -> ContT r m ()
put =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *). MonadState s m => s -> m ()
put state :: forall a. (s -> (a, s)) -> ContT r m a
state =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state -- | @since 2.2instanceMonadState s m =>MonadState s (ExceptTe m )whereget :: ExceptT e m s
get =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall s (m :: * -> *). MonadState s m => m s
get put :: s -> ExceptT e m ()
put =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *). MonadState s m => s -> m ()
put state :: forall a. (s -> (a, s)) -> ExceptT e m a
state =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state instanceMonadState s m =>MonadState s (IdentityTm )whereget :: IdentityT m s
get =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall s (m :: * -> *). MonadState s m => m s
get put :: s -> IdentityT m ()
put =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *). MonadState s m => s -> m ()
put state :: forall a. (s -> (a, s)) -> IdentityT m a
state =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state instanceMonadState s m =>MonadState s (MaybeTm )whereget :: MaybeT m s
get =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall s (m :: * -> *). MonadState s m => m s
get put :: s -> MaybeT m ()
put =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *). MonadState s m => s -> m ()
put state :: forall a. (s -> (a, s)) -> MaybeT m a
state =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state instanceMonadState s m =>MonadState s (ReaderTr m )whereget :: ReaderT r m s
get =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall s (m :: * -> *). MonadState s m => m s
get put :: s -> ReaderT r m ()
put =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *). MonadState s m => s -> m ()
put state :: forall a. (s -> (a, s)) -> ReaderT r m a
state =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state -- | @since 2.3instance(Monoidw ,MonadState s m )=>MonadState s (CPS.WriterTw m )whereget :: WriterT w m s
get =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall s (m :: * -> *). MonadState s m => m s
get put :: s -> WriterT w m ()
put =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *). MonadState s m => s -> m ()
put state :: forall a. (s -> (a, s)) -> WriterT w m a
state =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state instance(Monoidw ,MonadState s m )=>MonadState s (Lazy.WriterTw m )whereget :: WriterT w m s
get =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall s (m :: * -> *). MonadState s m => m s
get put :: s -> WriterT w m ()
put =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *). MonadState s m => s -> m ()
put state :: forall a. (s -> (a, s)) -> WriterT w m a
state =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state instance(Monoidw ,MonadState s m )=>MonadState s (Strict.WriterTw m )whereget :: WriterT w m s
get =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall s (m :: * -> *). MonadState s m => m s
get put :: s -> WriterT w m ()
put =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *). MonadState s m => s -> m ()
put state :: forall a. (s -> (a, s)) -> WriterT w m a
state =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state -- | @since 2.3instance(Monoidw ,MonadState s m )=>MonadState s (AccumTw m )whereget :: AccumT w m s
get =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall s (m :: * -> *). MonadState s m => m s
get put :: s -> AccumT w m ()
put =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *). MonadState s m => s -> m ()
put state :: forall a. (s -> (a, s)) -> AccumT w m a
state =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state -- | @since 2.3instanceMonadState s m =>MonadState s (SelectTr m )whereget :: SelectT r m s
get =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall s (m :: * -> *). MonadState s m => m s
get put :: s -> SelectT r m ()
put =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *). MonadState s m => s -> m ()
put state :: forall a. (s -> (a, s)) -> SelectT r m a
state =forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
liftforall b c a. (b -> c) -> (a -> b) -> a -> c
.forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state