State

State

type State s = StateT s Identity

A state monad parameterized by the type s of the state to carry.

The return function leaves the state unchanged, while >>= uses the final state of the first computation as the initial state of the second.

runState

Arguments

:: State s a

state-passing computation to execute

-> s

initial state

-> (a, s)

return value and final state

Unwrap a state monad computation as a function. (The inverse of state.)

evalState

Arguments

:: State s a

state-passing computation to execute

-> s

initial value

-> a

return value of the state computation

Evaluate a state computation with the given initial state and return the final value, discarding the final state.

• evalState m s = fst (runState m s)

execState

Arguments

:: State s a

state-passing computation to execute

-> s

initial value

-> s

final state

Evaluate a state computation with the given initial state and return the final state, discarding the final value.

• execState m s = snd (runState m s)

mapState :: ((a, s) -> (b, s)) -> State s a -> State s b

Map both the return value and final state of a computation using the given function.

• runState (mapState f m) = f . runState m

withState :: (s -> s) -> State s a -> State s a

withState f m executes action m on a state modified by applying f.

• withState f m = modify f >> m

StateT

newtype StateT s (m :: * -> *) a

A state transformer monad parameterized by:

• s - The state.
• m - The inner monad.

The return function leaves the state unchanged, while >>= uses the final state of the first computation as the initial state of the second.

Constructors

StateT

Fields

• runStateT :: s -> m (a, s)

Instances

MonadParsec e s m => MonadParsec e s (StateT st m)

Defined in Text.Megaparsec.Class

Methods

failure :: Maybe (ErrorItem (Token s)) -> Set (ErrorItem (Token s)) -> StateT st m a

fancyFailure :: Set (ErrorFancy e) -> StateT st m a

label :: String -> StateT st m a -> StateT st m a

hidden :: StateT st m a -> StateT st m a

try :: StateT st m a -> StateT st m a

lookAhead :: StateT st m a -> StateT st m a

notFollowedBy :: StateT st m a -> StateT st m ()

withRecovery :: (ParseError (Token s) e -> StateT st m a) -> StateT st m a -> StateT st m a

observing :: StateT st m a -> StateT st m (Either (ParseError (Token s) e) a)

eof :: StateT st m ()

token :: (Token s -> Either (Maybe (ErrorItem (Token s)), Set (ErrorItem (Token s))) a) -> Maybe (Token s) -> StateT st m a

tokens :: (Tokens s -> Tokens s -> Bool) -> Tokens s -> StateT st m (Tokens s)

takeWhileP :: Maybe String -> (Token s -> Bool) -> StateT st m (Tokens s)

takeWhile1P :: Maybe String -> (Token s -> Bool) -> StateT st m (Tokens s)

takeP :: Maybe String -> Int -> StateT st m (Tokens s)

getParserState :: StateT st m (State s)

updateParserState :: (State s -> State s) -> StateT st m ()

MonadReader r m => MonadReader r (StateT s m)

Defined in Control.Monad.Reader.Class

Methods

ask :: StateT s m r

local :: (r -> r) -> StateT s m a -> StateT s m a

reader :: (r -> a) -> StateT s m a

Monad m => MonadState s (StateT s m)

Defined in Control.Monad.State.Class

Methods

get :: StateT s m s

put :: s -> StateT s m ()

state :: (s -> (a, s)) -> StateT s m a

(Functor f, MonadFree f m) => MonadFree f (StateT s m)

Defined in Control.Monad.Free.Class

Methods

wrap :: f (StateT s m a) -> StateT s m a

MonadError e m => MonadError e (StateT s m)

Defined in Control.Monad.Error.Class

Methods

throwError :: e -> StateT s m a

catchError :: StateT s m a -> (e -> StateT s m a) -> StateT s m a

MonadWriter w m => MonadWriter w (StateT s m)

Defined in Control.Monad.Writer.Class

Methods

writer :: (a, w) -> StateT s m a

