Data.Monoid.Endo.AnEndo

Conversion of values in to endomorphisms.

Conversion Into Endo

Various types can be interpreted as an encoding of an endomorphism. In example, enum can be viewed as family of endomorphisms where each sets a specific field of a record to a specific enum value, i.e. data constructor. Type class AnEndo provides generic way to convert values in to an endomorphism using anEndo and aDualEndo functions.

class AnEndo a where

Class that represents various endomorphism representation. In other words anything that encodes (a -> a) can be instance of this class.

Here are some important instances with not so obvious definitions.

instance AnEndo (Proxy a) where
    type EndoOperatesOn (Proxy a) = a

    anEndo    _ = mempty -- = Endo id
    aDualEndo _ = mempty

It got quite common to use Proxy data type as an explicit way to pass types around. Above instance allows you to restrict type of result of endomorphism folding, to some extent.

instance AnEndo a => AnEndo (Maybe a) where
    type EndoOperatesOn (Maybe a) = EndoOperatesOn a

    anEndo Nothing  = mempty -- = Endo id
    anEndo (Just e) = anEndo e

    -- Definition of aDualEndo is analogous.

Instance for Maybe lets us conditionally inject endomorphism in to a folding chain.

instance AnEndo a => AnEndo (Identity a) where
    type EndoOperatesOn (Identity a) = EndoOperatesOn a

    anEndo (Identity e) = anEndo e
    aDualEndo (Identity e) = aDualEndo e

Above instance allows us to discard Identity wrapper, which is commonly used in data types that are parametrized by functor or monad.

Minimal complete definition

anEndo | aDualEndo

Associated Types

type EndoOperatesOn a

Extract type on which endomorphism operates, e.g. for (Endo a) it would be a.

Methods

anEndo :: a -> Endo (EndoOperatesOn a)

Convert value encoding (a -> a) in to Endo. Default implementation:

anEndo = getDual . aDualEndo

aDualEndo :: a -> Dual (Endo (EndoOperatesOn a))

Dual to anEndo. Default implementation:

aDualEndo = Dual . anEndo

Instances

AnEndo a => AnEndo [a]

Associated Types

type EndoOperatesOn [a] :: *

Methods

anEndo :: [a] -> Endo (EndoOperatesOn [a])

aDualEndo :: [a] -> Dual (Endo (EndoOperatesOn [a]))

AnEndo a => AnEndo (Maybe a)

Associated Types

type EndoOperatesOn (Maybe a) :: *

Methods

anEndo :: Maybe a -> Endo (EndoOperatesOn (Maybe a))

aDualEndo :: Maybe a -> Dual (Endo (EndoOperatesOn (Maybe a)))

AnEndo a => AnEndo (Identity a)

Associated Types

type EndoOperatesOn (Identity a) :: *

Methods

anEndo :: Identity a -> Endo (EndoOperatesOn (Identity a))

aDualEndo :: Identity a -> Dual (Endo (EndoOperatesOn (Identity a)))

AnEndo a => AnEndo (Option a)

Has same semantics as Maybe and it is actually defined in terms of AnEndo instance for Maybe.

Associated Types

type EndoOperatesOn (Option a) :: *

Methods

anEndo :: Option a -> Endo (EndoOperatesOn (Option a))

aDualEndo :: Option a -> Dual (Endo (EndoOperatesOn (Option a)))

AnEndo (Endo a)

Associated Types

type EndoOperatesOn (Endo a) :: *

Methods

anEndo :: Endo a -> Endo (EndoOperatesOn (Endo a))

aDualEndo :: Endo a -> Dual (Endo (EndoOperatesOn (Endo a)))

AnEndo (a -> a)

Associated Types

type EndoOperatesOn (a -> a) :: *

Methods

anEndo :: (a -> a) -> Endo (EndoOperatesOn (a -> a))

aDualEndo :: (a -> a) -> Dual (Endo (EndoOperatesOn (a -> a)))

(AnEndo a, AnEndo b, (~) * (EndoOperatesOn a) (EndoOperatesOn b)) => AnEndo (a, b)

Associated Types

type EndoOperatesOn (a, b) :: *

Methods

anEndo :: (a, b) -> Endo (EndoOperatesOn (a, b))

aDualEndo :: (a, b) -> Dual (Endo (EndoOperatesOn (a, b)))

AnEndo (Proxy * a)

Constructs identity endomorphism for specified phantom type.

