Data.Monoid.Endo.FromEndo

Convert endomorphism in to a value.

Convert Endo to a Value

class FromEndo a where

Type class provides functionality for converting Endo b and Dual (Endo b) in to some type a. Type b, on which endomorphism operates, is implied by type a, but generally aren't the same type. In other words it is dual type class to AnEndo.

Minimal complete definition

fromEndo

Associated Types

type EndoOperatedOn a

Methods

fromEndo :: Endo (EndoOperatedOn a) -> a

Convert endomorphism in to a value of type a.

fromDualEndo :: Dual (Endo (EndoOperatedOn a)) -> a

Provided default implementation:

fromDualEndo = fromEndo . getDual

Instances

FromEndo e => FromEndo (Dual e)

Associated Types

type EndoOperatedOn (Dual e) :: *

Methods

fromEndo :: Endo (EndoOperatedOn (Dual e)) -> Dual e

fromDualEndo :: Dual (Endo (EndoOperatedOn (Dual e))) -> Dual e

FromEndo (Endo a)

Associated Types

type EndoOperatedOn (Endo a) :: *

Methods

fromEndo :: Endo (EndoOperatedOn (Endo a)) -> Endo a

fromDualEndo :: Dual (Endo (EndoOperatedOn (Endo a))) -> Endo a

FromEndo (a -> a)

Associated Types

type EndoOperatedOn (a -> a) :: *

Methods

fromEndo :: Endo (EndoOperatedOn (a -> a)) -> a -> a

fromDualEndo :: Dual (Endo (EndoOperatedOn (a -> a))) -> a -> a

Monad f => FromEndo (StateT s f ())

Modify state.

fromEndo (Endo f) = modify f

Associated Types

type EndoOperatedOn (StateT s f ()) :: *

Methods

fromEndo :: Endo (EndoOperatedOn (StateT s f ())) -> StateT s f ()

fromDualEndo :: Dual (Endo (EndoOperatedOn (StateT s f ()))) -> StateT s f ()

Monad f => FromEndo (StateT s f ())

Modify state.

fromEndo (Endo f) = modify f

Associated Types

type EndoOperatedOn (StateT s f ()) :: *

Methods

fromEndo :: Endo (EndoOperatedOn (StateT s f ())) -> StateT s f ()

fromDualEndo :: Dual (Endo (EndoOperatedOn (StateT s f ()))) -> StateT s f ()

