optics-core-0.4.1.1: Optics as an abstract interface: core definitions

Safe Haskell | None
Language | Haskell2010

Optics.Fold

Contents

- Formation
- Introduction
- Elimination
- Computation
- Additional introduction forms
- Additional elimination forms
- Combinators
- Monoid structures
- Subtyping

Description

A ``Fold` S A` has the ability to extract some number of elements of type `A` from a container of type `S`. For example, `toListOf` can be used to obtain the contained elements as a list. Unlike a `Traversal`, there is no way to set or update elements.

This can be seen as a generalisation of `traverse_`, where the type `S` does not need to be a type constructor with `A` as the last parameter.

A close relative is the `AffineFold`, which is a `Fold` that contains at most one element.

Synopsis

- type Fold s a = Optic' A_Fold NoIx s a
- foldVL :: (forall (f :: Type -> Type). Applicative f => (a -> f u) -> s -> f v) -> Fold s a
- foldOf :: forall k a (is :: IxList) s. (Is k A_Fold, Monoid a) => Optic' k is s a -> s -> a
- foldMapOf :: forall k m (is :: IxList) s a. (Is k A_Fold, Monoid m) => Optic' k is s a -> (a -> m) -> s -> m
- foldrOf :: forall k (is :: IxList) s a r. Is k A_Fold => Optic' k is s a -> (a -> r -> r) -> r -> s -> r
- foldlOf' :: forall k (is :: IxList) s a r. Is k A_Fold => Optic' k is s a -> (r -> a -> r) -> r -> s -> r
- toListOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> s -> [a]
- sequenceOf_ :: forall k f (is :: IxList) s a. (Is k A_Fold, Applicative f) => Optic' k is s (f a) -> s -> f ()
- traverseOf_ :: forall k f (is :: IxList) s a r. (Is k A_Fold, Applicative f) => Optic' k is s a -> (a -> f r) -> s -> f ()
- forOf_ :: forall k f (is :: IxList) s a r. (Is k A_Fold, Applicative f) => Optic' k is s a -> s -> (a -> f r) -> f ()
- folded :: Foldable f => Fold (f a) a
- folding :: Foldable f => (s -> f a) -> Fold s a
- foldring :: (forall (f :: Type -> Type). Applicative f => (a -> f u -> f u) -> f v -> s -> f w) -> Fold s a
- unfolded :: (s -> Maybe (a, s)) -> Fold s a
- has :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> s -> Bool
- hasn't :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> s -> Bool
- headOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> s -> Maybe a
- lastOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> s -> Maybe a
- andOf :: forall k (is :: IxList) s. Is k A_Fold => Optic' k is s Bool -> s -> Bool
- orOf :: forall k (is :: IxList) s. Is k A_Fold => Optic' k is s Bool -> s -> Bool
- allOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> (a -> Bool) -> s -> Bool
- anyOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> (a -> Bool) -> s -> Bool
- noneOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> (a -> Bool) -> s -> Bool
- productOf :: forall k a (is :: IxList) s. (Is k A_Fold, Num a) => Optic' k is s a -> s -> a
- sumOf :: forall k a (is :: IxList) s. (Is k A_Fold, Num a) => Optic' k is s a -> s -> a
- asumOf :: forall k f (is :: IxList) s a. (Is k A_Fold, Alternative f) => Optic' k is s (f a) -> s -> f a
- msumOf :: forall k m (is :: IxList) s a. (Is k A_Fold, MonadPlus m) => Optic' k is s (m a) -> s -> m a
- elemOf :: forall k a (is :: IxList) s. (Is k A_Fold, Eq a) => Optic' k is s a -> a -> s -> Bool
- notElemOf :: forall k a (is :: IxList) s. (Is k A_Fold, Eq a) => Optic' k is s a -> a -> s -> Bool
- lengthOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> s -> Int
- maximumOf :: forall k a (is :: IxList) s. (Is k A_Fold, Ord a) => Optic' k is s a -> s -> Maybe a
- minimumOf :: forall k a (is :: IxList) s. (Is k A_Fold, Ord a) => Optic' k is s a -> s -> Maybe a
- maximumByOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> (a -> a -> Ordering) -> s -> Maybe a
- minimumByOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> (a -> a -> Ordering) -> s -> Maybe a
- findOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> (a -> Bool) -> s -> Maybe a
- findMOf :: forall k m (is :: IxList) s a. (Is k A_Fold, Monad m) => Optic' k is s a -> (a -> m Bool) -> s -> m (Maybe a)
- lookupOf :: forall k a (is :: IxList) s v. (Is k A_Fold, Eq a) => Optic' k is s (a, v) -> a -> s -> Maybe v
- universeOf :: forall k (is :: IxList) a. Is k A_Fold => Optic' k is a a -> a -> [a]
- cosmosOf :: forall k (is :: IxList) a. Is k A_Fold => Optic' k is a a -> Fold a a
- paraOf :: forall k (is :: IxList) a r. Is k A_Fold => Optic' k is a a -> (a -> [r] -> r) -> a -> r
- pre :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> AffineFold s a
- backwards_ :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> Fold s a
- summing :: forall k l (is :: IxList) s a (js :: IxList). (Is k A_Fold, Is l A_Fold) => Optic' k is s a -> Optic' l js s a -> Fold s a
- failing :: forall k l (is :: IxList) s a (js :: IxList). (Is k A_Fold, Is l A_Fold) => Optic' k is s a -> Optic' l js s a -> Fold s a
- data A_Fold