Associated Types

type EndoOperatesOn (Proxy * a) :: *

Methods

anEndo :: Proxy * a -> Endo (EndoOperatesOn (Proxy * a))

aDualEndo :: Proxy * a -> Dual (Endo (EndoOperatesOn (Proxy * a)))

(Foldable f, AnEndo a) => AnEndo (WrappedFoldable f a)

Associated Types

type EndoOperatesOn (WrappedFoldable f a) :: *

Methods

anEndo :: WrappedFoldable f a -> Endo (EndoOperatesOn (WrappedFoldable f a))

aDualEndo :: WrappedFoldable f a -> Dual (Endo (EndoOperatesOn (WrappedFoldable f a)))

(AnEndo a, AnEndo b, AnEndo c, (~) * (EndoOperatesOn a) (EndoOperatesOn b), (~) * (EndoOperatesOn a) (EndoOperatesOn c)) => AnEndo (a, b, c)

Associated Types

type EndoOperatesOn (a, b, c) :: *

Methods

anEndo :: (a, b, c) -> Endo (EndoOperatesOn (a, b, c))

aDualEndo :: (a, b, c) -> Dual (Endo (EndoOperatesOn (a, b, c)))

(Foldable f, AnEndo a) => AnEndo (Reverse * f a)

Fold in reverese order.

Associated Types

type EndoOperatesOn (Reverse * f a) :: *

Methods

anEndo :: Reverse * f a -> Endo (EndoOperatesOn (Reverse * f a))

aDualEndo :: Reverse * f a -> Dual (Endo (EndoOperatesOn (Reverse * f a)))

(AnEndo a1, AnEndo a2, AnEndo a3, AnEndo a4, (~) * (EndoOperatesOn a1) (EndoOperatesOn a2), (~) * (EndoOperatesOn a1) (EndoOperatesOn a3), (~) * (EndoOperatesOn a1) (EndoOperatesOn a4)) => AnEndo (a1, a2, a3, a4)

Associated Types

type EndoOperatesOn (a1, a2, a3, a4) :: *

Methods

anEndo :: (a1, a2, a3, a4) -> Endo (EndoOperatesOn (a1, a2, a3, a4))

aDualEndo :: (a1, a2, a3, a4) -> Dual (Endo (EndoOperatesOn (a1, a2, a3, a4)))

(AnEndo a1, AnEndo a2, AnEndo a3, AnEndo a4, AnEndo a5, (~) * (EndoOperatesOn a1) (EndoOperatesOn a2), (~) * (EndoOperatesOn a1) (EndoOperatesOn a3), (~) * (EndoOperatesOn a1) (EndoOperatesOn a4), (~) * (EndoOperatesOn a1) (EndoOperatesOn a5)) => AnEndo (a1, a2, a3, a4, a5)

Associated Types

type EndoOperatesOn (a1, a2, a3, a4, a5) :: *

Methods

anEndo :: (a1, a2, a3, a4, a5) -> Endo (EndoOperatesOn (a1, a2, a3, a4, a5))

aDualEndo :: (a1, a2, a3, a4, a5) -> Dual (Endo (EndoOperatesOn (a1, a2, a3, a4, a5)))

(AnEndo a1, AnEndo a2, AnEndo a3, AnEndo a4, AnEndo a5, AnEndo a6, (~) * (EndoOperatesOn a1) (EndoOperatesOn a2), (~) * (EndoOperatesOn a1) (EndoOperatesOn a3), (~) * (EndoOperatesOn a1) (EndoOperatesOn a4), (~) * (EndoOperatesOn a1) (EndoOperatesOn a5), (~) * (EndoOperatesOn a1) (EndoOperatesOn a6)) => AnEndo (a1, a2, a3, a4, a5, a6)

Associated Types

type EndoOperatesOn (a1, a2, a3, a4, a5, a6) :: *

Methods

anEndo :: (a1, a2, a3, a4, a5, a6) -> Endo (EndoOperatesOn (a1, a2, a3, a4, a5, a6))

aDualEndo :: (a1, a2, a3, a4, a5, a6) -> Dual (Endo (EndoOperatesOn (a1, a2, a3, a4, a5, a6)))