MonadState s m => FromEndo (ApplyEndo Modify' m s)

Evaluates ApplyEndo in terms of state operation:

fromEndo (Endo f) = ApplyEndo . state $ \s ->
    let s' = f s in s' `seq` (s', s')

Associated Types

type EndoOperatedOn (ApplyEndo Modify' m s) :: *

Methods

fromEndo :: Endo (EndoOperatedOn (ApplyEndo Modify' m s)) -> ApplyEndo Modify' m s

fromDualEndo :: Dual (Endo (EndoOperatedOn (ApplyEndo Modify' m s))) -> ApplyEndo Modify' m s

MonadState s m => FromEndo (ApplyEndo Modify m s)

Evaluates ApplyEndo in terms of state operation:

fromEndo e = ApplyEndo . state $ \s ->
    let s' = appEndo e s in (s', s')

Associated Types

type EndoOperatedOn (ApplyEndo Modify m s) :: *

Methods

fromEndo :: Endo (EndoOperatedOn (ApplyEndo Modify m s)) -> ApplyEndo Modify m s

fromDualEndo :: Dual (Endo (EndoOperatedOn (ApplyEndo Modify m s))) -> ApplyEndo Modify m s

MonadReader r m => FromEndo (ApplyEndo Reader m r)

Evaluates ApplyEndo in terms of asks operation:

fromEndo = ApplyEndo . asks . appEndo

Associated Types

type EndoOperatedOn (ApplyEndo Reader m r) :: *

Methods

fromEndo :: Endo (EndoOperatedOn (ApplyEndo Reader m r)) -> ApplyEndo Reader m r

fromDualEndo :: Dual (Endo (EndoOperatedOn (ApplyEndo Reader m r))) -> ApplyEndo Reader m r

(Applicative f, Default a) => FromEndo (ApplyEndo Def f a)

Associated Types

type EndoOperatedOn (ApplyEndo Def f a) :: *

Methods

fromEndo :: Endo (EndoOperatedOn (ApplyEndo Def f a)) -> ApplyEndo Def f a

fromDualEndo :: Dual (Endo (EndoOperatedOn (ApplyEndo Def f a))) -> ApplyEndo Def f a

(Applicative f, Monoid a) => FromEndo (ApplyEndo Mempty f a)

Associated Types

type EndoOperatedOn (ApplyEndo Mempty f a) :: *

Methods

fromEndo :: Endo (EndoOperatedOn (ApplyEndo Mempty f a)) -> ApplyEndo Mempty f a

fromDualEndo :: Dual (Endo (EndoOperatedOn (ApplyEndo Mempty f a))) -> ApplyEndo Mempty f a

Monad f => FromEndo (ReaderT * r f r)

Retrieve environment modified by endomorphism.

fromEndo (Endo f) = asks f

Associated Types

type EndoOperatedOn (ReaderT * r f r) :: *

Methods

fromEndo :: Endo (EndoOperatedOn (ReaderT * r f r)) -> ReaderT * r f r

fromDualEndo :: Dual (Endo (EndoOperatedOn (ReaderT * r f r))) -> ReaderT * r f r

(Monoid w, Monad f) => FromEndo (RWST r w s f ())

Modify state.

fromEndo (Endo f) = modify f

Associated Types

type EndoOperatedOn (RWST r w s f ()) :: *

Methods

fromEndo :: Endo (EndoOperatedOn (RWST r w s f ())) -> RWST r w s f ()

fromDualEndo :: Dual (Endo (EndoOperatedOn (RWST r w s f ()))) -> RWST r w s f ()

(Monoid w, Monad f) => FromEndo (RWST r w s f ())

Modify state.

fromEndo (Endo f) = modify f

Associated Types

type EndoOperatedOn (RWST r w s f ()) :: *

Methods

fromEndo :: Endo (EndoOperatedOn (RWST r w s f ())) -> RWST r w s f ()

fromDualEndo :: Dual (Endo (EndoOperatedOn (RWST r w s f ()))) -> RWST r w s f ()

fromEndoWith :: (FromEndo a, EndoOperatedOn a ~ c) => (a -> b) -> Endo c -> b

In a lot of cases it is necessary to evaluate result of fromEndo. Example:

>>> fromEndoWith ((`runState` def) :: State Int () -> ((), Int)) (Endo (+10))
((), 10)

Following property holds:

fromEndoWith id = fromEndo

See also fromDualEndoWith.

fromEndoWithF :: (Functor f, FromEndo a, EndoOperatedOn a ~ c) => (f a -> b) -> f (Endo c) -> b

Same as fromEndoWith, but deals with Endo wrapped inside a Functor.

fromDualEndoWith :: (FromEndo a, EndoOperatedOn a ~ c) => (a -> b) -> Dual (Endo c) -> b

In a lot of cases it is necessary to evaluate result of fromDualEndo. Example:

>>> fromEndoWith ((`runState` def) :: State Int () -> ((), Int)) (Dual (Endo (+10)))
((), 10)

Following property holds:

fromDualEndoWith id = fromDualEndo

See also fromEndoWith.

fromDualEndoWithF :: (Functor f, FromEndo a, EndoOperatedOn a ~ c) => (f a -> b) -> f (Dual (Endo c)) -> b

Same as fromDualEndoWith, but deals with Dual Endo wrapped inside a Functor.

fromEndoTo :: FromEndo a => Endo (EndoOperatedOn a) -> proxy a -> a

Variant of fromEndo that takes type restriction on the result type a as an argument.

fromDualEndoTo :: FromEndo a => Dual (Endo (EndoOperatedOn a)) -> proxy a -> a

Variant of fromDualEndo that takes type restriction on the result type a as an argument.