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) => Semigroup (Folding f a)

Methods

(<>) :: Folding f a -> Folding f a -> Folding f a

sconcat :: NonEmpty (Folding f a) -> Folding f a

stimes :: Integral b => b -> Folding f a -> Folding f a

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

Methods

mempty :: Folding f a

mappend :: Folding f a -> Folding f a -> Folding f a

mconcat :: [Folding f a] -> 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 => Semigroup (Traversed a f)

Methods

(<>) :: Traversed a f -> Traversed a f -> Traversed a f

sconcat :: NonEmpty (Traversed a f) -> Traversed a f

stimes :: Integral b => b -> Traversed a f -> Traversed a f

Applicative f => Monoid (Traversed a f)

Methods

mempty :: Traversed a f

mappend :: Traversed a f -> Traversed a f -> Traversed a f

mconcat :: [Traversed a f] -> Traversed a f

newtype TraversedF a f

Used internally by traverse1Of_ and the like.

Since: 4.16

Constructors

TraversedF

Fields

• getTraversedF :: f a

Instances

Apply f => Semigroup (TraversedF a f)

Methods

(<>) :: TraversedF a f -> TraversedF a f -> TraversedF a f

sconcat :: NonEmpty (TraversedF a f) -> TraversedF a f

stimes :: Integral b => b -> TraversedF a f -> TraversedF a f

(Apply f, Applicative f) => Monoid (TraversedF a f)

Methods

mempty :: TraversedF a f

mappend :: TraversedF a f -> TraversedF a f -> TraversedF a f

mconcat :: [TraversedF a f] -> TraversedF a f

newtype Sequenced a m

Used internally by mapM_ and the like.

The argument a of the result should not be used!

See 4.16 Changelog entry for the explanation of "why not Apply f =>"?

Constructors

Sequenced

Fields

• getSequenced :: m a

Instances

Monad m => Semigroup (Sequenced a m)

Methods

(<>) :: Sequenced a m -> Sequenced a m -> Sequenced a m

sconcat :: NonEmpty (Sequenced a m) -> Sequenced a m

stimes :: Integral b => b -> Sequenced a m -> Sequenced a m

Monad m => Monoid (Sequenced a m)

Methods

mempty :: Sequenced a m

mappend :: Sequenced a m -> Sequenced a m -> Sequenced a m

mconcat :: [Sequenced a m] -> Sequenced a m

data Max a

Used for maximumOf.

Constructors

NoMax

Max a

Instances

Ord a => Semigroup (Max a)

Methods

(<>) :: Max a -> Max a -> Max a

sconcat :: NonEmpty (Max a) -> Max a

stimes :: Integral b => b -> Max a -> Max a

Ord a => Monoid (Max a)

Methods

mempty :: Max a

mappend :: Max a -> Max a -> Max a

mconcat :: [Max a] -> Max a

getMax :: Max a -> Maybe a

Obtain the maximum.

data Min a

Used for minimumOf.

Constructors

NoMin

Min a

Instances

Ord a => Semigroup (Min a)

Methods

(<>) :: Min a -> Min a -> Min a

sconcat :: NonEmpty (Min a) -> Min a

stimes :: Integral b => b -> Min a -> Min a

Ord a => Monoid (Min a)

Methods

mempty :: Min a

mappend :: Min a -> Min a -> Min a

mconcat :: [Min a] -> Min a

getMin :: Min a -> Maybe a

Obtain the minimum.

data Leftmost a

Used for preview.

Constructors

LPure

LLeaf a

LStep (Leftmost a)

Instances

Semigroup (Leftmost a)

Methods

(<>) :: Leftmost a -> Leftmost a -> Leftmost a

sconcat :: NonEmpty (Leftmost a) -> Leftmost a

stimes :: Integral b => b -> Leftmost a -> Leftmost a

Monoid (Leftmost a)

Methods

mempty :: Leftmost a

mappend :: Leftmost a -> Leftmost a -> Leftmost a

mconcat :: [Leftmost a] -> 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

Semigroup (Rightmost a)

Methods

(<>) :: Rightmost a -> Rightmost a -> Rightmost a

sconcat :: NonEmpty (Rightmost a) -> Rightmost a

stimes :: Integral b => b -> Rightmost a -> Rightmost a

Monoid (Rightmost a)

Methods

mempty :: Rightmost a

mappend :: Rightmost a -> Rightmost a -> Rightmost a

mconcat :: [Rightmost a] -> 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

Semigroups for folding

newtype NonEmptyDList a

Constructors

NonEmptyDList

Fields

• getNonEmptyDList :: [a] -> NonEmpty a

Instances

Semigroup (NonEmptyDList a)

Methods

(<>) :: NonEmptyDList a -> NonEmptyDList a -> NonEmptyDList a

sconcat :: NonEmpty (NonEmptyDList a) -> NonEmptyDList a

stimes :: Integral b => b -> NonEmptyDList a -> NonEmptyDList a