(AnEndo a1, AnEndo a2, AnEndo a3, AnEndo a4, AnEndo a5, AnEndo a6, AnEndo a7, (~) * (EndoOperatesOn a1) (EndoOperatesOn a2), (~) * (EndoOperatesOn a1) (EndoOperatesOn a3), (~) * (EndoOperatesOn a1) (EndoOperatesOn a4), (~) * (EndoOperatesOn a1) (EndoOperatesOn a5), (~) * (EndoOperatesOn a1) (EndoOperatesOn a6), (~) * (EndoOperatesOn a1) (EndoOperatesOn a7)) => AnEndo (a1, a2, a3, a4, a5, a6, a7)

Associated Types

type EndoOperatesOn (a1, a2, a3, a4, a5, a6, a7) :: *

Methods

anEndo :: (a1, a2, a3, a4, a5, a6, a7) -> Endo (EndoOperatesOn (a1, a2, a3, a4, a5, a6, a7))

aDualEndo :: (a1, a2, a3, a4, a5, a6, a7) -> Dual (Endo (EndoOperatesOn (a1, a2, a3, a4, a5, a6, a7)))

(AnEndo a1, AnEndo a2, AnEndo a3, AnEndo a4, AnEndo a5, AnEndo a6, AnEndo a7, AnEndo a8, (~) * (EndoOperatesOn a1) (EndoOperatesOn a2), (~) * (EndoOperatesOn a1) (EndoOperatesOn a3), (~) * (EndoOperatesOn a1) (EndoOperatesOn a4), (~) * (EndoOperatesOn a1) (EndoOperatesOn a5), (~) * (EndoOperatesOn a1) (EndoOperatesOn a6), (~) * (EndoOperatesOn a1) (EndoOperatesOn a7), (~) * (EndoOperatesOn a1) (EndoOperatesOn a8)) => AnEndo (a1, a2, a3, a4, a5, a6, a7, a8)

Associated Types

type EndoOperatesOn (a1, a2, a3, a4, a5, a6, a7, a8) :: *

Methods

anEndo :: (a1, a2, a3, a4, a5, a6, a7, a8) -> Endo (EndoOperatesOn (a1, a2, a3, a4, a5, a6, a7, a8))

aDualEndo :: (a1, a2, a3, a4, a5, a6, a7, a8) -> Dual (Endo (EndoOperatesOn (a1, a2, a3, a4, a5, a6, a7, a8)))

(AnEndo a1, AnEndo a2, AnEndo a3, AnEndo a4, AnEndo a5, AnEndo a6, AnEndo a7, AnEndo a8, AnEndo a9, (~) * (EndoOperatesOn a1) (EndoOperatesOn a2), (~) * (EndoOperatesOn a1) (EndoOperatesOn a3), (~) * (EndoOperatesOn a1) (EndoOperatesOn a4), (~) * (EndoOperatesOn a1) (EndoOperatesOn a5), (~) * (EndoOperatesOn a1) (EndoOperatesOn a6), (~) * (EndoOperatesOn a1) (EndoOperatesOn a7), (~) * (EndoOperatesOn a1) (EndoOperatesOn a8), (~) * (EndoOperatesOn a1) (EndoOperatesOn a9)) => AnEndo (a1, a2, a3, a4, a5, a6, a7, a8, a9)

Associated Types

type EndoOperatesOn (a1, a2, a3, a4, a5, a6, a7, a8, a9) :: *

Methods

anEndo :: (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Endo (EndoOperatesOn (a1, a2, a3, a4, a5, a6, a7, a8, a9))

aDualEndo :: (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Dual (Endo (EndoOperatesOn (a1, a2, a3, a4, a5, a6, a7, a8, a9)))

(AnEndo a1, AnEndo a2, AnEndo a3, AnEndo a4, AnEndo a5, AnEndo a6, AnEndo a7, AnEndo a8, AnEndo a9, AnEndo a10, (~) * (EndoOperatesOn a1) (EndoOperatesOn a2), (~) * (EndoOperatesOn a1) (EndoOperatesOn a3), (~) * (EndoOperatesOn a1) (EndoOperatesOn a4), (~) * (EndoOperatesOn a1) (EndoOperatesOn a5), (~) * (EndoOperatesOn a1) (EndoOperatesOn a6), (~) * (EndoOperatesOn a1) (EndoOperatesOn a7), (~) * (EndoOperatesOn a1) (EndoOperatesOn a8), (~) * (EndoOperatesOn a1) (EndoOperatesOn a9), (~) * (EndoOperatesOn a1) (EndoOperatesOn a10)) => AnEndo (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)

Associated Types

type EndoOperatesOn (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) :: *

Methods

anEndo :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) -> Endo (EndoOperatesOn (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10))

aDualEndo :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) -> Dual (Endo (EndoOperatesOn (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)))