# Formation

type Fold s a = Optic' A_Fold NoIx s a Source #

Type synonym for a fold.

# Introduction

foldVL :: (forall (f :: Type -> Type). Applicative f => (a -> f u) -> s -> f v) -> Fold s a Source #

Obtain a `Fold` by lifting `traverse_` like function.

    foldVL . traverseOf_ ≡ id
    traverseOf_ . foldVL ≡ id

# Elimination

foldOf :: forall k a (is :: IxList) s. (Is k A_Fold, Monoid a) => Optic' k is s a -> s -> a Source #

Combine the results of a fold using a monoid.

foldMapOf :: forall k m (is :: IxList) s a. (Is k A_Fold, Monoid m) => Optic' k is s a -> (a -> m) -> s -> m Source #

Fold via embedding into a monoid.

foldrOf :: forall k (is :: IxList) s a r. Is k A_Fold => Optic' k is s a -> (a -> r -> r) -> r -> s -> r Source #

Fold right-associatively.

foldlOf' :: forall k (is :: IxList) s a r. Is k A_Fold => Optic' k is s a -> (r -> a -> r) -> r -> s -> r Source #

Fold left-associatively, and strictly.

toListOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> s -> [a] Source #

Fold to a list.

    >>> toListOf (_1 % folded % _Right) ([Right 'h', Left 5, Right 'i'], "bye")
    "hi"

sequenceOf_ :: forall k f (is :: IxList) s a. (Is k A_Fold, Applicative f) => Optic' k is s (f a) -> s -> f () Source #

Evaluate each action in a structure observed by a `Fold` from left to right, ignoring the results.

    sequenceA_ ≡ sequenceOf_ folded

    >>> sequenceOf_ each (putStrLn "hello",putStrLn "world")
    hello
    world

traverseOf_ :: forall k f (is :: IxList) s a r. (Is k A_Fold, Applicative f) => Optic' k is s a -> (a -> f r) -> s -> f () Source #

Traverse over all of the targets of a `Fold`, computing an `Applicative`-based answer, but unlike `traverseOf` do not construct a new structure. `traverseOf_` generalizes `traverse_` to work over any `Fold`.

    >>> traverseOf_ each putStrLn ("hello","world")
    hello
    world

    traverse_ ≡ traverseOf_ folded

forOf_ :: forall k f (is :: IxList) s a r. (Is k A_Fold, Applicative f) => Optic' k is s a -> s -> (a -> f r) -> f () Source #

A version of `traverseOf_` with the arguments flipped.

# Computation

    traverseOf_ (foldVL f) ≡ f

# Additional introduction forms

folded :: Foldable f => Fold (f a) a Source #

Fold via the `Foldable` class.

folding :: Foldable f => (s -> f a) -> Fold s a Source #

Obtain a `Fold` by lifting an operation that returns a `Foldable` result.

This can be useful to lift operations from `Data.List` and elsewhere into a `Fold`.

    >>> toListOf (folding tail) [1,2,3,4]
    [2,3,4]

foldring :: (forall (f :: Type -> Type). Applicative f => (a -> f u -> f u) -> f v -> s -> f w) -> Fold s a Source #

Obtain a `Fold` by lifting `foldr` like function.

    >>> toListOf (foldring foldr) [1,2,3,4]
    [1,2,3,4]

