planet-mitchell-0.0.0: Planet Mitchell

Safe HaskellSafe
LanguageHaskell2010

State

Contents

Synopsis

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.

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.

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.

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

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

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

Instances
MonadParsec e s m => MonadParsec e s (StateT st m) 
Instance details

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

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

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

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

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

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

Defined in Control.Monad.Base

Methods

liftBase :: b α -> StateT s m α #

MonadTrans (StateT s) 
Instance details

Defined in Control.Monad.Trans.State.Strict

Methods

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

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

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

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

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

Defined in Control.Monad.Trans.State.Strict

Methods

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

MonadFail m => MonadFail (StateT s m) 
Instance details

Defined in Control.Monad.Trans.State.Strict

Methods

fail :: String -> StateT s m a #

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

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

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

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

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

Defined in Control.Monad.Trans.State.Strict

Methods

liftIO :: IO a -> StateT s m a #

MonadMask m => MonadMask (StateT s m) 
Instance details

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

MonadCatch m => MonadCatch (StateT s m) 
Instance details

Defined in Control.Monad.Catch

Methods

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

MonadThrow m => MonadThrow (StateT s m) 
Instance details

Defined in Control.Monad.Catch

Methods

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

Divisible m => Divisible (StateT s m) 
Instance details

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

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 #

PrimMonad m => PrimMonad (StateT s m) 
Instance details

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 #

MonadTest m => MonadTest (StateT s m) 
Instance details

Defined in Hedgehog.Internal.Property

Methods

liftTest :: Test a -> StateT s m a #

MonadGen m => MonadGen (StateT s m) 
Instance details

Defined in Hedgehog.Internal.Gen

Methods

liftGen :: Gen a -> StateT s m a #

shrinkGen :: (a -> [a]) -> StateT s m a -> StateT s m a #

pruneGen :: StateT s m a -> StateT s m a #

scaleGen :: (Size -> Size) -> StateT s m a -> StateT s m a #

freezeGen :: StateT s m a -> StateT s m (a, StateT s m a) #

Bind m => Apply (StateT s m) 
Instance details

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

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

Defined in Control.Monad.Managed

Methods

using :: Managed a -> StateT s m a #

MonadCont m => MonadCont (StateT s m) 
Instance details

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

Defined in Data.Pointed

Methods

point :: a -> StateT s m a #

Plus f => Plus (StateT e f) 
Instance details

Defined in Data.Functor.Plus

Methods

zero :: StateT e f a #

Alt f => Alt (StateT e f) 
Instance details

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

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 
Instance details

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

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 
Instance details

Defined in Control.Lens.Wrapped

Strict (StateT s m a) (StateT s m a) 
Instance details

Defined in Control.Lens.Iso

Methods

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

type Zoomed (StateT s z) 
Instance details

Defined in Control.Lens.Zoom

type Zoomed (StateT s z) = Focusing z
type PrimState (StateT s m) 
Instance details

Defined in Control.Monad.Primitive

type PrimState (StateT s m) = PrimState m
type Unwrapped (StateT s m a) 
Instance details

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.

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.

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.

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

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

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 (TestT m) 
Instance details

Defined in Hedgehog.Internal.Property

Methods

get :: TestT m s #

put :: s -> TestT m () #

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

MonadState s m => MonadState s (PropertyT m) 
Instance details

Defined in Hedgehog.Internal.Property

Methods

get :: PropertyT m s #

put :: s -> PropertyT m () #

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

MonadState s m => MonadState s (GenT m) 
Instance details

Defined in Hedgehog.Internal.Gen

Methods

get :: GenT m s #

put :: s -> GenT m () #

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

MonadState s m => MonadState s (MaybeT m) 
Instance details

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

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

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

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

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

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

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

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

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

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

Instance details

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

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

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

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

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

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

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

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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 
Instance details

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

Defined in Control.Lens.Zoom

type Zoomed (ListT m) 
Instance details

Defined in Control.Lens.Zoom

type Zoomed (ListT m) = FocusingOn [] (Zoomed m)
type Zoomed (IdentityT m) 
Instance details

Defined in Control.Lens.Zoom

type Zoomed (IdentityT m) = Zoomed m
type Zoomed (ExceptT e m) 
Instance details

Defined in Control.Lens.Zoom

type Zoomed (ExceptT e m) = FocusingErr e (Zoomed m)
type Zoomed (FreeT f m) 
Instance details

Defined in Control.Lens.Zoom

type Zoomed (FreeT f m) = FocusingFree f m (Zoomed m)
type Zoomed (ErrorT e m) 
Instance details

Defined in Control.Lens.Zoom

type Zoomed (ErrorT e m) = FocusingErr e (Zoomed m)
type Zoomed (WriterT w m) 
Instance details

Defined in Control.Lens.Zoom

type Zoomed (WriterT w m) = FocusingPlus w (Zoomed m)
type Zoomed (StateT s z) 
Instance details

Defined in Control.Lens.Zoom

type Zoomed (StateT s z) = Focusing z
type Zoomed (StateT s z) 
Instance details

Defined in Control.Lens.Zoom

type Zoomed (StateT s z) = Focusing z
type Zoomed (WriterT w m) 
Instance details

Defined in Control.Lens.Zoom

type Zoomed (WriterT w m) = FocusingPlus w (Zoomed m)
type Zoomed (ReaderT e m) 
Instance details

Defined in Control.Lens.Zoom

type Zoomed (ReaderT e m) = Zoomed m
type Zoomed (RWST r w s z) 
Instance details

Defined in Control.Lens.Zoom

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

Defined in Control.Lens.Zoom

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