WrappedFoldable

Newtype WrappedFoldable allows us to use anEndo, aDualEndo, foldEndo, and dualFoldEndo for any Foldable instance without the need to create specific instance for that specific Foldable type and reduces. It would be possible to create AnEndo instance for all Foldable types, but that would require OverlappingInstances language extension.

Usage examples:

\vectorOfEndos -> anEndo (WrappedFoldable vectorOfEndos)
    :: Vector (E a) -> Endo a

\vectorOfEndos -> foldEndo (WrappedFoldable vectorOfEndos)
    :: FoldEndoArgs => Vector (E a) -> args

Note that the Vector is just one of possible Foldable data types that may be used here. Also, (E a) is just an example of endomorphism representation, any AnEndo instance can be used.

newtype WrappedFoldable f a

Wrapper for Foldable types. Used to provide instances that work for all Foldable types without the need for OverlappingInstances language extension.

Constructors

WrapFoldable

Fields

• getFoldable :: f a

Instances

Monad f => Monad (WrappedFoldable f)

Methods

(>>=) :: WrappedFoldable f a -> (a -> WrappedFoldable f b) -> WrappedFoldable f b

(>>) :: WrappedFoldable f a -> WrappedFoldable f b -> WrappedFoldable f b

return :: a -> WrappedFoldable f a

fail :: String -> WrappedFoldable f a

Functor f => Functor (WrappedFoldable f)

Methods

fmap :: (a -> b) -> WrappedFoldable f a -> WrappedFoldable f b

(<$) :: a -> WrappedFoldable f b -> WrappedFoldable f a

Applicative f => Applicative (WrappedFoldable f)

Methods

pure :: a -> WrappedFoldable f a

(<*>) :: WrappedFoldable f (a -> b) -> WrappedFoldable f a -> WrappedFoldable f b

(*>) :: WrappedFoldable f a -> WrappedFoldable f b -> WrappedFoldable f b

(<*) :: WrappedFoldable f a -> WrappedFoldable f b -> WrappedFoldable f a

Foldable f => Foldable (WrappedFoldable f)

Methods

fold :: Monoid m => WrappedFoldable f m -> m

foldMap :: Monoid m => (a -> m) -> WrappedFoldable f a -> m

foldr :: (a -> b -> b) -> b -> WrappedFoldable f a -> b

foldr' :: (a -> b -> b) -> b -> WrappedFoldable f a -> b

foldl :: (b -> a -> b) -> b -> WrappedFoldable f a -> b

foldl' :: (b -> a -> b) -> b -> WrappedFoldable f a -> b

foldr1 :: (a -> a -> a) -> WrappedFoldable f a -> a

foldl1 :: (a -> a -> a) -> WrappedFoldable f a -> a

toList :: WrappedFoldable f a -> [a]

null :: WrappedFoldable f a -> Bool

length :: WrappedFoldable f a -> Int

elem :: Eq a => a -> WrappedFoldable f a -> Bool

maximum :: Ord a => WrappedFoldable f a -> a

minimum :: Ord a => WrappedFoldable f a -> a

sum :: Num a => WrappedFoldable f a -> a

product :: Num a => WrappedFoldable f a -> a

Traversable f => Traversable (WrappedFoldable f)

Methods

traverse :: Applicative f => (a -> f b) -> WrappedFoldable f a -> f (WrappedFoldable f b)

sequenceA :: Applicative f => WrappedFoldable f (f a) -> f (WrappedFoldable f a)

mapM :: Monad m => (a -> m b) -> WrappedFoldable f a -> m (WrappedFoldable f b)

sequence :: Monad m => WrappedFoldable f (m a) -> m (WrappedFoldable f a)

Generic1 (WrappedFoldable f)

Associated Types

type Rep1 (WrappedFoldable f :: * -> *) :: * -> *

Methods

from1 :: WrappedFoldable f a -> Rep1 (WrappedFoldable f) a

to1 :: Rep1 (WrappedFoldable f) a -> WrappedFoldable f a

Eq1 f => Eq1 (WrappedFoldable f)

Methods

liftEq :: (a -> b -> Bool) -> WrappedFoldable f a -> WrappedFoldable f b -> Bool