unfolded :: (s -> Maybe (a, s)) -> Fold s a Source #

Build a `Fold` that unfolds its values from a seed.

    unfoldr ≡ toListOf . unfolded

    >>> toListOf (unfolded $ \b -> if b == 0 then Nothing else Just (b, b - 1)) 10
    [10,9,8,7,6,5,4,3,2,1]

# Additional elimination forms

See also `setOf`, which constructs a `Set` from a `Fold`.

has :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> s -> Bool Source #

Check to see if this optic matches 1 or more entries.

    >>> has _Left (Left 12)
    True

    >>> has _Right (Left 12)
    False

This will always return `True` for a `Lens` or `Getter`.

    >>> has _1 ("hello","world")
    True

hasn't :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> s -> Bool Source #

Check to see if this `Fold` or `Traversal` has no matches.

    >>> hasn't _Left (Right 12)
    True

    >>> hasn't _Left (Left 12)
    False

headOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> s -> Maybe a Source #

Retrieve the first entry of a `Fold`.

    >>> headOf folded [1..10]
    Just 1

    >>> headOf each (1,2)
    Just 1

lastOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> s -> Maybe a Source #

Retrieve the last entry of a `Fold`.

    >>> lastOf folded [1..10]
    Just 10

    >>> lastOf each (1,2)
    Just 2

andOf :: forall k (is :: IxList) s. Is k A_Fold => Optic' k is s Bool -> s -> Bool Source #

Returns `True` if every target of a `Fold` is `True`.

    >>> andOf each (True, False)
    False
    >>> andOf each (True, True)
    True

    and ≡ andOf folded

orOf :: forall k (is :: IxList) s. Is k A_Fold => Optic' k is s Bool -> s -> Bool Source #

Returns `True` if any target of a `Fold` is `True`.

    >>> orOf each (True, False)
    True
    >>> orOf each (False, False)
    False

    or ≡ orOf folded

allOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> (a -> Bool) -> s -> Bool Source #

Returns `True` if every target of a `Fold` satisfies a predicate.

    >>> allOf each (>=3) (4,5)
    True
    >>> allOf folded (>=2) [1..10]
    False

    all ≡ allOf folded

anyOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> (a -> Bool) -> s -> Bool Source #

Returns `True` if any target of a `Fold` satisfies a predicate.

    >>> anyOf each (=='x') ('x','y')
    True

noneOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> (a -> Bool) -> s -> Bool Source #