tell :: w -> StateT s m ()

listen :: StateT s m a -> StateT s m (a, w)

pass :: StateT s m (a, w -> w) -> StateT s m a

MonadBase b m => MonadBase b (StateT s m)

Defined in Control.Monad.Base

Methods

liftBase :: b α -> StateT s m α

MonadTrans (StateT s)

Defined in Control.Monad.Trans.State.Strict

Methods

lift :: Monad m => m a -> StateT s m a

MFunctor (StateT s :: (* -> *) -> * -> *)

Defined in Control.Monad.Morph

Methods

hoist :: Monad m => (forall a. m a -> n a) -> StateT s m b -> StateT s n b

Monad m => Monad (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

(>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b

(>>) :: StateT s m a -> StateT s m b -> StateT s m b

return :: a -> StateT s m a

fail :: String -> StateT s m a

Functor m => Functor (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

fmap :: (a -> b) -> StateT s m a -> StateT s m b

(<$) :: a -> StateT s m b -> StateT s m a

MonadFix m => MonadFix (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

mfix :: (a -> StateT s m a) -> StateT s m a

MonadFail m => MonadFail (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

fail :: String -> StateT s m a

(Functor m, Monad m) => Applicative (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

pure :: a -> StateT s m a

(<*>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b

liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c

(*>) :: StateT s m a -> StateT s m b -> StateT s m b

(<*) :: StateT s m a -> StateT s m b -> StateT s m a

(Functor m, MonadPlus m) => Alternative (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

empty :: StateT s m a

(<|>) :: StateT s m a -> StateT s m a -> StateT s m a

some :: StateT s m a -> StateT s m [a]

many :: StateT s m a -> StateT s m [a]

Contravariant m => Contravariant (StateT s m)

Defined in Data.Functor.Contravariant

Methods

contramap :: (a -> b) -> StateT s m b -> StateT s m a

(>$) :: b -> StateT s m b -> StateT s m a

MonadPlus m => MonadPlus (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

mzero :: StateT s m a

mplus :: StateT s m a -> StateT s m a -> StateT s m a

MonadIO m => MonadIO (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

liftIO :: IO a -> StateT s m a

Divisible m => Divisible (StateT s m)

Defined in Data.Functor.Contravariant.Divisible

Methods

divide :: (a -> (b, c)) -> StateT s m b -> StateT s m c -> StateT s m a

conquer :: StateT s m a

Decidable m => Decidable (StateT s m)

Defined in Data.Functor.Contravariant.Divisible

Methods

lose :: (a -> Void) -> StateT s m a

choose :: (a -> Either b c) -> StateT s m b -> StateT s m c -> StateT s m a

MonadThrow m => MonadThrow (StateT s m)

Defined in Control.Monad.Catch

Methods

throwM :: Exception e => e -> StateT s m a

MonadCatch m => MonadCatch (StateT s m)

Defined in Control.Monad.Catch

Methods

catch :: Exception e => StateT s m a -> (e -> StateT s m a) -> StateT s m a

MonadMask m => MonadMask (StateT s m)

Defined in Control.Monad.Catch

Methods

mask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b

uninterruptibleMask :: ((forall a. StateT s m a -> StateT s m a) -> StateT s m b) -> StateT s m b

generalBracket :: StateT s m a -> (a -> ExitCase b -> StateT s m c) -> (a -> StateT s m b) -> StateT s m (b, c)

PrimMonad m => PrimMonad (StateT s m)

Defined in Control.Monad.Primitive

Associated Types

type PrimState (StateT s m) :: *

Methods

primitive :: (State# (PrimState (StateT s m)) -> (#State# (PrimState (StateT s m)), a#)) -> StateT s m a

Bind m => Apply (StateT s m)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b

(.>) :: StateT s m a -> StateT s m b -> StateT s m b

(<.) :: StateT s m a -> StateT s m b -> StateT s m a

liftF2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c

MonadLogic m => MonadLogic (StateT s m)

Defined in Control.Monad.Logic.Class

Methods

msplit :: StateT s m a -> StateT s m (Maybe (a, StateT s m a))

interleave :: StateT s m a -> StateT s m a -> StateT s m a

(>>-) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b

ifte :: StateT s m a -> (a -> StateT s m b) -> StateT s m b -> StateT s m b

once :: StateT s m a -> StateT s m a

MonadManaged m => MonadManaged (StateT s m)

Defined in Control.Monad.Managed

Methods

using :: Managed a -> StateT s m a

MonadCont m => MonadCont (StateT s m)

Defined in Control.Monad.Cont.Class

Methods

callCC :: ((a -> StateT s m b) -> StateT s m a) -> StateT s m a

Pointed m => Pointed (StateT s m)

Defined in Data.Pointed

Methods

point :: a -> StateT s m a

Plus f => Plus (StateT e f)

Defined in Data.Functor.Plus

Methods

zero :: StateT e f a

Alt f => Alt (StateT e f)

Defined in Data.Functor.Alt

Methods

(<!>) :: StateT e f a -> StateT e f a -> StateT e f a

some :: Applicative (StateT e f) => StateT e f a -> StateT e f [a]

many :: Applicative (StateT e f) => StateT e f a -> StateT e f [a]

Bind m => Bind (StateT s m)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b

join :: StateT s m (StateT s m a) -> StateT s m a

Monad z => Zoom (StateT s z) (StateT t z) s t

Defined in Control.Lens.Zoom

Methods

zoom :: LensLike' (Zoomed (StateT s z) c) t s -> StateT s z c -> StateT t z c

Wrapped (StateT s m a)

Defined in Control.Lens.Wrapped

Associated Types

type Unwrapped (StateT s m a) :: *

Methods

_Wrapped' :: Iso' (StateT s m a) (Unwrapped (StateT s m a))

t ~ StateT s' m' a' => Rewrapped (StateT s m a) t

Defined in Control.Lens.Wrapped

Strict (StateT s m a) (StateT s m a)

Defined in Control.Lens.Iso

Methods

strict :: Iso' (StateT0 s m a) (StateT s m a)

type Zoomed (StateT s z)

Defined in Control.Lens.Zoom

type Zoomed (StateT s z) = Focusing z

type PrimState (StateT s m)

Defined in Control.Monad.Primitive

type PrimState (StateT s m) = PrimState m

type Unwrapped (StateT s m a)

Defined in Control.Lens.Wrapped

type Unwrapped (StateT s m a) = s -> m (a, s)

evalStateT :: Monad m => StateT s m a -> s -> m a

Evaluate a state computation with the given initial state and return the final value, discarding the final state.

• evalStateT m s = liftM fst (runStateT m s)

execStateT :: Monad m => StateT s m a -> s -> m s

Evaluate a state computation with the given initial state and return the final state, discarding the final value.

• execStateT m s = liftM snd (runStateT m s)

mapStateT :: (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b

Map both the return value and final state of a computation using the given function.

• runStateT (mapStateT f m) = f . runStateT m

withStateT :: (s -> s) -> StateT s m a -> StateT s m a

withStateT f m executes action m on a state modified by applying f.

• withStateT f m = modify f >> m

MonadState

class Monad m => MonadState s (m :: * -> *) | m -> s where

Minimal definition is either both of get and put or just state

Minimal complete definition

state | get, put

Methods

get :: m s

Return the state from the internals of the monad.

put :: s -> m ()

Replace the state inside the monad.

state :: (s -> (a, s)) -> m a

Embed a simple state action into the monad.

Instances

MonadState s m => MonadState s (MaybeT m)

Defined in Control.Monad.State.Class

Methods

get :: MaybeT m s

put :: s -> MaybeT m ()

state :: (s -> (a, s)) -> MaybeT m a

MonadState s m => MonadState s (ListT m)

Defined in Control.Monad.State.Class

Methods

get :: ListT m s

put :: s -> ListT m ()

state :: (s -> (a, s)) -> ListT m a

MonadState s m => MonadState s (LogicT m)

Defined in Control.Monad.Logic

Methods

get :: LogicT m s

put :: s -> LogicT m ()

state :: (s -> (a, s)) -> LogicT m a

MonadState s m => MonadState s (ListT m)

Defined in List.Transformer

Methods

get :: ListT m s

put :: s -> ListT m ()

state :: (s -> (a, s)) -> ListT m a

(Functor m, MonadState s m) => MonadState s (Free m)

Defined in Control.Monad.Free

Methods

get :: Free m s

put :: s -> Free m ()

state :: (s -> (a, s)) -> Free m a

(Monoid w, MonadState s m) => MonadState s (WriterT w m)

Defined in Control.Monad.State.Class

Methods

get :: WriterT w m s

put :: s -> WriterT w m ()

state :: (s -> (a, s)) -> WriterT w m a

(Monoid w, MonadState s m) => MonadState s (WriterT w m)

Defined in Control.Monad.State.Class

Methods

get :: WriterT w m s

put :: s -> WriterT w m ()

state :: (s -> (a, s)) -> WriterT w m a

Monad m => MonadState s (StateT s m)

Defined in Control.Monad.State.Class

Methods

get :: StateT s m s

put :: s -> StateT s m ()

state :: (s -> (a, s)) -> StateT s m a

Monad m => MonadState s (StateT s m)

Defined in Control.Monad.State.Class

Methods

get :: StateT s m s

put :: s -> StateT s m ()

state :: (s -> (a, s)) -> StateT s m a

MonadState s m => MonadState s (IdentityT m)

Defined in Control.Monad.State.Class

Methods

get :: IdentityT m s

put :: s -> IdentityT m ()

state :: (s -> (a, s)) -> IdentityT m a

MonadState s m => MonadState s (ExceptT e m)

Since: mtl-2.2

Defined in Control.Monad.State.Class

Methods

get :: ExceptT e m s

put :: s -> ExceptT e m ()

state :: (s -> (a, s)) -> ExceptT e m a

(Error e, MonadState s m) => MonadState s (ErrorT e m)

Defined in Control.Monad.State.Class

Methods

get :: ErrorT e m s

put :: s -> ErrorT e m ()

state :: (s -> (a, s)) -> ErrorT e m a

(Functor f, MonadState s m) => MonadState s (FreeT f m)

Defined in Control.Monad.Trans.Free

Methods

get :: FreeT f m s

put :: s -> FreeT f m ()

state :: (s -> (a, s)) -> FreeT f m a

(Stream s, MonadState st m) => MonadState st (ParsecT e s m)

Defined in Text.Megaparsec.Internal

Methods

get :: ParsecT e s m st

put :: st -> ParsecT e s m ()

state :: (st -> (a, st)) -> ParsecT e s m a

MonadState s m => MonadState s (ReaderT r m)

Defined in Control.Monad.State.Class

Methods

get :: ReaderT r m s

put :: s -> ReaderT r m ()

state :: (s -> (a, s)) -> ReaderT r m a

MonadState s m => MonadState s (ContT r m)

Defined in Control.Monad.State.Class

Methods

get :: ContT r m s

put :: s -> ContT r m ()

state :: (s -> (a, s)) -> ContT r m a

(Monad m, Monoid w) => MonadState s (RWST r w s m)

Defined in Control.Monad.State.Class

Methods

get :: RWST r w s m s

put :: s -> RWST r w s m ()

state :: (s -> (a, s)) -> RWST r w s m a

(Monad m, Monoid w) => MonadState s (RWST r w s m)

Defined in Control.Monad.State.Class

Methods

get :: RWST r w s m s

put :: s -> RWST r w s m ()

state :: (s -> (a, s)) -> RWST r w s m a

gets :: MonadState s m => (s -> a) -> m a

Gets specific component of the state, using a projection function supplied.

modify :: MonadState s m => (s -> s) -> m ()

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

A variant of modify in which the computation is strict in the new state.

Since: mtl-2.2

Zoom

class (MonadState s m, MonadState t n) => Zoom (m :: * -> *) (n :: * -> *) s t | m -> s, n -> t, m t -> n, n s -> m

This class allows us to use zoom in, changing the State supplied by many different Monad transformers, potentially quite deep in a Monad transformer stack.

Minimal complete definition

zoom

Instances

Zoom m n s t => Zoom (MaybeT m) (MaybeT n) s t

Defined in Control.Lens.Zoom

Methods

zoom :: LensLike' (Zoomed (MaybeT m) c) t s -> MaybeT m c -> MaybeT n c

Zoom m n s t => Zoom (ListT m) (ListT n) s t

Defined in Control.Lens.Zoom

Methods

zoom :: LensLike' (Zoomed (ListT m) c) t s -> ListT m c -> ListT n c

Zoom m n s t => Zoom (IdentityT m) (IdentityT n) s t

Defined in Control.Lens.Zoom

Methods

zoom :: LensLike' (Zoomed (IdentityT m) c) t s -> IdentityT m c -> IdentityT n c

Zoom m n s t => Zoom (ExceptT e m) (ExceptT e n) s t

Defined in Control.Lens.Zoom

Methods

zoom :: LensLike' (Zoomed (ExceptT e m) c) t s -> ExceptT e m c -> ExceptT e n c

(Functor f, Zoom m n s t) => Zoom (FreeT f m) (FreeT f n) s t

Defined in Control.Lens.Zoom

Methods

zoom :: LensLike' (Zoomed (FreeT f m) c) t s -> FreeT f m c -> FreeT f n c

(Error e, Zoom m n s t) => Zoom (ErrorT e m) (ErrorT e n) s t

Defined in Control.Lens.Zoom

Methods

zoom :: LensLike' (Zoomed (ErrorT e m) c) t s -> ErrorT e m c -> ErrorT e n c

(Monoid w, Zoom m n s t) => Zoom (WriterT w m) (WriterT w n) s t

Defined in Control.Lens.Zoom

Methods

zoom :: LensLike' (Zoomed (WriterT w m) c) t s -> WriterT w m c -> WriterT w n c

Monad z => Zoom (StateT s z) (StateT t z) s t

Defined in Control.Lens.Zoom

Methods

zoom :: LensLike' (Zoomed (StateT s z) c) t s -> StateT s z c -> StateT t z c

Monad z => Zoom (StateT s z) (StateT t z) s t

Defined in Control.Lens.Zoom

Methods

zoom :: LensLike' (Zoomed (StateT s z) c) t s -> StateT s z c -> StateT t z c

(Monoid w, Zoom m n s t) => Zoom (WriterT w m) (WriterT w n) s t

Defined in Control.Lens.Zoom

Methods

zoom :: LensLike' (Zoomed (WriterT w m) c) t s -> WriterT w m c -> WriterT w n c

Zoom m n s t => Zoom (ReaderT e m) (ReaderT e n) s t

Defined in Control.Lens.Zoom

Methods

zoom :: LensLike' (Zoomed (ReaderT e m) c) t s -> ReaderT e m c -> ReaderT e n c

(Monoid w, Monad z) => Zoom (RWST r w s z) (RWST r w t z) s t

Defined in Control.Lens.Zoom

Methods

zoom :: LensLike' (Zoomed (RWST r w s z) c) t s -> RWST r w s z c -> RWST r w t z c

(Monoid w, Monad z) => Zoom (RWST r w s z) (RWST r w t z) s t

Defined in Control.Lens.Zoom

Methods

zoom :: LensLike' (Zoomed (RWST r w s z) c) t s -> RWST r w s z c -> RWST r w t z c

zoom :: Zoom m n s t => LensLike' (Zoomed m c) t s -> m c -> n c infixr 2

Run a monadic action in a larger State than it was defined in, using a Lens' or Traversal'.

This is commonly used to lift actions in a simpler State Monad into a State Monad with a larger State type.

When applied to a Traversal' over multiple values, the actions for each target are executed sequentially and the results are aggregated.

This can be used to edit pretty much any Monad transformer stack with a State in it!

>>> flip State.evalState (a,b) $ zoom _1 $ use id
a

>>> flip State.execState (a,b) $ zoom _1 $ id .= c
(c,b)

>>> flip State.execState [(a,b),(c,d)] $ zoom traverse $ _2 %= f
[(a,f b),(c,f d)]

>>> flip State.runState [(a,b),(c,d)] $ zoom traverse $ _2 <%= f
(f b <> f d <> mempty,[(a,f b),(c,f d)])

>>> flip State.evalState (a,b) $ zoom both (use id)
a <> b

zoom :: Monad m             => Lens' s t      -> StateT t m a -> StateT s m a
zoom :: (Monad m, Monoid c) => Traversal' s t -> StateT t m c -> StateT s m c
zoom :: (Monad m, Monoid w)             => Lens' s t      -> RWST r w t m c -> RWST r w s m c
zoom :: (Monad m, Monoid w, Monoid c) => Traversal' s t -> RWST r w t m c -> RWST r w s m c
zoom :: (Monad m, Monoid w, Error e)  => Lens' s t      -> ErrorT e (RWST r w t m) c -> ErrorT e (RWST r w s m) c
zoom :: (Monad m, Monoid w, Monoid c, Error e) => Traversal' s t -> ErrorT e (RWST r w t m) c -> ErrorT e (RWST r w s m) c
...

type family Zoomed (m :: * -> *) :: * -> * -> *

This type family is used by Zoom to describe the common effect type.

Instances

type Zoomed (MaybeT m)

Defined in Control.Lens.Zoom

type Zoomed (MaybeT m) = FocusingMay (Zoomed m)

type Zoomed (ListT m)

Defined in Control.Lens.Zoom

type Zoomed (ListT m) = FocusingOn [] (Zoomed m)

type Zoomed (IdentityT m)

Defined in Control.Lens.Zoom

type Zoomed (IdentityT m) = Zoomed m

type Zoomed (ExceptT e m)

Defined in Control.Lens.Zoom

type Zoomed (ExceptT e m) = FocusingErr e (Zoomed m)

type Zoomed (FreeT f m)

Defined in Control.Lens.Zoom

type Zoomed (FreeT f m) = FocusingFree f m (Zoomed m)

type Zoomed (ErrorT e m)

Defined in Control.Lens.Zoom

type Zoomed (ErrorT e m) = FocusingErr e (Zoomed m)

type Zoomed (WriterT w m)

Defined in Control.Lens.Zoom

type Zoomed (WriterT w m) = FocusingPlus w (Zoomed m)

type Zoomed (StateT s z)

Defined in Control.Lens.Zoom

type Zoomed (StateT s z) = Focusing z

type Zoomed (StateT s z)

Defined in Control.Lens.Zoom

type Zoomed (StateT s z) = Focusing z

type Zoomed (WriterT w m)

Defined in Control.Lens.Zoom

type Zoomed (WriterT w m) = FocusingPlus w (Zoomed m)

type Zoomed (ReaderT e m)

Defined in Control.Lens.Zoom

type Zoomed (ReaderT e m) = Zoomed m

type Zoomed (RWST r w s z)

Defined in Control.Lens.Zoom

type Zoomed (RWST r w s z) = FocusingWith w z

type Zoomed (RWST r w s z)

Defined in Control.Lens.Zoom

type Zoomed (RWST r w s z) = FocusingWith w z