Ord1 f => Ord1 (WrappedFoldable f)

Methods

liftCompare :: (a -> b -> Ordering) -> WrappedFoldable f a -> WrappedFoldable f b -> Ordering

Read1 f => Read1 (WrappedFoldable f)

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (WrappedFoldable f a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [WrappedFoldable f a]

Show1 f => Show1 (WrappedFoldable f)

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> WrappedFoldable f a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [WrappedFoldable f a] -> ShowS

(Data (f a), Typeable * a, Typeable (* -> *) f) => Data (WrappedFoldable f a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WrappedFoldable f a -> c (WrappedFoldable f a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WrappedFoldable f a)

toConstr :: WrappedFoldable f a -> Constr

dataTypeOf :: WrappedFoldable f a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (WrappedFoldable f a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WrappedFoldable f a))

gmapT :: (forall b. Data b => b -> b) -> WrappedFoldable f a -> WrappedFoldable f a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedFoldable f a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedFoldable f a -> r

gmapQ :: (forall d. Data d => d -> u) -> WrappedFoldable f a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedFoldable f a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WrappedFoldable f a -> m (WrappedFoldable f a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedFoldable f a -> m (WrappedFoldable f a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedFoldable f a -> m (WrappedFoldable f a)

Read (f a) => Read (WrappedFoldable f a)

Methods

readsPrec :: Int -> ReadS (WrappedFoldable f a)

readList :: ReadS [WrappedFoldable f a]

readPrec :: ReadPrec (WrappedFoldable f a)

readListPrec :: ReadPrec [WrappedFoldable f a]

Show (f a) => Show (WrappedFoldable f a)

Methods

showsPrec :: Int -> WrappedFoldable f a -> ShowS

show :: WrappedFoldable f a -> String

showList :: [WrappedFoldable f a] -> ShowS

Generic (WrappedFoldable f a)

Associated Types

type Rep (WrappedFoldable f a) :: * -> *

Methods

from :: WrappedFoldable f a -> Rep (WrappedFoldable f a) x

to :: Rep (WrappedFoldable f a) x -> WrappedFoldable f a

(Foldable f, AnEndo a) => AnEndo (WrappedFoldable f a)

Associated Types

type EndoOperatesOn (WrappedFoldable f a) :: *

Methods

anEndo :: WrappedFoldable f a -> Endo (EndoOperatesOn (WrappedFoldable f a))

aDualEndo :: WrappedFoldable f a -> Dual (Endo (EndoOperatesOn (WrappedFoldable f a)))

type Rep1 (WrappedFoldable f)

type Rep1 (WrappedFoldable f) = D1 (MetaData "WrappedFoldable" "Data.Monoid.Endo.AnEndo" "endo-0.3.0.0-FDoQmRwl62o5XNvfgqOehr" True) (C1 (MetaCons "WrapFoldable" PrefixI True) (S1 (MetaSel (Just Symbol "getFoldable") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 f)))

type Rep (WrappedFoldable f a)

type Rep (WrappedFoldable f a) = D1 (MetaData "WrappedFoldable" "Data.Monoid.Endo.AnEndo" "endo-0.3.0.0-FDoQmRwl62o5XNvfgqOehr" True) (C1 (MetaCons "WrapFoldable" PrefixI True) (S1 (MetaSel (Just Symbol "getFoldable") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (f a))))

type EndoOperatesOn (WrappedFoldable f a)

type EndoOperatesOn (WrappedFoldable f a) = EndoOperatesOn a

Utility Functions and Types

embedEndoWith

Arguments

:: (AnEndo e, EndoOperatesOn e ~ a)

=> (Endo a -> b)

Embedding function.

-> e

-> b

Use Endo (possibly result of foldEndo) and use it to create value of different type.

Examples:

embedEndoWith tell
    :: (Monad m, AnEndo e, w ~ EndoOperatesOn e)
    => e
    -> WriterT (Endo w) m ()

embedEndoWith (modify . appEndo)
    :: (Monad m, AnEndo e, s ~ EndoOperatesOn e)
    => e
    -> StateT s m ()

See also embedDualEndoWith.

embedDualEndoWith

Arguments

:: (AnEndo e, EndoOperatesOn e ~ a)

=> (Dual (Endo a) -> b)

Embedding function.

-> e

-> b

Dual to embedEndoWith, which uses aDualEndo instead of anEndo.