Control.Lens.Internal.Fold

Monoids for folding

newtype Folding f a

A Monoid for a Contravariant Applicative.

Constructors

Folding

Fields

getFolding :: f a

Instances

(Contravariant f, Applicative f) => Monoid (Folding f a)

(Contravariant f, Apply f) => Semigroup (Folding f a)

newtype Traversed a f

Used internally by traverseOf_ and the like.

The argument a of the result should not be used!

Constructors

Traversed

Fields

getTraversed :: f a

Instances

Applicative f => Monoid (Traversed a f)

Apply f => Semigroup (Traversed a f)

newtype Sequenced a m

Used internally by mapM_ and the like.

The argument a of the result should not be used!

Constructors

Sequenced

Fields

getSequenced :: m a

Instances

Monad m => Monoid (Sequenced a m)

Apply m => Semigroup (Sequenced a m)

data Max a

Used for maximumOf.

Constructors

NoMax

Max a

Instances

Ord a => Monoid (Max a)

Ord a => Semigroup (Max a)

getMax :: Max a -> Maybe a

Obtain the maximum.

data Min a

Used for minimumOf.

Constructors

NoMin

Min a

Instances

Ord a => Monoid (Min a)

Ord a => Semigroup (Min a)

getMin :: Min a -> Maybe a

Obtain the minimum.

data Leftmost a

Used for preview.

Constructors

LPure

LLeaf a

LStep (Leftmost a)

Instances

Monoid (Leftmost a)

Semigroup (Leftmost a)

getLeftmost :: Leftmost a -> Maybe a

Extract the Leftmost element. This will fairly eagerly determine that it can return Just the moment it sees any element at all.

data Rightmost a

Used for lastOf.

Constructors

RPure

RLeaf a

RStep (Rightmost a)

Instances

Monoid (Rightmost a)

Semigroup (Rightmost a)

getRightmost :: Rightmost a -> Maybe a

Extract the Rightmost element. This will fairly eagerly determine that it can return Just the moment it sees any element at all.

data ReifiedMonoid a

Constructors

ReifiedMonoid

Fields

reifiedMappend :: a -> a -> a

reifiedMempty :: a

newtype M a s

Constructors

M a

Instances

Reifies * s (ReifiedMonoid a) => Monoid (M a s)

reifyFold :: (a -> a -> a) -> a -> (forall s. Reifies s (ReifiedMonoid a) => t -> M a s) -> t -> a