Returns `True` only if no targets of a `Fold` satisfy a predicate.

    >>> noneOf each (not . isn't _Nothing) (Just 3, Just 4, Just 5)
    True
    >>> noneOf (folded % folded) (<10) [[13,99,20],[3,71,42]]
    False

productOf :: forall k a (is :: IxList) s. (Is k A_Fold, Num a) => Optic' k is s a -> s -> a Source #

Calculate the `Product` of every number targeted by a `Fold`.

    >>> productOf each (4,5)
    20
    >>> productOf folded [1,2,3,4,5]
    120

    product ≡ productOf folded

This operation may be more strict than you would expect. If you want a lazier version use `\o -> `getProduct` `.` `foldMapOf` o `Product``.

sumOf :: forall k a (is :: IxList) s. (Is k A_Fold, Num a) => Optic' k is s a -> s -> a Source #

Calculate the `Sum` of every number targeted by a `Fold`.

    >>> sumOf each (5,6)
    11
    >>> sumOf folded [1,2,3,4]
    10
    >>> sumOf (folded % each) [(1,2),(3,4)]
    10

    sum ≡ sumOf folded

This operation may be more strict than you would expect. If you want a lazier version use `\o -> `getSum` `.` `foldMapOf` o `Sum``

asumOf :: forall k f (is :: IxList) s a. (Is k A_Fold, Alternative f) => Optic' k is s (f a) -> s -> f a Source #

The sum of a collection of actions.

    >>> asumOf each ("hello","world")
    "helloworld"

    >>> asumOf each (Nothing, Just "hello", Nothing)
    Just "hello"

    asum ≡ asumOf folded

msumOf :: forall k m (is :: IxList) s a. (Is k A_Fold, MonadPlus m) => Optic' k is s (m a) -> s -> m a Source #

The sum of a collection of actions.

    >>> msumOf each ("hello","world")
    "helloworld"

    >>> msumOf each (Nothing, Just "hello", Nothing)
    Just "hello"

    msum ≡ msumOf folded

elemOf :: forall k a (is :: IxList) s. (Is k A_Fold, Eq a) => Optic' k is s a -> a -> s -> Bool Source #

Does the element occur anywhere within a given `Fold` of the structure?

    >>> elemOf each "hello" ("hello","world")
    True

    elem ≡ elemOf folded

notElemOf :: forall k a (is :: IxList) s. (Is k A_Fold, Eq a) => Optic' k is s a -> a -> s -> Bool Source #

Does the element not occur anywhere within a given `Fold` of the structure?

    >>> notElemOf each 'd' ('a','b','c')
    True

    >>> notElemOf each 'a' ('a','b','c')
    False

    notElem ≡ notElemOf folded

lengthOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> s -> Int Source #

Calculate the number of targets there are for a `Fold` in a given container.

Note: This can be rather inefficient for large containers and just like `length`, this will not terminate for infinite folds.

    length ≡ lengthOf folded

    >>> lengthOf _1 ("hello",())
    1

    >>> lengthOf folded [1..10]
    10

    >>> lengthOf (folded % folded) [[1,2],[3,4],[5,6]]
    6

maximumOf :: forall k a (is :: IxList) s. (Is k A_Fold, Ord a) => Optic' k is s a -> s -> Maybe a Source #

Obtain the maximum element (if any) targeted by a `Fold` safely.

Note: `maximumOf` on a valid `Iso`, `Lens` or `Getter` will always return `Just` a value.

    >>> maximumOf folded [1..10]
    Just 10

    >>> maximumOf folded []
    Nothing

    >>> maximumOf (folded % filtered even) [1,4,3,6,7,9,2]
    Just 6

    maximum ≡ fromMaybe (error "empty") . maximumOf folded

In the interest of efficiency, This operation has semantics more strict than strictly necessary. `\o -> `getMax` . `foldMapOf` o `Max`` has lazier semantics but could leak memory.

minimumOf :: forall k a (is :: IxList) s. (Is k A_Fold, Ord a) => Optic' k is s a -> s -> Maybe a Source #

Obtain the minimum element (if any) targeted by a `Fold` safely.

Note: `minimumOf` on a valid `Iso`, `Lens` or `Getter` will always return `Just` a value.

    >>> minimumOf folded [1..10]
    Just 1

    >>> minimumOf folded []
    Nothing

    >>> minimumOf (folded % filtered even) [1,4,3,6,7,9,2]
    Just 2

    minimum ≡ fromMaybe (error "empty") . minimumOf folded

In the interest of efficiency, This operation has semantics more strict than strictly necessary. `\o -> `getMin` . `foldMapOf` o `Min`` has lazier semantics but could leak memory.

maximumByOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> (a -> a -> Ordering) -> s -> Maybe a Source #

Obtain the maximum element (if any) targeted by a `Fold` according to a user supplied `Ordering`.

    >>> maximumByOf folded (compare `on` length) ["mustard","relish","ham"]
    Just "mustard"

In the interest of efficiency, This operation has semantics more strict than strictly necessary.

    maximumBy cmp ≡ fromMaybe (error "empty") . maximumByOf folded cmp

minimumByOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> (a -> a -> Ordering) -> s -> Maybe a Source #

Obtain the minimum element (if any) targeted by a `Fold` according to a user supplied `Ordering`.

In the interest of efficiency, This operation has semantics more strict than strictly necessary.

    >>> minimumByOf folded (compare `on` length) ["mustard","relish","ham"]
    Just "ham"

    minimumBy cmp ≡ fromMaybe (error "empty") . minimumByOf folded cmp

findOf :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> (a -> Bool) -> s -> Maybe a Source #

The `findOf` function takes a `Fold`, a predicate and a structure and returns the leftmost element of the structure matching the predicate, or `Nothing` if there is no such element.

    >>> findOf each even (1,3,4,6)
    Just 4

    >>> findOf folded even [1,3,5,7]
    Nothing

    find ≡ findOf folded

findMOf :: forall k m (is :: IxList) s a. (Is k A_Fold, Monad m) => Optic' k is s a -> (a -> m Bool) -> s -> m (Maybe a) Source #

The `findMOf` function takes a `Fold`, a monadic predicate and a structure and returns in the monad the leftmost element of the structure matching the predicate, or `Nothing` if there is no such element.

    >>> findMOf each (\x -> print ("Checking " ++ show x) >> return (even x)) (1,3,4,6)
    "Checking 1"
    "Checking 3"
    "Checking 4"
    Just 4

    >>> findMOf each (\x -> print ("Checking " ++ show x) >> return (even x)) (1,3,5,7)
    "Checking 1"
    "Checking 3"
    "Checking 5"
    "Checking 7"
    Nothing

    findMOf folded :: (Monad m, Foldable f) => (a -> m Bool) -> f a -> m (Maybe a)

lookupOf :: forall k a (is :: IxList) s v. (Is k A_Fold, Eq a) => Optic' k is s (a, v) -> a -> s -> Maybe v Source #

The `lookupOf` function takes a `Fold`, a key, and a structure containing key/value pairs. It returns the first value corresponding to the given key. This function generalizes `lookup` to work on an arbitrary `Fold` instead of lists.

    >>> lookupOf folded 4 [(2, 'a'), (4, 'b'), (4, 'c')]
    Just 'b'

    >>> lookupOf folded 2 [(2, 'a'), (4, 'b'), (4, 'c')]
    Just 'a'

universeOf :: forall k (is :: IxList) a. Is k A_Fold => Optic' k is a a -> a -> [a] Source #

Given a `Fold` that knows how to locate immediate children, retrieve all of the transitive descendants of a node, including itself.

Since: 0.4.1

cosmosOf :: forall k (is :: IxList) a. Is k A_Fold => Optic' k is a a -> Fold a a Source #

Given a `Fold` that knows how to locate immediate children, fold all of the transitive descendants of a node, including itself.

Since: 0.4.1

paraOf :: forall k (is :: IxList) a r. Is k A_Fold => Optic' k is a a -> (a -> [r] -> r) -> a -> r Source #

Perform a fold-like computation on each value, technically a paramorphism.

Since: 0.4.1

# Combinators

pre :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> AffineFold s a Source #

Convert a fold to an `AffineFold` that visits the first element of the original fold.

For the traversal version see `singular`.

backwards_ :: forall k (is :: IxList) s a. Is k A_Fold => Optic' k is s a -> Fold s a Source #

This allows you to traverse the elements of a `Fold` in the opposite order.

# Monoid structures

`Fold` admits (at least) two monoid structures:

- `summing` concatenates results from both folds.
- `failing` returns results from the second fold only if the first returns no results.

In both cases, the identity element of the monoid is `ignored`, which returns no results.

There is no `Semigroup` or `Monoid` instance for `Fold`, because there is not a unique choice of monoid to use, and the (`<>`) operator could not be used to combine optics of different kinds. When porting code from `lens` that uses `<>` to combine folds, use `summing` instead.

summing :: forall k l (is :: IxList) s a (js :: IxList). (Is k A_Fold, Is l A_Fold) => Optic' k is s a -> Optic' l js s a -> Fold s a infixr 6 Source #

Return entries of the first `Fold`, then the second one.

    >>> toListOf (_1 % ix 0 `summing` _2 % ix 1) ([1,2], [4,7,1])
    [1,7]

For the traversal version see `adjoin`.

failing :: forall k l (is :: IxList) s a (js :: IxList). (Is k A_Fold, Is l A_Fold) => Optic' k is s a -> Optic' l js s a -> Fold s a infixl 3 Source #

Try the first `Fold`. If it returns no entries, try the second one.

    >>> toListOf (ix 1 `failing` ix 0) [4,7]
    [7]
    >>> toListOf (ix 1 `failing` ix 0) [4]
    [4]

# Subtyping

data A_Fold Source #

Tag for a fold.

#### Instances

Instances details

Is A_Getter A_Fold Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods implies :: forall (p :: Type -> Type -> Type -> Type) r. (Constraints A_Getter p => r) -> Constraints A_Fold p => r Source #
Is A_Lens A_Fold Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods implies :: forall (p :: Type -> Type -> Type -> Type) r. (Constraints A_Lens p => r) -> Constraints A_Fold p => r Source #
Is A_Prism A_Fold Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods implies :: forall (p :: Type -> Type -> Type -> Type) r. (Constraints A_Prism p => r) -> Constraints A_Fold p => r Source #
Is A_ReversedPrism A_Fold Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods implies :: forall (p :: Type -> Type -> Type -> Type) r. (Constraints A_ReversedPrism p => r) -> Constraints A_Fold p => r Source #
Is A_Traversal A_Fold Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods implies :: forall (p :: Type -> Type -> Type -> Type) r. (Constraints A_Traversal p => r) -> Constraints A_Fold p => r Source #
Is An_AffineFold A_Fold Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods implies :: forall (p :: Type -> Type -> Type -> Type) r. (Constraints An_AffineFold p => r) -> Constraints A_Fold p => r Source #
Is An_AffineTraversal A_Fold Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods implies :: forall (p :: Type -> Type -> Type -> Type) r. (Constraints An_AffineTraversal p => r) -> Constraints A_Fold p => r Source #
Is An_Iso A_Fold Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods implies :: forall (p :: Type -> Type -> Type -> Type) r. (Constraints An_Iso p => r) -> Constraints A_Fold p => r Source #
k ~ A_Fold => JoinKinds A_Fold A_Fold k Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Fold p, Constraints A_Fold p) => r) -> Constraints k p => r Source #
k ~ A_Fold => JoinKinds A_Fold A_Getter k Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Fold p, Constraints A_Getter p) => r) -> Constraints k p => r Source #
k ~ A_Fold => JoinKinds A_Fold A_Lens k Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Fold p, Constraints A_Lens p) => r) -> Constraints k p => r Source #
k ~ A_Fold => JoinKinds A_Fold A_Prism k Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Fold p, Constraints A_Prism p) => r) -> Constraints k p => r Source #
k ~ A_Fold => JoinKinds A_Fold A_ReversedPrism k Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Fold p, Constraints A_ReversedPrism p) => r) -> Constraints k p => r Source #
k ~ A_Fold => JoinKinds A_Fold A_Traversal k Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Fold p, Constraints A_Traversal p) => r) -> Constraints k p => r Source #
k ~ A_Fold => JoinKinds A_Fold An_AffineFold k Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Fold p, Constraints An_AffineFold p) => r) -> Constraints k p => r Source #
k ~ A_Fold => JoinKinds A_Fold An_AffineTraversal k Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Fold p, Constraints An_AffineTraversal p) => r) -> Constraints k p => r Source #
k ~ A_Fold => JoinKinds A_Fold An_Iso k Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Fold p, Constraints An_Iso p) => r) -> Constraints k p => r Source #
k ~ A_Fold => JoinKinds A_Getter A_Fold k Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Getter p, Constraints A_Fold p) => r) -> Constraints k p => r Source #
k ~ A_Fold => JoinKinds A_Lens A_Fold k Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Lens p, Constraints A_Fold p) => r) -> Constraints k p => r Source #
k ~ A_Fold => JoinKinds A_Prism A_Fold k Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Prism p, Constraints A_Fold p) => r) -> Constraints k p => r Source #
k ~ A_Fold => JoinKinds A_ReversedPrism A_Fold k Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_ReversedPrism p, Constraints A_Fold p) => r) -> Constraints k p => r Source #
k ~ A_Fold => JoinKinds A_Traversal A_Fold k Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Traversal p, Constraints A_Fold p) => r) -> Constraints k p => r Source #
k ~ A_Fold => JoinKinds An_AffineFold A_Fold k Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints An_AffineFold p, Constraints A_Fold p) => r) -> Constraints k p => r Source #
k ~ A_Fold => JoinKinds An_AffineTraversal A_Fold k Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints An_AffineTraversal p, Constraints A_Fold p) => r) -> Constraints k p => r Source #
k ~ A_Fold => JoinKinds An_Iso A_Fold k Source # |
Instance details Defined in Optics.Internal.Optic.Subtyping Methods joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints An_Iso p, Constraints A_Fold p) => r) -> Constraints k p => r Source #
(s ~ t, a ~ b) => IxOptic A_Fold s t a b Source # |
Instance details Defined in Optics.Indexed.Core Methods noIx :: forall (is :: IxList). NonEmptyIndices is => Optic A_Fold is s t a b -> Optic A_Fold NoIx s t a b Source #
(s ~ t, a ~ b) => ToReadOnly A_Fold s t a b Source # |

Instance details

Defined in Optics.ReadOnly

Associated Types

type ReadOnlyOptic A_Fold |
Instance details Defined in Optics.ReadOnly type ReadOnlyOptic A_Fold = A_Fold

Methods

getting :: forall (is :: IxList). Optic A_Fold is s t a b -> Optic' (ReadOnlyOptic A_Fold) is s a Source #

type ReadOnlyOptic A_Fold Source # |
Instance details Defined in Optics.ReadOnly type ReadOnlyOptic A_Fold = A_Fold