Control.Lens.Traversal

lens-4.15.3: Lenses, Folds and Traversals

Copyright | (C) 2012-16 Edward Kmett
License | BSD-style (see the file LICENSE)
Maintainer | Edward Kmett <ekmett@gmail.com>
Stability | provisional
Portability | Rank2Types
Safe Haskell | Trustworthy
Language | Haskell98

Control.Lens.Traversal

Contents

- Traversals
- Traversing and Lensing
- Monomorphic Traversals
- Parts and Holes
- Common Traversals
- Indexed Traversals
  - Common
  - Combinators
- Reflection
- Implementation Details
- Fusion

Description

A ``Traversal` s t a b` is a generalization of `traverse` from `Traversable`. It allows you to `traverse` over a structure and change out its contents with monadic or `Applicative` side-effects. Starting from

    traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)

we monomorphize the contents and result to obtain

    type Traversal s t a b = forall f. Applicative f => (a -> f b) -> s -> f t

A `Traversal` can be used as a `Fold`. Any `Traversal` can be used for `Getting` like a `Fold`, because given a `Monoid` `m`, we have an `Applicative` for `(`Const` m)`. Everything you know how to do with a `Traversable` container, you can with a `Traversal`, and here we provide combinators that generalize the usual `Traversable` operations.

Synopsis

- type Traversal s t a b = forall f. Applicative f => (a -> f b) -> s -> f t
- type Traversal' s a = Traversal s s a a
- type Traversal1 s t a b = forall f. Apply f => (a -> f b) -> s -> f t
- type Traversal1' s a = Traversal1 s s a a
- type IndexedTraversal i s t a b = forall p f. (Indexable i p, Applicative f) => p a (f b) -> s -> f t
- type IndexedTraversal' i s a = IndexedTraversal i s s a a
- type IndexedTraversal1 i s t a b = forall p f. (Indexable i p, Apply f) => p a (f b) -> s -> f t
- type IndexedTraversal1' i s a = IndexedTraversal1 i s s a a
- type ATraversal s t a b = LensLike (Bazaar (->) a b) s t a b
- type ATraversal' s a = ATraversal s s a a
- type ATraversal1 s t a b = LensLike (Bazaar1 (->) a b) s t a b
- type ATraversal1' s a = ATraversal1 s s a a
- type AnIndexedTraversal i s t a b = Over (Indexed i) (Bazaar (Indexed i) a b) s t a b
- type AnIndexedTraversal' i s a = AnIndexedTraversal i s s a a
- type AnIndexedTraversal1 i s t a b = Over (Indexed i) (Bazaar1 (Indexed i) a b) s t a b
- type AnIndexedTraversal1' i s a = AnIndexedTraversal1 i s s a a
- type Traversing p f s t a b = Over p (BazaarT p f a b) s t a b
- type Traversing' p f s a = Traversing p f s s a a
- type Traversing1 p f s t a b = Over p (BazaarT1 p f a b) s t a b
- type Traversing1' p f s a = Traversing1 p f s s a a
- traverseOf :: LensLike f s t a b -> (a -> f b) -> s -> f t
- forOf :: LensLike f s t a b -> s -> (a -> f b) -> f t
- sequenceAOf :: LensLike f s t (f b) b -> s -> f t
- mapMOf :: LensLike (WrappedMonad m) s t a b -> (a -> m b) -> s -> m t
- forMOf :: LensLike (WrappedMonad m) s t a b -> s -> (a -> m b) -> m t
- sequenceOf :: LensLike (WrappedMonad m) s t (m b) b -> s -> m t
- transposeOf :: LensLike ZipList s t [a] a -> s -> [t]
- mapAccumLOf :: LensLike (State acc) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
- mapAccumROf :: LensLike (Backwards (State acc)) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
- scanr1Of :: LensLike (Backwards (State (Maybe a))) s t a a -> (a -> a -> a) -> s -> t
- scanl1Of :: LensLike (State (Maybe a)) s t a a -> (a -> a -> a) -> s -> t
- failover :: Alternative m => LensLike ((,) Any) s t a b -> (a -> b) -> s -> m t
- ifailover :: Alternative m => Over (Indexed i) ((,) Any) s t a b -> (i -> a -> b) -> s -> m t
- cloneTraversal :: ATraversal s t a b -> Traversal s t a b
- cloneIndexPreservingTraversal :: ATraversal s t a b -> IndexPreservingTraversal s t a b
- cloneIndexedTraversal :: AnIndexedTraversal i s t a b -> IndexedTraversal i s t a b
- cloneTraversal1 :: ATraversal1 s t a b -> Traversal1 s t a b
- cloneIndexPreservingTraversal1 :: ATraversal1 s t a b -> IndexPreservingTraversal1 s t a b
- cloneIndexedTraversal1 :: AnIndexedTraversal1 i s t a b -> IndexedTraversal1 i s t a b
- partsOf :: Functor f => Traversing (->) f s t a a -> LensLike f s t [a] [a]
- partsOf' :: ATraversal s t a a -> Lens s t [a] [a]
- unsafePartsOf :: Functor f => Traversing (->) f s t a b -> LensLike f s t [a] [b]
- unsafePartsOf' :: ATraversal s t a b -> Lens s t [a] [b]
- holesOf :: forall p s t a. Conjoined p => Over p (Bazaar p a a) s t a a -> s -> [Pretext p a a t]
- singular :: (Conjoined p, Functor f) => Traversing p f s t a a -> Over p f s t a a
- unsafeSingular :: (Conjoined p, Functor f) => Traversing p f s t a b -> Over p f s t a b
- class (Functor t, Foldable t) => Traversable t where
- class (Foldable1 t, Traversable t) => Traversable1 t where
- both :: Bitraversable r => Traversal (r a a) (r b b) a b
- both1 :: Bitraversable1 r => Traversal1 (r a a) (r b b) a b
- beside :: (Representable q, Applicative (Rep q), Applicative f, Bitraversable r) => Optical p q f s t a b -> Optical p q f s' t' a b -> Optical p q f (r s s') (r t t') a b
- taking :: (Conjoined p, Applicative f) => Int -> Traversing p f s t a a -> Over p f s t a a
- dropping :: (Conjoined p, Applicative f) => Int -> Over p (Indexing f) s t a a -> Over p f s t a a
- failing :: (Conjoined p, Applicative f) => Traversing p f s t a b -> Over p f s t a b -> Over p f s t a b
- deepOf :: (Conjoined p, Applicative f) => LensLike f s t s t -> Traversing p f s t a b -> Over p f s t a b
- ignored :: Applicative f => pafb -> s -> f s
- class Ord k => TraverseMin k m | m -> k where
- class Ord k => TraverseMax k m | m -> k where
- traversed :: Traversable f => IndexedTraversal Int (f a) (f b) a b
- traversed1 :: Traversable1 f => IndexedTraversal1 Int (f a) (f b) a b
- traversed64 :: Traversable f => IndexedTraversal Int64 (f a) (f b) a b
- elementOf :: Applicative f => LensLike (Indexing f) s t a a -> Int -> IndexedLensLike Int f s t a a
- element :: Traversable t => Int -> IndexedTraversal' Int (t a) a
- elementsOf :: Applicative f => LensLike (Indexing f) s t a a -> (Int -> Bool) -> IndexedLensLike Int f s t a a
- elements :: Traversable t => (Int -> Bool) -> IndexedTraversal' Int (t a) a
- ipartsOf :: forall i p f s t a. (Indexable [i] p, Functor f) => Traversing (Indexed i) f s t a a -> Over p f s t [a] [a]
- ipartsOf' :: forall i p f s t a. (Indexable [i] p, Functor f) => Over (Indexed i) (Bazaar' (Indexed i) a) s t a a -> Over p f s t [a] [a]
- iunsafePartsOf :: forall i p f s t a b. (Indexable [i] p, Functor f) => Traversing (Indexed i) f s t a b -> Over p f s t [a] [b]
- iunsafePartsOf' :: forall i s t a b. Over (Indexed i) (Bazaar (Indexed i) a b) s t a b -> IndexedLens [i] s t [a] [b]
- itraverseOf :: (Indexed i a (f b) -> s -> f t) -> (i -> a -> f b) -> s -> f t
- iforOf :: (Indexed i a (f b) -> s -> f t) -> s -> (i -> a -> f b) -> f t
- imapMOf :: Over (Indexed i) (WrappedMonad m) s t a b -> (i -> a -> m b) -> s -> m t
- iforMOf :: (Indexed i a (WrappedMonad m b) -> s -> WrappedMonad m t) -> s -> (i -> a -> m b) -> m t
- imapAccumROf :: Over (Indexed i) (Backwards (State acc)) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
- imapAccumLOf :: Over (Indexed i) (State acc) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
- traverseBy :: Traversable t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (a -> f b) -> t a -> f (t b)
- traverseByOf :: Traversal s t a b -> (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (a -> f b) -> s -> f t
- sequenceBy :: Traversable t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> t (f a) -> f (t a)
- sequenceByOf :: Traversal s t (f b) b -> (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> s -> f t
- newtype Bazaar p a b t = Bazaar {
  - runBazaar :: forall f. Applicative f => p a (f b) -> f t
  }
- type Bazaar' p a = Bazaar p a a
- newtype Bazaar1 p a b t = Bazaar1 {
  - runBazaar1 :: forall f. Apply f => p a (f b) -> f t
  }
- type Bazaar1' p a = Bazaar1 p a a
- loci :: Traversal (Bazaar (->) a c s) (Bazaar (->) b c s) a b
- iloci :: IndexedTraversal i (Bazaar (Indexed i) a c s) (Bazaar (Indexed i) b c s) a b
- confusing :: Applicative f => LensLike (Curried (Yoneda f) (Yoneda f)) s t a b -> LensLike f s t a b

# Traversals

type Traversal s t a b = forall f. Applicative f => (a -> f b) -> s -> f t #

A `Traversal` can be used directly as a `Setter` or a `Fold` (but not as a `Lens`) and provides the ability to both read and update multiple fields, subject to some relatively weak `Traversal` laws.

These have also been known as multilenses, but they have the signature and spirit of

    traverse :: Traversable f => Traversal (f a) (f b) a b

and the more evocative name suggests their application.

Most of the time the `Traversal` you will want to use is just `traverse`, but you can also pass any `Lens` or `Iso` as a `Traversal`, and composition of a `Traversal` (or `Lens` or `Iso`) with a `Traversal` (or `Lens` or `Iso`) using (`.`) forms a valid `Traversal`.

The laws for a `Traversal` `t` follow from the laws for `Traversable` as stated in "The Essence of the Iterator Pattern".

    t pure ≡ pure
    fmap (t f) . t g ≡ getCompose . t (Compose . fmap f . g)

One consequence of this requirement is that a `Traversal` needs to leave the same number of elements as a candidate for subsequent `Traversal` that it started with. Another testament to the strength of these laws is that the caveat expressed in section 5.5 of the "Essence of the Iterator Pattern" about exotic `Traversable` instances that `traverse` the same entry multiple times was actually already ruled out by the second law in that same paper!

type Traversal' s a = Traversal s s a a #

    type Traversal' = Simple Traversal

type Traversal1 s t a b = forall f. Apply f => (a -> f b) -> s -> f t #

type Traversal1' s a = Traversal1 s s a a #

type IndexedTraversal i s t a b = forall p f. (Indexable i p, Applicative f) => p a (f b) -> s -> f t #

Every `IndexedTraversal` is a valid `Traversal` or `IndexedFold`.

The `Indexed` constraint is used to allow an `IndexedTraversal` to be used directly as a `Traversal`.

The `Traversal` laws are still required to hold.

In addition, the index `i` should satisfy the requirement that it stays unchanged even when modifying the value `a`, otherwise traversals like `indices` break the `Traversal` laws.

type IndexedTraversal' i s a = IndexedTraversal i s s a a #

    type IndexedTraversal' i = Simple (IndexedTraversal i)

type IndexedTraversal1 i s t a b = forall p f. (Indexable i p, Apply f) => p a (f b) -> s -> f t #

type IndexedTraversal1' i s a = IndexedTraversal1 i s s a a #

type ATraversal s t a b = LensLike (Bazaar (->) a b) s t a b #

When you see this as an argument to a function, it expects a `Traversal`.

type ATraversal' s a = ATraversal s s a a #

    type ATraversal' = Simple ATraversal

type ATraversal1 s t a b = LensLike (Bazaar1 (->) a b) s t a b #

When you see this as an argument to a function, it expects a `Traversal1`.

type ATraversal1' s a = ATraversal1 s s a a #

    type ATraversal1' = Simple ATraversal1

type AnIndexedTraversal i s t a b = Over (Indexed i) (Bazaar (Indexed i) a b) s t a b #

When you see this as an argument to a function, it expects an `IndexedTraversal`.

type AnIndexedTraversal' i s a = AnIndexedTraversal i s s a a #

    type AnIndexedTraversal' = Simple (AnIndexedTraversal i)

type AnIndexedTraversal1 i s t a b = Over (Indexed i) (Bazaar1 (Indexed i) a b) s t a b #

When you see this as an argument to a function, it expects an `IndexedTraversal1`.

type AnIndexedTraversal1' i s a = AnIndexedTraversal1 i s s a a #

    type AnIndexedTraversal1' = Simple (AnIndexedTraversal1 i)

type Traversing p f s t a b = Over p (BazaarT p f a b) s t a b #

When you see this as an argument to a function, it expects

- to be indexed if `p` is an instance of `Indexed` i,
- to be unindexed if `p` is `(->)`,
- a `Traversal` if `f` is `Applicative`,
- a `Getter` if `f` is only a `Functor` and `Contravariant`,
- a `Lens` if `p` is only a `Functor`,
- a `Fold` if `f` is `Functor`, `Contravariant` and `Applicative`.

type Traversing' p f s a = Traversing p f s s a a #

    type Traversing' f = Simple (Traversing f)

type Traversing1 p f s t a b = Over p (BazaarT1 p f a b) s t a b #

type Traversing1' p f s a = Traversing1 p f s s a a #

# Traversing and Lensing

traverseOf :: LensLike f s t a b -> (a -> f b) -> s -> f t #

Map each element of a structure targeted by a `Lens` or `Traversal`, evaluate these actions from left to right, and collect the results.

This function is only provided for consistency, `id` is strictly more general.

    >>> traverseOf each print (1,2,3)
    1
    2
    3
    ((),(),())

    traverseOf ≡ id
    itraverseOf l ≡ traverseOf l . Indexed
    itraverseOf itraversed ≡ itraverse

This yields the obvious law:

    traverse ≡ traverseOf traverse

    traverseOf :: Functor f     => Iso s t a b        -> (a -> f b) -> s -> f t
    traverseOf :: Functor f     => Lens s t a b       -> (a -> f b) -> s -> f t
    traverseOf :: Apply f       => Traversal1 s t a b -> (a -> f b) -> s -> f t
    traverseOf :: Applicative f => Traversal s t a b  -> (a -> f b) -> s -> f t

forOf :: LensLike f s t a b -> s -> (a -> f b) -> f t #

A version of `traverseOf` with the arguments flipped, such that:

    >>> forOf each (1,2,3) print
    1
    2
    3
    ((),(),())

This function is only provided for consistency, `flip` is strictly more general.

    forOf ≡ flip
    forOf ≡ flip . traverseOf

    for ≡ forOf traverse
    ifor l s ≡ for l s . Indexed

    forOf :: Functor f => Iso s t a b -> s -> (a -> f b) -> f t
    forOf :: Functor f => Lens s t a b -> s -> (a -> f b) -> f t
    forOf :: Applicative f => Traversal s t a b -> s -> (a -> f b) -> f t

sequenceAOf :: LensLike f s t (f b) b -> s -> f t #

Evaluate each action in the structure from left to right, and collect the results.

    >>> sequenceAOf both ([1,2],[3,4])
    [(1,3),(1,4),(2,3),(2,4)]

    sequenceA ≡ sequenceAOf traverse ≡ traverse id
    sequenceAOf l ≡ traverseOf l id ≡ l id

    sequenceAOf :: Functor f => Iso s t (f b) b       -> s -> f t
    sequenceAOf :: Functor f => Lens s t (f b) b      -> s -> f t
    sequenceAOf :: Applicative f => Traversal s t (f b) b -> s -> f t

mapMOf :: LensLike (WrappedMonad m) s t a b -> (a -> m b) -> s -> m t #

Map each element of a structure targeted by a `Lens` to a monadic action, evaluate these actions from left to right, and collect the results.

    >>> mapMOf both (\x -> [x, x + 1]) (1,3)
    [(1,3),(1,4),(2,3),(2,4)]

    mapM ≡ mapMOf traverse
    imapMOf l ≡ forM l . Indexed

    mapMOf :: Monad m => Iso s t a b       -> (a -> m b) -> s -> m t
    mapMOf :: Monad m => Lens s t a b      -> (a -> m b) -> s -> m t
    mapMOf :: Monad m => Traversal s t a b -> (a -> m b) -> s -> m t

forMOf :: LensLike (WrappedMonad m) s t a b -> s -> (a -> m b) -> m t #

`forMOf` is a flipped version of `mapMOf`, consistent with the definition of `forM`.

    >>> forMOf both (1,3) $ \x -> [x, x + 1]
    [(1,3),(1,4),(2,3),(2,4)]

    forM ≡ forMOf traverse
    forMOf l ≡ flip (mapMOf l)
    iforMOf l s ≡ forM l s . Indexed

    forMOf :: Monad m => Iso s t a b       -> s -> (a -> m b) -> m t
    forMOf :: Monad m => Lens s t a b      -> s -> (a -> m b) -> m t
    forMOf :: Monad m => Traversal s t a b -> s -> (a -> m b) -> m t

sequenceOf :: LensLike (WrappedMonad m) s t (m b) b -> s -> m t #

Sequence the (monadic) effects targeted by a `Lens` in a container from left to right.

    >>> sequenceOf each ([1,2],[3,4],[5,6])
    [(1,3,5),(1,3,6),(1,4,5),(1,4,6),(2,3,5),(2,3,6),(2,4,5),(2,4,6)]

    sequence ≡ sequenceOf traverse
    sequenceOf l ≡ mapMOf l id
    sequenceOf l ≡ unwrapMonad . l WrapMonad

    sequenceOf :: Monad m => Iso s t (m b) b       -> s -> m t
    sequenceOf :: Monad m => Lens s t (m b) b      -> s -> m t
    sequenceOf :: Monad m => Traversal s t (m b) b -> s -> m t

transposeOf :: LensLike ZipList s t [a] a -> s -> [t] #

This generalizes `transpose` to an arbitrary `Traversal`.

Note: `transpose` handles ragged inputs more intelligently, but for non-ragged inputs:

    >>> transposeOf traverse [[1,2,3],[4,5,6]]
    [[1,4],[2,5],[3,6]]

    transpose ≡ transposeOf traverse

Since every `Lens` is a `Traversal`, we can use this as a form of monadic strength as well:

    transposeOf _2 :: (b, [a]) -> [(b, a)]

mapAccumLOf :: LensLike (State acc) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t) #

This generalizes `mapAccumL` to an arbitrary `Traversal`.

    mapAccumL ≡ mapAccumLOf traverse

`mapAccumLOf` accumulates `State` from left to right.

    mapAccumLOf :: Iso s t a b       -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
    mapAccumLOf :: Lens s t a b      -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
    mapAccumLOf :: Traversal s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)

    mapAccumLOf :: LensLike (State acc) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
    mapAccumLOf l f acc0 s = swap (runState (l (a -> state (acc -> swap (f acc a))) s) acc0)

mapAccumROf :: LensLike (Backwards (State acc)) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t) #

This generalizes `mapAccumR` to an arbitrary `Traversal`.

    mapAccumR ≡ mapAccumROf traverse

`mapAccumROf` accumulates `State` from right to left.

    mapAccumROf :: Iso s t a b       -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
    mapAccumROf :: Lens s t a b      -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
    mapAccumROf :: Traversal s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)

    mapAccumROf :: LensLike (Backwards (State acc)) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)

scanr1Of :: LensLike (Backwards (State (Maybe a))) s t a a -> (a -> a -> a) -> s -> t #

This permits the use of `scanr1` over an arbitrary `Traversal` or `Lens`.

    scanr1 ≡ scanr1Of traverse

    scanr1Of :: Iso s t a a       -> (a -> a -> a) -> s -> t
    scanr1Of :: Lens s t a a      -> (a -> a -> a) -> s -> t
    scanr1Of :: Traversal s t a a -> (a -> a -> a) -> s -> t

scanl1Of :: LensLike (State (Maybe a)) s t a a -> (a -> a -> a) -> s -> t #

This permits the use of `scanl1` over an arbitrary `Traversal` or `Lens`.

    scanl1 ≡ scanl1Of traverse

    scanl1Of :: Iso s t a a       -> (a -> a -> a) -> s -> t
    scanl1Of :: Lens s t a a      -> (a -> a -> a) -> s -> t
    scanl1Of :: Traversal s t a a -> (a -> a -> a) -> s -> t

failover :: Alternative m => LensLike ((,) Any) s t a b -> (a -> b) -> s -> m t #

Try to map a function over this `Traversal`, failing if the `Traversal` has no targets.

    >>> failover (element 3) (*2) [1,2] :: Maybe [Int]
    Nothing

    >>> failover _Left (*2) (Right 4) :: Maybe (Either Int Int)
    Nothing

    >>> failover _Right (*2) (Right 4) :: Maybe (Either Int Int)
    Just (Right 8)

    failover :: Alternative m => Traversal s t a b -> (a -> b) -> s -> m t

ifailover :: Alternative m => Over (Indexed i) ((,) Any) s t a b -> (i -> a -> b) -> s -> m t #

Try to map a function which uses the index over this `IndexedTraversal`, failing if the `IndexedTraversal` has no targets.

    ifailover :: Alternative m => IndexedTraversal i s t a b -> (i -> a -> b) -> s -> m t

# Monomorphic Traversals

cloneTraversal :: ATraversal s t a b -> Traversal s t a b #

A `Traversal` is completely characterized by its behavior on a `Bazaar`.

Cloning a `Traversal` is one way to make sure you aren't given something weaker, such as a `Fold` and can be used as a way to pass around traversals that have to be monomorphic in `f`.

Note: This only accepts a proper `Traversal` (or `Lens`). To clone a `Lens` as such, use `cloneLens`.

Note: It is usually better to use `ReifiedTraversal` and `runTraversal` than to `cloneTraversal`. The former can execute at full speed, while the latter needs to round trip through the `Bazaar`.

    >>> let foo l a = (view (getting (cloneTraversal l)) a, set (cloneTraversal l) 10 a)
    >>> foo both ("hello","world")
    ("helloworld",(10,10))

    cloneTraversal :: LensLike (Bazaar (->) a b) s t a b -> Traversal s t a b

cloneIndexPreservingTraversal :: ATraversal s t a b -> IndexPreservingTraversal s t a b #

Clone a `Traversal` yielding an `IndexPreservingTraversal` that passes through whatever index it is composed with.

cloneIndexedTraversal :: AnIndexedTraversal i s t a b -> IndexedTraversal i s t a b #

Clone an `IndexedTraversal` yielding an `IndexedTraversal` with the same index.

cloneTraversal1 :: ATraversal1 s t a b -> Traversal1 s t a b #

A `Traversal1` is completely characterized by its behavior on a `Bazaar1`.

cloneIndexPreservingTraversal1 :: ATraversal1 s t a b -> IndexPreservingTraversal1 s t a b #

Clone a `Traversal1` yielding an `IndexPreservingTraversal1` that passes through whatever index it is composed with.

cloneIndexedTraversal1 :: AnIndexedTraversal1 i s t a b -> IndexedTraversal1 i s t a b #

Clone an `IndexedTraversal1` yielding an `IndexedTraversal1` with the same index.

# Parts and Holes

partsOf :: Functor f => Traversing (->) f s t a a -> LensLike f s t [a] [a] #

`partsOf` turns a `Traversal` into a `Lens` that resembles an early version of the `uniplate` (or `biplate`) type.

Note: You should really try to maintain the invariant of the number of children in the list.

    >>> (a,b,c) & partsOf each .~ [x,y,z]
    (x,y,z)

Any extras will be lost. If you do not supply enough, then the remainder will come from the original structure.

    >>> (a,b,c) & partsOf each .~ [w,x,y,z]
    (w,x,y)

    >>> (a,b,c) & partsOf each .~ [x,y]
    (x,y,c)

    >>> ('b', 'a', 'd', 'c') & partsOf each %~ sort
    ('a','b','c','d')

So technically, this is only a `Lens` if you do not change the number of results it returns.

When applied to a `Fold` the result is merely a `Getter`.

    partsOf :: Iso' s a       -> Lens' s [a]
    partsOf :: Lens' s a      -> Lens' s [a]
    partsOf :: Traversal' s a -> Lens' s [a]
    partsOf :: Fold s a       -> Getter s [a]
    partsOf :: Getter s a     -> Getter s [a]

partsOf' :: ATraversal s t a a -> Lens s t [a] [a] #

A type-restricted version of `partsOf` that can only be used with a `Traversal`.

unsafePartsOf :: Functor f => Traversing (->) f s t a b -> LensLike f s t [a] [b] #

`unsafePartsOf` turns a `Traversal` into a `uniplate` (or `biplate`) family.

If you do not need the types of `s` and `t` to be different, it is recommended that you use `partsOf`.

It is generally safer to traverse with the `Bazaar` rather than use this combinator. However, it is sometimes convenient.

This is unsafe because if you don't supply at least as many `b`'s as you were given `a`'s, then the reconstruction of `t` will result in an error!

When applied to a `Fold` the result is merely a `Getter` (and becomes safe).

    unsafePartsOf :: Iso s t a b       -> Lens s t [a] [b]
    unsafePartsOf :: Lens s t a b      -> Lens s t [a] [b]
    unsafePartsOf :: Traversal s t a b -> Lens s t [a] [b]
    unsafePartsOf :: Fold s a          -> Getter s [a]
    unsafePartsOf :: Getter s a        -> Getter s [a]

unsafePartsOf' :: ATraversal s t a b -> Lens s t [a] [b] #

holesOf :: forall p s t a. Conjoined p => Over p (Bazaar p a a) s t a a -> s -> [Pretext p a a t] #

The one-level version of `contextsOf`. This extracts a list of the immediate children according to a given `Traversal` as editable contexts.

Given a context you can use `pos` to see the values, `peek` at what the structure would be like with an edited result, or simply `extract` the original structure.

    propChildren l x = childrenOf l x == map pos (holesOf l x)
    propId l x = all (== x) [extract w | w <- holesOf l x]

    holesOf :: Iso' s a                -> s -> [Pretext' (->) a s]
    holesOf :: Lens' s a               -> s -> [Pretext' (->) a s]
    holesOf :: Traversal' s a          -> s -> [Pretext' (->) a s]
    holesOf :: IndexedLens' i s a      -> s -> [Pretext' (Indexed i) a s]
    holesOf :: IndexedTraversal' i s a -> s -> [Pretext' (Indexed i) a s]

singular :: (Conjoined p, Functor f) => Traversing p f s t a a -> Over p f s t a a #

This converts a `Traversal` that you "know" will target one or more elements to a `Lens`. It can also be used to transform a non-empty `Fold` into a `Getter`.

The resulting `Lens` or `Getter` will be partial if the supplied `Traversal` returns no results.

    >>> [1,2,3] ^. singular _head
    1

    >>> Left (ErrorCall "singular: empty traversal") <- try (evaluate ([] ^. singular _head)) :: IO (Either ErrorCall ())

    >>> Left 4 ^. singular _Left
    4

    >>> [1..10] ^. singular (ix 7)
    8

    >>> [] & singular traverse .~ 0
    []

    singular :: Traversal s t a a          -> Lens s t a a
    singular :: Fold s a                   -> Getter s a
    singular :: IndexedTraversal i s t a a -> IndexedLens i s t a a
    singular :: IndexedFold i s a          -> IndexedGetter i s a

unsafeSingular :: (Conjoined p, Functor f) => Traversing p f s t a b -> Over p f s t a b #

This converts a `Traversal` that you "know" will target only one element to a `Lens`. It can also be used to transform a `Fold` into a `Getter`.

The resulting `Lens` or `Getter` will be partial if the `Traversal` targets nothing or more than one element.

    >>> Left (ErrorCall "unsafeSingular: empty traversal") <- try (evaluate ([] & unsafeSingular traverse .~ 0)) :: IO (Either ErrorCall [Integer])

    unsafeSingular :: Traversal s t a b          -> Lens s t a b
    unsafeSingular :: Fold s a                   -> Getter s a
    unsafeSingular :: IndexedTraversal i s t a b -> IndexedLens i s t a b
    unsafeSingular :: IndexedFold i s a          -> IndexedGetter i s a

# Common Traversals

class (Functor t, Foldable t) => Traversable t where #

Functors representing data structures that can be traversed from left to right.

A definition of `traverse` must satisfy the following laws:

naturality
  `t . `traverse` f = `traverse` (t . f)` for every applicative transformation `t`
identity
  ``traverse` Identity = Identity`
composition
  ``traverse` (Compose . `fmap` g . f) = Compose . `fmap` (`traverse` g) . `traverse` f`

A definition of `sequenceA` must satisfy the following laws:

naturality
  `t . `sequenceA` = `sequenceA` . `fmap` t` for every applicative transformation `t`
identity
  ``sequenceA` . `fmap` Identity = Identity`
composition
  ``sequenceA` . `fmap` Compose = Compose . `fmap` `sequenceA` . `sequenceA``

where an applicative transformation is a function

    t :: (Applicative f, Applicative g) => f a -> g a

preserving the `Applicative` operations, i.e.

-     t (pure x) = pure x

-     t (x <*> y) = t x <*> t y

and the identity functor `Identity` and composition of functors `Compose` are defined as

      newtype Identity a = Identity a

      instance Functor Identity where
        fmap f (Identity x) = Identity (f x)

      instance Applicative Identity where
        pure x = Identity x
        Identity f <*> Identity x = Identity (f x)

      newtype Compose f g a = Compose (f (g a))

      instance (Functor f, Functor g) => Functor (Compose f g) where
        fmap f (Compose x) = Compose (fmap (fmap f) x)

      instance (Applicative f, Applicative g) => Applicative (Compose f g) where
        pure x = Compose (pure (pure x))
        Compose f <*> Compose x = Compose ((<*>) <$> f <*> x)

(The naturality law is implied by parametricity.)

Instances are similar to `Functor`, e.g. given a data type

    data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

a suitable instance would be

    instance Traversable Tree where
       traverse f Empty = pure Empty
       traverse f (Leaf x) = Leaf <$> f x
       traverse f (Node l k r) = Node <$> traverse f l <*> f k <*> traverse f r

This is suitable even for abstract types, as the laws for `<*>` imply a form of associativity.

The superclass instances should satisfy the following:

- In the `Functor` instance, `fmap` should be equivalent to traversal with the identity applicative functor (`fmapDefault`).
- In the `Foldable` instance, `foldMap` should be equivalent to traversal with a constant applicative functor (`foldMapDefault`).

Minimal complete definition

traverse | sequenceA

Methods

traverse :: Applicative f => (a -> f b) -> t a -> f (t b) #

Map each element of a structure to an action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see `traverse_`.

Instances

Traversable [] |
Methods traverse :: Applicative f => (a -> f b) -> [a] -> f [b] # sequenceA :: Applicative f => [f a] -> f [a] # mapM :: Monad m => (a -> m b) -> [a] -> m [b] # sequence :: Monad m => [m a] -> m [a] #
Traversable Maybe |
Methods traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) # sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a) # mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) # sequence :: Monad m => Maybe (m a) -> m (Maybe a) #
Traversable V1 |
Methods traverse :: Applicative f => (a -> f b) -> V1 a -> f (V1 b) # sequenceA :: Applicative f => V1 (f a) -> f (V1 a) # mapM :: Monad m => (a -> m b) -> V1 a -> m (V1 b) # sequence :: Monad m => V1 (m a) -> m (V1 a) #
Traversable U1 |
Methods traverse :: Applicative f => (a -> f b) -> U1 a -> f (U1 b) # sequenceA :: Applicative f => U1 (f a) -> f (U1 a) # mapM :: Monad m => (a -> m b) -> U1 a -> m (U1 b) # sequence :: Monad m => U1 (m a) -> m (U1 a) #
Traversable Par1 |
Methods traverse :: Applicative f => (a -> f b) -> Par1 a -> f (Par1 b) # sequenceA :: Applicative f => Par1 (f a) -> f (Par1 a) # mapM :: Monad m => (a -> m b) -> Par1 a -> m (Par1 b) # sequence :: Monad m => Par1 (m a) -> m (Par1 a) #
Traversable Identity |
Methods traverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b) # sequenceA :: Applicative f => Identity (f a) -> f (Identity a) # mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b) # sequence :: Monad m => Identity (m a) -> m (Identity a) #
Traversable Min |
Methods traverse :: Applicative f => (a -> f b) -> Min a -> f (Min b) # sequenceA :: Applicative f => Min (f a) -> f (Min a) # mapM :: Monad m => (a -> m b) -> Min a -> m (Min b) # sequence :: Monad m => Min (m a) -> m (Min a) #
Traversable Max |
Methods traverse :: Applicative f => (a -> f b) -> Max a -> f (Max b) # sequenceA :: Applicative f => Max (f a) -> f (Max a) # mapM :: Monad m => (a -> m b) -> Max a -> m (Max b) # sequence :: Monad m => Max (m a) -> m (Max a) #
Traversable First |
Methods traverse :: Applicative f => (a -> f b) -> First a -> f (First b) # sequenceA :: Applicative f => First (f a) -> f (First a) # mapM :: Monad m => (a -> m b) -> First a -> m (First b) # sequence :: Monad m => First (m a) -> m (First a) #
Traversable Last |
Methods traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) # sequenceA :: Applicative f => Last (f a) -> f (Last a) # mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) # sequence :: Monad m => Last (m a) -> m (Last a) #
Traversable Option |
Methods traverse :: Applicative f => (a -> f b) -> Option a -> f (Option b) # sequenceA :: Applicative f => Option (f a) -> f (Option a) # mapM :: Monad m => (a -> m b) -> Option a -> m (Option b) # sequence :: Monad m => Option (m a) -> m (Option a) #
Traversable NonEmpty |
Methods traverse :: Applicative f => (a -> f b) -> NonEmpty a -> f (NonEmpty b) # sequenceA :: Applicative f => NonEmpty (f a) -> f (NonEmpty a) # mapM :: Monad m => (a -> m b) -> NonEmpty a -> m (NonEmpty b) # sequence :: Monad m => NonEmpty (m a) -> m (NonEmpty a) #
Traversable Complex |
Methods traverse :: Applicative f => (a -> f b) -> Complex a -> f (Complex b) # sequenceA :: Applicative f => Complex (f a) -> f (Complex a) # mapM :: Monad m => (a -> m b) -> Complex a -> m (Complex b) # sequence :: Monad m => Complex (m a) -> m (Complex a) #
Traversable ZipList |
Methods traverse :: Applicative f => (a -> f b) -> ZipList a -> f (ZipList b) # sequenceA :: Applicative f => ZipList (f a) -> f (ZipList a) # mapM :: Monad m => (a -> m b) -> ZipList a -> m (ZipList b) # sequence :: Monad m => ZipList (m a) -> m (ZipList a) #
Traversable Dual |
Methods traverse :: Applicative f => (a -> f b) -> Dual a -> f (Dual b) # sequenceA :: Applicative f => Dual (f a) -> f (Dual a) # mapM :: Monad m => (a -> m b) -> Dual a -> m (Dual b) # sequence :: Monad m => Dual (m a) -> m (Dual a) #
Traversable Sum |
Methods traverse :: Applicative f => (a -> f b) -> Sum a -> f (Sum b) # sequenceA :: Applicative f => Sum (f a) -> f (Sum a) # mapM :: Monad m => (a -> m b) -> Sum a -> m (Sum b) # sequence :: Monad m => Sum (m a) -> m (Sum a) #
Traversable Product |
Methods traverse :: Applicative f => (a -> f b) -> Product a -> f (Product b) # sequenceA :: Applicative f => Product (f a) -> f (Product a) # mapM :: Monad m => (a -> m b) -> Product a -> m (Product b) # sequence :: Monad m => Product (m a) -> m (Product a) #
Traversable First |
Methods traverse :: Applicative f => (a -> f b) -> First a -> f (First b) # sequenceA :: Applicative f => First (f a) -> f (First a) # mapM :: Monad m => (a -> m b) -> First a -> m (First b) # sequence :: Monad m => First (m a) -> m (First a) #
Traversable Last |
Methods traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) # sequenceA :: Applicative f => Last (f a) -> f (Last a) # mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) # sequence :: Monad m => Last (m a) -> m (Last a) #
Traversable Digit |
Methods traverse :: Applicative f => (a -> f b) -> Digit a -> f (Digit b) # sequenceA :: Applicative f => Digit (f a) -> f (Digit a) # mapM :: Monad m => (a -> m b) -> Digit a -> m (Digit b) # sequence :: Monad m => Digit (m a) -> m (Digit a) #
Traversable Node |
Methods traverse :: Applicative f => (a -> f b) -> Node a -> f (Node b) # sequenceA :: Applicative f => Node (f a) -> f (Node a) # mapM :: Monad m => (a -> m b) -> Node a -> m (Node b) # sequence :: Monad m => Node (m a) -> m (Node a) #
Traversable Elem |
Methods traverse :: Applicative f => (a -> f b) -> Elem a -> f (Elem b) # sequenceA :: Applicative f => Elem (f a) -> f (Elem a) # mapM :: Monad m => (a -> m b) -> Elem a -> m (Elem b) # sequence :: Monad m => Elem (m a) -> m (Elem a) #
Traversable FingerTree |
Methods traverse :: Applicative f => (a -> f b) -> FingerTree a -> f (FingerTree b) # sequenceA :: Applicative f => FingerTree (f a) -> f (FingerTree a) # mapM :: Monad m => (a -> m b) -> FingerTree a -> m (FingerTree b) # sequence :: Monad m => FingerTree (m a) -> m (FingerTree a) #
Traversable IntMap |
Methods traverse :: Applicative f => (a -> f b) -> IntMap a -> f (IntMap b) # sequenceA :: Applicative f => IntMap (f a) -> f (IntMap a) # mapM :: Monad m => (a -> m b) -> IntMap a -> m (IntMap b) # sequence :: Monad m => IntMap (m a) -> m (IntMap a) #
Traversable Tree |
Methods traverse :: Applicative f => (a -> f b) -> Tree a -> f (Tree b) # sequenceA :: Applicative f => Tree (f a) -> f (Tree a) # mapM :: Monad m => (a -> m b) -> Tree a -> m (Tree b) # sequence :: Monad m => Tree (m a) -> m (Tree a) #
Traversable Seq |
Methods traverse :: Applicative f => (a -> f b) -> Seq a -> f (Seq b) # sequenceA :: Applicative f => Seq (f a) -> f (Seq a) # mapM :: Monad m => (a -> m b) -> Seq a -> m (Seq b) # sequence :: Monad m => Seq (m a) -> m (Seq a) #
Traversable ViewL |
Methods traverse :: Applicative f => (a -> f b) -> ViewL a -> f (ViewL b) # sequenceA :: Applicative f => ViewL (f a) -> f (ViewL a) # mapM :: Monad m => (a -> m b) -> ViewL a -> m (ViewL b) # sequence :: Monad m => ViewL (m a) -> m (ViewL a) #
Traversable ViewR |
Methods traverse :: Applicative f => (a -> f b) -> ViewR a -> f (ViewR b) # sequenceA :: Applicative f => ViewR (f a) -> f (ViewR a) # mapM :: Monad m => (a -> m b) -> ViewR a -> m (ViewR b) # sequence :: Monad m => ViewR (m a) -> m (ViewR a) #
Traversable Array |
Methods traverse :: Applicative f => (a -> f b) -> Array a -> f (Array b) # sequenceA :: Applicative f => Array (f a) -> f (Array a) # mapM :: Monad m => (a -> m b) -> Array a -> m (Array b) # sequence :: Monad m => Array (m a) -> m (Array a) #
Traversable Vector |
Methods traverse :: Applicative f => (a -> f b) -> Vector a -> f (Vector b) # sequenceA :: Applicative f => Vector (f a) -> f (Vector a) # mapM :: Monad m => (a -> m b) -> Vector a -> m (Vector b) # sequence :: Monad m => Vector (m a) -> m (Vector a) #
Traversable Deque # |
Methods traverse :: Applicative f => (a -> f b) -> Deque a -> f (Deque b) # sequenceA :: Applicative f => Deque (f a) -> f (Deque a) # mapM :: Monad m => (a -> m b) -> Deque a -> m (Deque b) # sequence :: Monad m => Deque (m a) -> m (Deque a) #
Traversable (Either a) |
Methods traverse :: Applicative f => (a -> f b) -> Either a a -> f (Either a b) # sequenceA :: Applicative f => Either a (f a) -> f (Either a a) # mapM :: Monad m => (a -> m b) -> Either a a -> m (Either a b) # sequence :: Monad m => Either a (m a) -> m (Either a a) #
Traversable f => Traversable (Rec1 f) |
Methods traverse :: Applicative f => (a -> f b) -> Rec1 f a -> f (Rec1 f b) # sequenceA :: Applicative f => Rec1 f (f a) -> f (Rec1 f a) # mapM :: Monad m => (a -> m b) -> Rec1 f a -> m (Rec1 f b) # sequence :: Monad m => Rec1 f (m a) -> m (Rec1 f a) #
Traversable (URec Char) |
Methods traverse :: Applicative f => (a -> f b) -> URec Char a -> f (URec Char b) # sequenceA :: Applicative f => URec Char (f a) -> f (URec Char a) # mapM :: Monad m => (a -> m b) -> URec Char a -> m (URec Char b) # sequence :: Monad m => URec Char (m a) -> m (URec Char a) #
Traversable (URec Double) |
Methods traverse :: Applicative f => (a -> f b) -> URec Double a -> f (URec Double b) # sequenceA :: Applicative f => URec Double (f a) -> f (URec Double a) # mapM :: Monad m => (a -> m b) -> URec Double a -> m (URec Double b) # sequence :: Monad m => URec Double (m a) -> m (URec Double a) #
Traversable (URec Float) |
Methods traverse :: Applicative f => (a -> f b) -> URec Float a -> f (URec Float b) # sequenceA :: Applicative f => URec Float (f a) -> f (URec Float a) # mapM :: Monad m => (a -> m b) -> URec Float a -> m (URec Float b) # sequence :: Monad m => URec Float (m a) -> m (URec Float a) #
Traversable (URec Int) |
Methods traverse :: Applicative f => (a -> f b) -> URec Int a -> f (URec Int b) # sequenceA :: Applicative f => URec Int (f a) -> f (URec Int a) # mapM :: Monad m => (a -> m b) -> URec Int a -> m (URec Int b) # sequence :: Monad m => URec Int (m a) -> m (URec Int a) #
Traversable (URec Word) |
Methods traverse :: Applicative f => (a -> f b) -> URec Word a -> f (URec Word b) # sequenceA :: Applicative f => URec Word (f a) -> f (URec Word a) # mapM :: Monad m => (a -> m b) -> URec Word a -> m (URec Word b) # sequence :: Monad m => URec Word (m a) -> m (URec Word a) #
Traversable (URec (Ptr ())) |
Methods traverse :: Applicative f => (a -> f b) -> URec (Ptr ()) a -> f (URec (Ptr ()) b) # sequenceA :: Applicative f => URec (Ptr ()) (f a) -> f (URec (Ptr ()) a) # mapM :: Monad m => (a -> m b) -> URec (Ptr ()) a -> m (URec (Ptr ()) b) # sequence :: Monad m => URec (Ptr ()) (m a) -> m (URec (Ptr ()) a) #
Traversable ((,) a) |
Methods traverse :: Applicative f => (a -> f b) -> (a, a) -> f (a, b) # sequenceA :: Applicative f => (a, f a) -> f (a, a) # mapM :: Monad m => (a -> m b) -> (a, a) -> m (a, b) # sequence :: Monad m => (a, m a) -> m (a, a) #
Ix i => Traversable (Array i) |
Methods traverse :: Applicative f => (a -> f b) -> Array i a -> f (Array i b) # sequenceA :: Applicative f => Array i (f a) -> f (Array i a) # mapM :: Monad m => (a -> m b) -> Array i a -> m (Array i b) # sequence :: Monad m => Array i (m a) -> m (Array i a) #
Traversable (Arg a) |
Methods traverse :: Applicative f => (a -> f b) -> Arg a a -> f (Arg a b) # sequenceA :: Applicative f => Arg a (f a) -> f (Arg a a) # mapM :: Monad m => (a -> m b) -> Arg a a -> m (Arg a b) # sequence :: Monad m => Arg a (m a) -> m (Arg a a) #
Traversable (Proxy *) |
Methods traverse :: Applicative f => (a -> f b) -> Proxy * a -> f (Proxy * b) # sequenceA :: Applicative f => Proxy * (f a) -> f (Proxy * a) # mapM :: Monad m => (a -> m b) -> Proxy * a -> m (Proxy * b) # sequence :: Monad m => Proxy * (m a) -> m (Proxy * a) #
Traversable (Map k) |
Methods traverse :: Applicative f => (a -> f b) -> Map k a -> f (Map k b) # sequenceA :: Applicative f => Map k (f a) -> f (Map k a) # mapM :: Monad m => (a -> m b) -> Map k a -> m (Map k b) # sequence :: Monad m => Map k (m a) -> m (Map k a) #
(Monad m, Traversable m) => Traversable (CatchT m) |
Methods traverse :: Applicative f => (a -> f b) -> CatchT m a -> f (CatchT m b) # sequenceA :: Applicative f => CatchT m (f a) -> f (CatchT m a) # mapM :: Monad m => (a -> m b) -> CatchT m a -> m (CatchT m b) # sequence :: Monad m => CatchT m (m a) -> m (CatchT m a) #
Traversable f => Traversable (Cofree f) |
Methods traverse :: Applicative f => (a -> f b) -> Cofree f a -> f (Cofree f b) # sequenceA :: Applicative f => Cofree f (f a) -> f (Cofree f a) # mapM :: Monad m => (a -> m b) -> Cofree f a -> m (Cofree f b) # sequence :: Monad m => Cofree f (m a) -> m (Cofree f a) #
Traversable w => Traversable (CoiterT w) |
Methods traverse :: Applicative f => (a -> f b) -> CoiterT w a -> f (CoiterT w b) # sequenceA :: Applicative f => CoiterT w (f a) -> f (CoiterT w a) # mapM :: Monad m => (a -> m b) -> CoiterT w a -> m (CoiterT w b) # sequence :: Monad m => CoiterT w (m a) -> m (CoiterT w a) #
Traversable f => Traversable (Free f) |
Methods traverse :: Applicative f => (a -> f b) -> Free f a -> f (Free f b) # sequenceA :: Applicative f => Free f (f a) -> f (Free f a) # mapM :: Monad m => (a -> m b) -> Free f a -> m (Free f b) # sequence :: Monad m => Free f (m a) -> m (Free f a) #
(Monad m, Traversable m) => Traversable (IterT m) |
Methods traverse :: Applicative f => (a -> f b) -> IterT m a -> f (IterT m b) # sequenceA :: Applicative f => IterT m (f a) -> f (IterT m a) # mapM :: Monad m => (a -> m b) -> IterT m a -> m (IterT m b) # sequence :: Monad m => IterT m (m a) -> m (IterT m a) #
Traversable f => Traversable (Yoneda f) |
Methods traverse :: Applicative f => (a -> f b) -> Yoneda f a -> f (Yoneda f b) # sequenceA :: Applicative f => Yoneda f (f a) -> f (Yoneda f a) # mapM :: Monad m => (a -> m b) -> Yoneda f a -> m (Yoneda f b) # sequence :: Monad m => Yoneda f (m a) -> m (Yoneda f a) #
Traversable f => Traversable (ListT f) |
Methods traverse :: Applicative f => (a -> f b) -> ListT f a -> f (ListT f b) # sequenceA :: Applicative f => ListT f (f a) -> f (ListT f a) # mapM :: Monad m => (a -> m b) -> ListT f a -> m (ListT f b) # sequence :: Monad m => ListT f (m a) -> m (ListT f a) #
Traversable f => Traversable (Lift f) |
Methods traverse :: Applicative f => (a -> f b) -> Lift f a -> f (Lift f b) # sequenceA :: Applicative f => Lift f (f a) -> f (Lift f a) # mapM :: Monad m => (a -> m b) -> Lift f a -> m (Lift f b) # sequence :: Monad m => Lift f (m a) -> m (Lift f a) #
Traversable f => Traversable (MaybeT f) |
Methods traverse :: Applicative f => (a -> f b) -> MaybeT f a -> f (MaybeT f b) # sequenceA :: Applicative f => MaybeT f (f a) -> f (MaybeT f a) # mapM :: Monad m => (a -> m b) -> MaybeT f a -> m (MaybeT f b) # sequence :: Monad m => MaybeT f (m a) -> m (MaybeT f a) #
Traversable (HashMap k) |
Methods traverse :: Applicative f => (a -> f b) -> HashMap k a -> f (HashMap k b) # sequenceA :: Applicative f => HashMap k (f a) -> f (HashMap k a) # mapM :: Monad m => (a -> m b) -> HashMap k a -> m (HashMap k b) # sequence :: Monad m => HashMap k (m a) -> m (HashMap k a) #
Traversable (Level i) # |
Methods traverse :: Applicative f => (a -> f b) -> Level i a -> f (Level i b) # sequenceA :: Applicative f => Level i (f a) -> f (Level i a) # mapM :: Monad m => (a -> m b) -> Level i a -> m (Level i b) # sequence :: Monad m => Level i (m a) -> m (Level i a) #
Traversable (K1 i c) |
Methods traverse :: Applicative f => (a -> f b) -> K1 i c a -> f (K1 i c b) # sequenceA :: Applicative f => K1 i c (f a) -> f (K1 i c a) # mapM :: Monad m => (a -> m b) -> K1 i c a -> m (K1 i c b) # sequence :: Monad m => K1 i c (m a) -> m (K1 i c a) #
(Traversable f, Traversable g) => Traversable ((:+:) f g) |
Methods traverse :: Applicative f => (a -> f b) -> (f :+: g) a -> f ((f :+: g) b) # sequenceA :: Applicative f => (f :+: g) (f a) -> f ((f :+: g) a) # mapM :: Monad m => (a -> m b) -> (f :+: g) a -> m ((f :+: g) b) # sequence :: Monad m => (f :+: g) (m a) -> m ((f :+: g) a) #
(Traversable f, Traversable g) => Traversable ((:*:) f g) |
Methods traverse :: Applicative f => (a -> f b) -> (f :*: g) a -> f ((f :*: g) b) # sequenceA :: Applicative f => (f :*: g) (f a) -> f ((f :*: g) a) # mapM :: Monad m => (a -> m b) -> (f :*: g) a -> m ((f :*: g) b) # sequence :: Monad m => (f :*: g) (m a) -> m ((f :*: g) a) #
(Traversable f, Traversable g) => Traversable ((:.:) f g) |
Methods traverse :: Applicative f => (a -> f b) -> (f :.: g) a -> f ((f :.: g) b) # sequenceA :: Applicative f => (f :.: g) (f a) -> f ((f :.: g) a) # mapM :: Monad m => (a -> m b) -> (f :.: g) a -> m ((f :.: g) b) # sequence :: Monad m => (f :.: g) (m a) -> m ((f :.: g) a) #
Traversable (Const * m) |
Methods traverse :: Applicative f => (a -> f b) -> Const * m a -> f (Const * m b) # sequenceA :: Applicative f => Const * m (f a) -> f (Const * m a) # mapM :: Monad m => (a -> m b) -> Const * m a -> m (Const * m b) # sequence :: Monad m => Const * m (m a) -> m (Const * m a) #
Bitraversable p => Traversable (Join * p) |
Methods traverse :: Applicative f => (a -> f b) -> Join * p a -> f (Join * p b) # sequenceA :: Applicative f => Join * p (f a) -> f (Join * p a) # mapM :: Monad m => (a -> m b) -> Join * p a -> m (Join * p b) # sequence :: Monad m => Join * p (m a) -> m (Join * p a) #
Bitraversable p => Traversable (Fix * p) |
Methods traverse :: Applicative f => (a -> f b) -> Fix * p a -> f (Fix * p b) # sequenceA :: Applicative f => Fix * p (f a) -> f (Fix * p a) # mapM :: Monad m => (a -> m b) -> Fix * p a -> m (Fix * p b) # sequence :: Monad m => Fix * p (m a) -> m (Fix * p a) #
Traversable w => Traversable (EnvT e w) |
Methods traverse :: Applicative f => (a -> f b) -> EnvT e w a -> f (EnvT e w b) # sequenceA :: Applicative f => EnvT e w (f a) -> f (EnvT e w a) # mapM :: Monad m => (a -> m b) -> EnvT e w a -> m (EnvT e w b) # sequence :: Monad m => EnvT e w (m a) -> m (EnvT e w a) #
Traversable f => Traversable (IdentityT * f) |
Methods traverse :: Applicative f => (a -> f b) -> IdentityT * f a -> f (IdentityT * f b) # sequenceA :: Applicative f => IdentityT * f (f a) -> f (IdentityT * f a) # mapM :: Monad m => (a -> m b) -> IdentityT * f a -> m (IdentityT * f b) # sequence :: Monad m => IdentityT * f (m a) -> m (IdentityT * f a) #
Traversable f => Traversable (CofreeF f a) |
Methods traverse :: Applicative f => (a -> f b) -> CofreeF f a a -> f (CofreeF f a b) # sequenceA :: Applicative f => CofreeF f a (f a) -> f (CofreeF f a a) # mapM :: Monad m => (a -> m b) -> CofreeF f a a -> m (CofreeF f a b) # sequence :: Monad m => CofreeF f a (m a) -> m (CofreeF f a a) #
(Traversable f, Traversable w) => Traversable (CofreeT f w) |
Methods traverse :: Applicative f => (a -> f b) -> CofreeT f w a -> f (CofreeT f w b) # sequenceA :: Applicative f => CofreeT f w (f a) -> f (CofreeT f w a) # mapM :: Monad m => (a -> m b) -> CofreeT f w a -> m (CofreeT f w b) # sequence :: Monad m => CofreeT f w (m a) -> m (CofreeT f w a) #
Traversable f => Traversable (FreeF f a) |
Methods traverse :: Applicative f => (a -> f b) -> FreeF f a a -> f (FreeF f a b) # sequenceA :: Applicative f => FreeF f a (f a) -> f (FreeF f a a) # mapM :: Monad m => (a -> m b) -> FreeF f a a -> m (FreeF f a b) # sequence :: Monad m => FreeF f a (m a) -> m (FreeF f a a) #
(Monad m, Traversable m, Traversable f) => Traversable (FreeT f m) |
Methods traverse :: Applicative f => (a -> f b) -> FreeT f m a -> f (FreeT f m b) # sequenceA :: Applicative f => FreeT f m (f a) -> f (FreeT f m a) # mapM :: Monad m => (a -> m b) -> FreeT f m a -> m (FreeT f m b) # sequence :: Monad m => FreeT f m (m a) -> m (FreeT f m a) #
Traversable f => Traversable (ErrorT e f) |
Methods traverse :: Applicative f => (a -> f b) -> ErrorT e f a -> f (ErrorT e f b) # sequenceA :: Applicative f => ErrorT e f (f a) -> f (ErrorT e f a) # mapM :: Monad m => (a -> m b) -> ErrorT e f a -> m (ErrorT e f b) # sequence :: Monad m => ErrorT e f (m a) -> m (ErrorT e f a) #
Traversable f => Traversable (ExceptT e f) |
Methods traverse :: Applicative f => (a -> f b) -> ExceptT e f a -> f (ExceptT e f b) # sequenceA :: Applicative f => ExceptT e f (f a) -> f (ExceptT e f a) # mapM :: Monad m => (a -> m b) -> ExceptT e f a -> m (ExceptT e f b) # sequence :: Monad m => ExceptT e f (m a) -> m (ExceptT e f a) #
Traversable f => Traversable (WriterT w f) |
Methods traverse :: Applicative f => (a -> f b) -> WriterT w f a -> f (WriterT w f b) # sequenceA :: Applicative f => WriterT w f (f a) -> f (WriterT w f a) # mapM :: Monad m => (a -> m b) -> WriterT w f a -> m (WriterT w f b) # sequence :: Monad m => WriterT w f (m a) -> m (WriterT w f a) #
Traversable f => Traversable (WriterT w f) |
Methods traverse :: Applicative f => (a -> f b) -> WriterT w f a -> f (WriterT w f b) # sequenceA :: Applicative f => WriterT w f (f a) -> f (WriterT w f a) # mapM :: Monad m => (a -> m b) -> WriterT w f a -> m (WriterT w f b) # sequence :: Monad m => WriterT w f (m a) -> m (WriterT w f a) #
Traversable (Forget r a) |
Methods traverse :: Applicative f => (a -> f b) -> Forget r a a -> f (Forget r a b) # sequenceA :: Applicative f => Forget r a (f a) -> f (Forget r a a) # mapM :: Monad m => (a -> m b) -> Forget r a a -> m (Forget r a b) # sequence :: Monad m => Forget r a (m a) -> m (Forget r a a) #
Traversable (Tagged k s) |
Methods traverse :: Applicative f => (a -> f b) -> Tagged k s a -> f (Tagged k s b) # sequenceA :: Applicative f => Tagged k s (f a) -> f (Tagged k s a) # mapM :: Monad m => (a -> m b) -> Tagged k s a -> m (Tagged k s b) # sequence :: Monad m => Tagged k s (m a) -> m (Tagged k s a) #
Traversable f => Traversable (Reverse * f) | Traverse from right to left.
Methods traverse :: Applicative f => (a -> f b) -> Reverse * f a -> f (Reverse * f b) # sequenceA :: Applicative f => Reverse * f (f a) -> f (Reverse * f a) # mapM :: Monad m => (a -> m b) -> Reverse * f a -> m (Reverse * f b) # sequence :: Monad m => Reverse * f (m a) -> m (Reverse * f a) #
Traversable f => Traversable (Backwards * f) | Derived instance.
Methods traverse :: Applicative f => (a -> f b) -> Backwards * f a -> f (Backwards * f b) # sequenceA :: Applicative f => Backwards * f (f a) -> f (Backwards * f a) # mapM :: Monad m => (a -> m b) -> Backwards * f a -> m (Backwards * f b) # sequence :: Monad m => Backwards * f (m a) -> m (Backwards * f a) #
Traversable (Constant * a) |
Methods traverse :: Applicative f => (a -> f b) -> Constant * a a -> f (Constant * a b) # sequenceA :: Applicative f => Constant * a (f a) -> f (Constant * a a) # mapM :: Monad m => (a -> m b) -> Constant * a a -> m (Constant * a b) # sequence :: Monad m => Constant * a (m a) -> m (Constant * a a) #
Traversable f => Traversable (AlongsideRight f a) # |
Methods traverse :: Applicative f => (a -> f b) -> AlongsideRight f a a -> f (AlongsideRight f a b) # sequenceA :: Applicative f => AlongsideRight f a (f a) -> f (AlongsideRight f a a) # mapM :: Monad m => (a -> m b) -> AlongsideRight f a a -> m (AlongsideRight f a b) # sequence :: Monad m => AlongsideRight f a (m a) -> m (AlongsideRight f a a) #
Traversable f => Traversable (AlongsideLeft f b) # |
Methods traverse :: Applicative f => (a -> f b) -> AlongsideLeft f b a -> f (AlongsideLeft f b b) # sequenceA :: Applicative f => AlongsideLeft f b (f a) -> f (AlongsideLeft f b a) # mapM :: Monad m => (a -> m b) -> AlongsideLeft f b a -> m (AlongsideLeft f b b) # sequence :: Monad m => AlongsideLeft f b (m a) -> m (AlongsideLeft f b a) #
Traversable f => Traversable (M1 i c f) |
Methods traverse :: Applicative f => (a -> f b) -> M1 i c f a -> f (M1 i c f b) # sequenceA :: Applicative f => M1 i c f (f a) -> f (M1 i c f a) # mapM :: Monad m => (a -> m b) -> M1 i c f a -> m (M1 i c f b) # sequence :: Monad m => M1 i c f (m a) -> m (M1 i c f a) #
(Traversable f, Traversable g) => Traversable (Sum * f g) |
Methods traverse :: Applicative f => (a -> f b) -> Sum * f g a -> f (Sum * f g b) # sequenceA :: Applicative f => Sum * f g (f a) -> f (Sum * f g a) # mapM :: Monad m => (a -> m b) -> Sum * f g a -> m (Sum * f g b) # sequence :: Monad m => Sum * f g (m a) -> m (Sum * f g a) #
(Traversable f, Traversable g) => Traversable (Product * f g) |
Methods traverse :: Applicative f => (a -> f b) -> Product * f g a -> f (Product * f g b) # sequenceA :: Applicative f => Product * f g (f a) -> f (Product * f g a) # mapM :: Monad m => (a -> m b) -> Product * f g a -> m (Product * f g b) # sequence :: Monad m => Product * f g (m a) -> m (Product * f g a) #
Traversable (Magma i t b) # |
Methods traverse :: Applicative f => (a -> f b) -> Magma i t b a -> f (Magma i t b b) # sequenceA :: Applicative f => Magma i t b (f a) -> f (Magma i t b a) # mapM :: Monad m => (a -> m b) -> Magma i t b a -> m (Magma i t b b) # sequence :: Monad m => Magma i t b (m a) -> m (Magma i t b a) #
(Traversable f, Traversable g) => Traversable (Compose * * f g) |
Methods traverse :: Applicative f => (a -> f b) -> Compose * * f g a -> f (Compose * * f g b) # sequenceA :: Applicative f => Compose * * f g (f a) -> f (Compose * * f g a) # mapM :: Monad m => (a -> m b) -> Compose * * f g a -> m (Compose * * f g b) # sequence :: Monad m => Compose * * f g (m a) -> m (Compose * * f g a) #
Bitraversable p => Traversable (WrappedBifunctor * * p a) |
Methods traverse :: Applicative f => (a -> f b) -> WrappedBifunctor * * p a a -> f (WrappedBifunctor * * p a b) # sequenceA :: Applicative f => WrappedBifunctor * * p a (f a) -> f (WrappedBifunctor * * p a a) # mapM :: Monad m => (a -> m b) -> WrappedBifunctor * * p a a -> m (WrappedBifunctor * * p a b) # sequence :: Monad m => WrappedBifunctor * * p a (m a) -> m (WrappedBifunctor * * p a a) #
Traversable g => Traversable (Joker k * g a) |
Methods traverse :: Applicative f => (a -> f b) -> Joker k * g a a -> f (Joker k * g a b) # sequenceA :: Applicative f => Joker k * g a (f a) -> f (Joker k * g a a) # mapM :: Monad m => (a -> m b) -> Joker k * g a a -> m (Joker k * g a b) # sequence :: Monad m => Joker k * g a (m a) -> m (Joker k * g a a) #
Bitraversable p => Traversable (Flip * * p a) |
Methods traverse :: Applicative f => (a -> f b) -> Flip * * p a a -> f (Flip * * p a b) # sequenceA :: Applicative f => Flip * * p a (f a) -> f (Flip * * p a a) # mapM :: Monad m => (a -> m b) -> Flip * * p a a -> m (Flip * * p a b) # sequence :: Monad m => Flip * * p a (m a) -> m (Flip * * p a a) #
Traversable (Clown * k f a) |
Methods traverse :: Applicative f => (a -> f b) -> Clown * k f a a -> f (Clown * k f a b) # sequenceA :: Applicative f => Clown * k f a (f a) -> f (Clown * k f a a) # mapM :: Monad m => (a -> m b) -> Clown * k f a a -> m (Clown * k f a b) # sequence :: Monad m => Clown * k f a (m a) -> m (Clown * k f a a) #
(Traversable f, Bitraversable p) => Traversable (Tannen * * * f p a) |
Methods traverse :: Applicative f => (a -> f b) -> Tannen * * * f p a a -> f (Tannen * * * f p a b) # sequenceA :: Applicative f => Tannen * * * f p a (f a) -> f (Tannen * * * f p a a) # mapM :: Monad m => (a -> m b) -> Tannen * * * f p a a -> m (Tannen * * * f p a b) # sequence :: Monad m => Tannen * * * f p a (m a) -> m (Tannen * * * f p a a) #
(Bitraversable p, Traversable g) => Traversable (Biff * k * * p f g a) |
Methods traverse :: Applicative f => (a -> f b) -> Biff * k * * p f g a a -> f (Biff * k * * p f g a b) # sequenceA :: Applicative f => Biff * k * * p f g a (f a) -> f (Biff * k * * p f g a a) # mapM :: Monad m => (a -> m b) -> Biff * k * * p f g a a -> m (Biff * k * * p f g a b) # sequence :: Monad m => Biff * k * * p f g a (m a) -> m (Biff * k * * p f g a a) #

class (Foldable1 t, Traversable t) => Traversable1 t where #

Minimal complete definition

traverse1 | sequence1

Methods

traverse1 :: Apply f => (a -> f b) -> t a -> f (t b) #

Instances

Traversable1 V1 |
Methods traverse1 :: Apply f => (a -> f b) -> V1 a -> f (V1 b) # sequence1 :: Apply f => V1 (f b) -> f (V1 b) #
Traversable1 Par1 |
Methods traverse1 :: Apply f => (a -> f b) -> Par1 a -> f (Par1 b) # sequence1 :: Apply f => Par1 (f b) -> f (Par1 b) #
Traversable1 Identity |
Methods traverse1 :: Apply f => (a -> f b) -> Identity a -> f (Identity b) # sequence1 :: Apply f => Identity (f b) -> f (Identity b) #
Traversable1 NonEmpty |
Methods traverse1 :: Apply f => (a -> f b) -> NonEmpty a -> f (NonEmpty b) # sequence1 :: Apply f => NonEmpty (f b) -> f (NonEmpty b) #
Traversable1 Tree |
Methods traverse1 :: Apply f => (a -> f b) -> Tree a -> f (Tree b) # sequence1 :: Apply f => Tree (f b) -> f (Tree b) #
Traversable1 f => Traversable1 (Rec1 f) |
Methods traverse1 :: Apply f => (a -> f b) -> Rec1 f a -> f (Rec1 f b) # sequence1 :: Apply f => Rec1 f (f b) -> f (Rec1 f b) #
Traversable1 ((,) a) |
Methods traverse1 :: Apply f => (a -> f b) -> (a, a) -> f (a, b) # sequence1 :: Apply f => (a, f b) -> f (a, b) #
Traversable1 f => Traversable1 (Cofree f) |
Methods traverse1 :: Apply f => (a -> f b) -> Cofree f a -> f (Cofree f b) # sequence1 :: Apply f => Cofree f (f b) -> f (Cofree f b) #
Traversable1 f => Traversable1 (Free f) |
Methods traverse1 :: Apply f => (a -> f b) -> Free f a -> f (Free f b) # sequence1 :: Apply f => Free f (f b) -> f (Free f b) #
(Monad m, Traversable1 m) => Traversable1 (IterT m) |
Methods traverse1 :: Apply f => (a -> f b) -> IterT m a -> f (IterT m b) # sequence1 :: Apply f => IterT m (f b) -> f (IterT m b) #
Traversable1 f => Traversable1 (Yoneda f) |
Methods traverse1 :: Apply f => (a -> f b) -> Yoneda f a -> f (Yoneda f b) # sequence1 :: Apply f => Yoneda f (f b) -> f (Yoneda f b) #
Traversable1 f => Traversable1 (Lift f) |
Methods traverse1 :: Apply f => (a -> f b) -> Lift f a -> f (Lift f b) # sequence1 :: Apply f => Lift f (f b) -> f (Lift f b) #
(Traversable1 f, Traversable1 g) => Traversable1 ((:+:) f g) |
Methods traverse1 :: Apply f => (a -> f b) -> (f :+: g) a -> f ((f :+: g) b) # sequence1 :: Apply f => (f :+: g) (f b) -> f ((f :+: g) b) #
(Traversable1 f, Traversable1 g) => Traversable1 ((:*:) f g) |
Methods traverse1 :: Apply f => (a -> f b) -> (f :*: g) a -> f ((f :*: g) b) # sequence1 :: Apply f => (f :*: g) (f b) -> f ((f :*: g) b) #
(Traversable1 f, Traversable1 g) => Traversable1 ((:.:) f g) |
Methods traverse1 :: Apply f => (a -> f b) -> (f :.: g) a -> f ((f :.: g) b) # sequence1 :: Apply f => (f :.: g) (f b) -> f ((f :.: g) b) #
Bitraversable1 p => Traversable1 (Join * p) |
Methods traverse1 :: Apply f => (a -> f b) -> Join * p a -> f (Join * p b) # sequence1 :: Apply f => Join * p (f b) -> f (Join * p b) #
Traversable1 f => Traversable1 (IdentityT * f) |
Methods traverse1 :: Apply f => (a -> f b) -> IdentityT * f a -> f (IdentityT * f b) # sequence1 :: Apply f => IdentityT * f (f b) -> f (IdentityT * f b) #
Traversable1 (Tagged * a) |
Methods traverse1 :: Apply f => (a -> f b) -> Tagged * a a -> f (Tagged * a b) # sequence1 :: Apply f => Tagged * a (f b) -> f (Tagged * a b) #
Traversable1 f => Traversable1 (Reverse * f) |
Methods traverse1 :: Apply f => (a -> f b) -> Reverse * f a -> f (Reverse * f b) # sequence1 :: Apply f => Reverse * f (f b) -> f (Reverse * f b) #
Traversable1 f => Traversable1 (Backwards * f) |
Methods traverse1 :: Apply f => (a -> f b) -> Backwards * f a -> f (Backwards * f b) # sequence1 :: Apply f => Backwards * f (f b) -> f (Backwards * f b) #
Traversable1 f => Traversable1 (AlongsideRight f a) # |
Methods traverse1 :: Apply f => (a -> f b) -> AlongsideRight f a a -> f (AlongsideRight f a b) # sequence1 :: Apply f => AlongsideRight f a (f b) -> f (AlongsideRight f a b) #
Traversable1 f => Traversable1 (AlongsideLeft f b) # |
Methods traverse1 :: Apply f => (a -> f b) -> AlongsideLeft f b a -> f (AlongsideLeft f b b) # sequence1 :: Apply f => AlongsideLeft f b (f b) -> f (AlongsideLeft f b b) #
Traversable1 f => Traversable1 (M1 i c f) |
Methods traverse1 :: Apply f => (a -> f b) -> M1 i c f a -> f (M1 i c f b) # sequence1 :: Apply f => M1 i c f (f b) -> f (M1 i c f b) #
(Traversable1 f, Traversable1 g) => Traversable1 (Sum * f g) |
Methods traverse1 :: Apply f => (a -> f b) -> Sum * f g a -> f (Sum * f g b) # sequence1 :: Apply f => Sum * f g (f b) -> f (Sum * f g b) #
(Traversable1 f, Traversable1 g) => Traversable1 (Product * f g) |
Methods traverse1 :: Apply f => (a -> f b) -> Product * f g a -> f (Product * f g b) # sequence1 :: Apply f => Product * f g (f b) -> f (Product * f g b) #
(Traversable1 f, Traversable1 g) => Traversable1 (Compose * * f g) |
Methods traverse1 :: Apply f => (a -> f b) -> Compose * * f g a -> f (Compose * * f g b) # sequence1 :: Apply f => Compose * * f g (f b) -> f (Compose * * f g b) #
Traversable1 g => Traversable1 (Joker * * g a) |
Methods traverse1 :: Apply f => (a -> f b) -> Joker * * g a a -> f (Joker * * g a b) # sequence1 :: Apply f => Joker * * g a (f b) -> f (Joker * * g a b) #

both :: Bitraversable r => Traversal (r a a) (r b b) a b #

Traverse both parts of a `Bitraversable` container with matching types.

Usually that type will be a pair.

    >>> (1,2) & both *~ 10
    (10,20)

    >>> over both length ("hello","world")
    (5,5)

    >>> ("hello","world")^.both
    "helloworld"

    both :: Traversal (a, a)       (b, b)       a b
    both :: Traversal (Either a a) (Either b b) a b

both1 :: Bitraversable1 r => Traversal1 (r a a) (r b b) a b #

Traverse both parts of a `Bitraversable1` container with matching types.

Usually that type will be a pair.

    both1 :: Traversal1 (a, a)       (b, b)       a b
    both1 :: Traversal1 (Either a a) (Either b b) a b

beside :: (Representable q, Applicative (Rep q), Applicative f, Bitraversable r) => Optical p q f s t a b -> Optical p q f s' t' a b -> Optical p q f (r s s') (r t t') a b #

Apply a different `Traversal` or `Fold` to each side of a `Bitraversable` container.

    beside :: Traversal s t a b                -> Traversal s' t' a b                -> Traversal (r s s') (r t t') a b
    beside :: IndexedTraversal i s t a b       -> IndexedTraversal i s' t' a b       -> IndexedTraversal i (r s s') (r t t') a b
    beside :: IndexPreservingTraversal s t a b -> IndexPreservingTraversal s' t' a b -> IndexPreservingTraversal (r s s') (r t t') a b

    beside :: Traversal s t a b                -> Traversal s' t' a b                -> Traversal (s,s') (t,t') a b
    beside :: Lens s t a b                     -> Lens s' t' a b                     -> Traversal (s,s') (t,t') a b
    beside :: Fold s a                         -> Fold s' a                          -> Fold (s,s') a
    beside :: Getter s a                       -> Getter s' a                        -> Fold (s,s') a

    beside :: IndexedTraversal i s t a b       -> IndexedTraversal i s' t' a b       -> IndexedTraversal i (s,s') (t,t') a b
    beside :: IndexedLens i s t a b            -> IndexedLens i s' t' a b            -> IndexedTraversal i (s,s') (t,t') a b
    beside :: IndexedFold i s a                -> IndexedFold i s' a                 -> IndexedFold i (s,s') a
    beside :: IndexedGetter i s a              -> IndexedGetter i s' a               -> IndexedFold i (s,s') a

    beside :: IndexPreservingTraversal s t a b -> IndexPreservingTraversal s' t' a b -> IndexPreservingTraversal (s,s') (t,t') a b
    beside :: IndexPreservingLens s t a b      -> IndexPreservingLens s' t' a b      -> IndexPreservingTraversal (s,s') (t,t') a b
    beside :: IndexPreservingFold s a          -> IndexPreservingFold s' a           -> IndexPreservingFold (s,s') a
    beside :: IndexPreservingGetter s a        -> IndexPreservingGetter s' a         -> IndexPreservingFold (s,s') a

    >>> ("hello",["world","!!!"])^..beside id traverse
    ["hello","world","!!!"]

taking :: (Conjoined p, Applicative f) => Int -> Traversing p f s t a a -> Over p f s t a a #

Visit the first n targets of a `Traversal`, `Fold`, `Getter` or `Lens`.

    >>> [("hello","world"),("!!!","!!!")]^.. taking 2 (traverse.both)
    ["hello","world"]

    >>> timingOut $ [1..] ^.. taking 3 traverse
    [1,2,3]

    >>> over (taking 5 traverse) succ "hello world"
    "ifmmp world"

    taking :: Int -> Traversal' s a                   -> Traversal' s a
    taking :: Int -> Lens' s a                        -> Traversal' s a
    taking :: Int -> Iso' s a                         -> Traversal' s a
    taking :: Int -> Prism' s a                       -> Traversal' s a
    taking :: Int -> Getter s a                       -> Fold s a
    taking :: Int -> Fold s a                         -> Fold s a
    taking :: Int -> IndexedTraversal' i s a          -> IndexedTraversal' i s a
    taking :: Int -> IndexedLens' i s a               -> IndexedTraversal' i s a
    taking :: Int -> IndexedGetter i s a              -> IndexedFold i s a
    taking :: Int -> IndexedFold i s a                -> IndexedFold i s a

dropping :: (Conjoined p, Applicative f) => Int -> Over p (Indexing f) s t a a -> Over p f s t a a #

Visit all but the first n targets of a `Traversal`, `Fold`, `Getter` or `Lens`.

    >>> ("hello","world") ^? dropping 1 both
    Just "world"

Dropping works on infinite traversals as well:

    >>> [1..] ^? dropping 1 folded
    Just 2

    dropping :: Int -> Traversal' s a                   -> Traversal' s a
    dropping :: Int -> Lens' s a                        -> Traversal' s a
    dropping :: Int -> Iso' s a                         -> Traversal' s a
    dropping :: Int -> Prism' s a                       -> Traversal' s a
    dropping :: Int -> Getter s a                       -> Fold s a
    dropping :: Int -> Fold s a                         -> Fold s a
    dropping :: Int -> IndexedTraversal' i s a          -> IndexedTraversal' i s a
    dropping :: Int -> IndexedLens' i s a               -> IndexedTraversal' i s a
    dropping :: Int -> IndexedGetter i s a              -> IndexedFold i s a
    dropping :: Int -> IndexedFold i s a                -> IndexedFold i s a

failing :: (Conjoined p, Applicative f) => Traversing p f s t a b -> Over p f s t a b -> Over p f s t a b infixl 5 #

Try the first `Traversal` (or `Fold`), falling back on the second `Traversal` (or `Fold`) if it returns no entries.

This is only a valid `Traversal` if the second `Traversal` is disjoint from the result of the first or returns exactly the same results. These conditions are trivially met when given a `Lens`, `Iso`, `Getter`, `Prism` or "affine" Traversal -- one that has 0 or 1 target.

Mutatis mutandis for `Fold`.

    >>> [0,1,2,3] ^? failing (ix 1) (ix 2)
    Just 1

    >>> [0,1,2,3] ^? failing (ix 42) (ix 2)
    Just 2

    failing :: Traversal s t a b -> Traversal s t a b -> Traversal s t a b
    failing :: Prism s t a b     -> Prism s t a b     -> Traversal s t a b
    failing :: Fold s a          -> Fold s a          -> Fold s a

These cases are also supported, trivially, but are boring, because the left hand side always succeeds.

    failing :: Lens s t a b      -> Traversal s t a b -> Traversal s t a b
    failing :: Iso s t a b       -> Traversal s t a b -> Traversal s t a b
    failing :: Equality s t a b  -> Traversal s t a b -> Traversal s t a b
    failing :: Getter s a        -> Fold s a          -> Fold s a

If both of the inputs are indexed, the result is also indexed, so you can apply this to a pair of indexed traversals or indexed folds, obtaining an indexed traversal or indexed fold.

    failing :: IndexedTraversal i s t a b -> IndexedTraversal i s t a b -> IndexedTraversal i s t a b
    failing :: IndexedFold i s a          -> IndexedFold i s a          -> IndexedFold i s a

These cases are also supported, trivially, but are boring, because the left hand side always succeeds.

    failing :: IndexedLens i s t a b      -> IndexedTraversal i s t a b -> IndexedTraversal i s t a b
    failing :: IndexedGetter i s a        -> IndexedGetter i s a        -> IndexedFold i s a

deepOf :: (Conjoined p, Applicative f) => LensLike f s t s t -> Traversing p f s t a b -> Over p f s t a b #

Try the second traversal. If it returns no entries, try again with all entries from the first traversal, recursively.

    deepOf :: Fold s s          -> Fold s a                   -> Fold s a
    deepOf :: Traversal' s s    -> Traversal' s a             -> Traversal' s a
    deepOf :: Traversal s t s t -> Traversal s t a b          -> Traversal s t a b
    deepOf :: Fold s s          -> IndexedFold i s a          -> IndexedFold i s a
    deepOf :: Traversal s t s t -> IndexedTraversal i s t a b -> IndexedTraversal i s t a b

# Indexed Traversals

## Common

ignored :: Applicative f => pafb -> s -> f s #

This is the trivial empty `Traversal`.

    ignored :: IndexedTraversal i s s a b

    ignored ≡ const pure

    >>> 6 & ignored %~ absurd
    6

class Ord k => TraverseMin k m | m -> k where #

Allows `IndexedTraversal` the value at the smallest index.

Minimal complete definition

traverseMin

Methods

traverseMin :: IndexedTraversal' k (m v) v #

`IndexedTraversal` of the element with the smallest index.

Instances

TraverseMin Int IntMap # |
Methods traverseMin :: (Indexable Int p, Applicative f) => p v (f v) -> IntMap v -> f (IntMap v) #
Ord k => TraverseMin k (Map k) # |
Methods traverseMin :: (Indexable k p, Applicative f) => p v (f v) -> Map k v -> f (Map k v) #

class Ord k => TraverseMax k m | m -> k where #

Allows `IndexedTraversal` of the value at the largest index.

Minimal complete definition

traverseMax

Methods

traverseMax :: IndexedTraversal' k (m v) v #

`IndexedTraversal` of the element at the largest index.

Instances

TraverseMax Int IntMap # |
Methods traverseMax :: (Indexable Int p, Applicative f) => p v (f v) -> IntMap v -> f (IntMap v) #
Ord k => TraverseMax k (Map k) # |
Methods traverseMax :: (Indexable k p, Applicative f) => p v (f v) -> Map k v -> f (Map k v) #

traversed :: Traversable f => IndexedTraversal Int (f a) (f b) a b #

Traverse any `Traversable` container. This is an `IndexedTraversal` that is indexed by ordinal position.

traversed1 :: Traversable1 f => IndexedTraversal1 Int (f a) (f b) a b #

Traverse any `Traversable1` container. This is an `IndexedTraversal1` that is indexed by ordinal position.

traversed64 :: Traversable f => IndexedTraversal Int64 (f a) (f b) a b #

Traverse any `Traversable` container. This is an `IndexedTraversal` that is indexed by ordinal position.

elementOf :: Applicative f => LensLike (Indexing f) s t a a -> Int -> IndexedLensLike Int f s t a a #

Traverse the nth `elementOf` a `Traversal`, `Lens` or `Iso` if it exists.

    >>> [[1],[3,4]] & elementOf (traverse.traverse) 1 .~ 5
    [[1],[5,4]]

    >>> [[1],[3,4]] ^? elementOf (folded.folded) 1
    Just 3

    >>> timingOut $ ['a'..] ^?! elementOf folded 5
    'f'

    >>> timingOut $ take 10 $ elementOf traverse 3 .~ 16 $ [0..]
    [0,1,2,16,4,5,6,7,8,9]

    elementOf :: Traversal' s a -> Int -> IndexedTraversal' Int s a
    elementOf :: Fold s a       -> Int -> IndexedFold Int s a

element :: Traversable t => Int -> IndexedTraversal' Int (t a) a #

Traverse the nth element of a `Traversable` container.

    element ≡ elementOf traverse

elementsOf :: Applicative f => LensLike (Indexing f) s t a a -> (Int -> Bool) -> IndexedLensLike Int f s t a a #

Traverse (or fold) selected elements of a `Traversal` (or `Fold`) where their ordinal positions match a predicate.

    elementsOf :: Traversal' s a -> (Int -> Bool) -> IndexedTraversal' Int s a
    elementsOf :: Fold s a       -> (Int -> Bool) -> IndexedFold Int s a

elements :: Traversable t => (Int -> Bool) -> IndexedTraversal' Int (t a) a #

Traverse elements of a `Traversable` container where their ordinal positions match a predicate.

    elements ≡ elementsOf traverse

## Combinators

ipartsOf :: forall i p f s t a. (Indexable [i] p, Functor f) => Traversing (Indexed i) f s t a a -> Over p f s t [a] [a] #

An indexed version of `partsOf` that receives the entire list of indices as its index.

ipartsOf' :: forall i p f s t a. (Indexable [i] p, Functor f) => Over (Indexed i) (Bazaar' (Indexed i) a) s t a a -> Over p f s t [a] [a] #

A type-restricted version of `ipartsOf` that can only be used with an `IndexedTraversal`.

iunsafePartsOf :: forall i p f s t a b. (Indexable [i] p, Functor f) => Traversing (Indexed i) f s t a b -> Over p f s t [a] [b] #

An indexed version of `unsafePartsOf` that receives the entire list of indices as its index.

iunsafePartsOf' :: forall i s t a b. Over (Indexed i) (Bazaar (Indexed i) a b) s t a b -> IndexedLens [i] s t [a] [b] #

itraverseOf :: (Indexed i a (f b) -> s -> f t) -> (i -> a -> f b) -> s -> f t #

Traversal with an index.

NB: When you don't need access to the index then you can just apply your `IndexedTraversal` directly as a function!

    itraverseOf ≡ withIndex
    traverseOf l = itraverseOf l . const = id

    itraverseOf :: Functor f     => IndexedLens i s t a b       -> (i -> a -> f b) -> s -> f t
    itraverseOf :: Applicative f => IndexedTraversal i s t a b  -> (i -> a -> f b) -> s -> f t
    itraverseOf :: Apply f       => IndexedTraversal1 i s t a b -> (i -> a -> f b) -> s -> f t

iforOf :: (Indexed i a (f b) -> s -> f t) -> s -> (i -> a -> f b) -> f t #

Traverse with an index (and the arguments flipped).

    forOf l a ≡ iforOf l a . const
    iforOf ≡ flip . itraverseOf

    iforOf :: Functor f     => IndexedLens i s t a b       -> s -> (i -> a -> f b) -> f t
    iforOf :: Applicative f => IndexedTraversal i s t a b  -> s -> (i -> a -> f b) -> f t
    iforOf :: Apply f       => IndexedTraversal1 i s t a b -> s -> (i -> a -> f b) -> f t

imapMOf :: Over (Indexed i) (WrappedMonad m) s t a b -> (i -> a -> m b) -> s -> m t #

Map each element of a structure targeted by a `Lens` to a monadic action, evaluate these actions from left to right, and collect the results, with access its position.

When you don't need access to the index `mapMOf` is more liberal in what it can accept.

    mapMOf l ≡ imapMOf l . const

    imapMOf :: Monad m => IndexedLens       i s t a b -> (i -> a -> m b) -> s -> m t
    imapMOf :: Monad m => IndexedTraversal  i s t a b -> (i -> a -> m b) -> s -> m t
    imapMOf :: Bind  m => IndexedTraversal1 i s t a b -> (i -> a -> m b) -> s -> m t

iforMOf :: (Indexed i a (WrappedMonad m b) -> s -> WrappedMonad m t) -> s -> (i -> a -> m b) -> m t #

Map each element of a structure targeted by a `Lens` to a monadic action, evaluate these actions from left to right, and collect the results, with access its position (and the arguments flipped).

    forMOf l a ≡ iforMOf l a . const
    iforMOf ≡ flip . imapMOf

    iforMOf :: Monad m => IndexedLens i s t a b      -> s -> (i -> a -> m b) -> m t
    iforMOf :: Monad m => IndexedTraversal i s t a b -> s -> (i -> a -> m b) -> m t

imapAccumROf :: Over (Indexed i) (Backwards (State acc)) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t) #

Generalizes `mapAccumR` to an arbitrary `IndexedTraversal` with access to the index.

`imapAccumROf` accumulates state from right to left.

    mapAccumROf l ≡ imapAccumROf l . const

    imapAccumROf :: IndexedLens i s t a b      -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
    imapAccumROf :: IndexedTraversal i s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)

imapAccumLOf :: Over (Indexed i) (State acc) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t) #

Generalizes `mapAccumL` to an arbitrary `IndexedTraversal` with access to the index.

`imapAccumLOf` accumulates state from left to right.

    mapAccumLOf l ≡ imapAccumLOf l . const

    imapAccumLOf :: IndexedLens i s t a b      -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
    imapAccumLOf :: IndexedTraversal i s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)

# Reflection

traverseBy :: Traversable t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (a -> f b) -> t a -> f (t b) #

Traverse a container using its `Traversable` instance using explicitly provided `Applicative` operations. This is like `traverse` where the `Applicative` instance can be manually specified.

traverseByOf :: Traversal s t a b -> (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (a -> f b) -> s -> f t #

Traverse a container using a specified `Applicative`.

This is like `traverseBy` where the `Traversable` instance can be specified by any `Traversal`

    traverseByOf traverse ≡ traverseBy

sequenceBy :: Traversable t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> t (f a) -> f (t a) #

Sequence a container using its `Traversable` instance using explicitly provided `Applicative` operations. This is like `sequence` where the `Applicative` instance can be manually specified.

sequenceByOf :: Traversal s t (f b) b -> (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> s -> f t #

Sequence a container using a specified `Applicative`.

This is like `traverseBy` where the `Traversable` instance can be specified by any `Traversal`

    sequenceByOf traverse ≡ sequenceBy

# Implementation Details

newtype Bazaar p a b t #

This is used to characterize a `Traversal`.

a.k.a. indexed Cartesian store comonad, indexed Kleene store comonad, or an indexed `FunList`.

http://twanvl.nl/blog/haskell/non-regular1

A `Bazaar` is like a `Traversal` that has already been applied to some structure.

Where a ``Context` a b t` holds an `a` and a function from `b` to `t`, a ``Bazaar` a b t` holds `N` `a`s and a function from `N` `b`s to `t`, (where `N` might be infinite).

Mnemonically, a `Bazaar` holds many stores and you can easily add more.

This is a final encoding of `Bazaar`.

Constructors

Bazaar |
Fields runBazaar :: forall f. Applicative f => p a (f b) -> f t

Instances

Corepresentable p => Sellable p (Bazaar p) # |
Methods sell :: p a (Bazaar p a b b) #
Profunctor p => Bizarre p (Bazaar p) # |
Methods bazaar :: Applicative f => p a (f b) -> Bazaar p a b t -> f t #
Conjoined p => IndexedComonad (Bazaar p) # |
Methods iextract :: Bazaar p a a t -> t # iduplicate :: Bazaar p a c t -> Bazaar p a b (Bazaar p b c t) # iextend :: (Bazaar p b c t -> r) -> Bazaar p a c t -> Bazaar p a b r #
IndexedFunctor (Bazaar p) # |
Methods ifmap :: (s -> t) -> Bazaar p a b s -> Bazaar p a b t #
Functor (Bazaar p a b) # |
Methods fmap :: (a -> b) -> Bazaar p a b a -> Bazaar p a b b # (<$) :: a -> Bazaar p a b b -> Bazaar p a b a #
Applicative (Bazaar p a b) # |
Methods pure :: a -> Bazaar p a b a # (<*>) :: Bazaar p a b (a -> b) -> Bazaar p a b a -> Bazaar p a b b # (*>) :: Bazaar p a b a -> Bazaar p a b b -> Bazaar p a b b # (<*) :: Bazaar p a b a -> Bazaar p a b b -> Bazaar p a b a #
((~) * a b, Conjoined p) => Comonad (Bazaar p a b) # |
Methods extract :: Bazaar p a b a -> a # duplicate :: Bazaar p a b a -> Bazaar p a b (Bazaar p a b a) # extend :: (Bazaar p a b a -> b) -> Bazaar p a b a -> Bazaar p a b b #
((~) * a b, Conjoined p) => ComonadApply (Bazaar p a b) # |
Methods (<@>) :: Bazaar p a b (a -> b) -> Bazaar p a b a -> Bazaar p a b b # (@>) :: Bazaar p a b a -> Bazaar p a b b -> Bazaar p a b b # (<@) :: Bazaar p a b a -> Bazaar p a b b -> Bazaar p a b a #
Apply (Bazaar p a b) # |
Methods (<.>) :: Bazaar p a b (a -> b) -> Bazaar p a b a -> Bazaar p a b b # (.>) :: Bazaar p a b a -> Bazaar p a b b -> Bazaar p a b b # (<.) :: Bazaar p a b a -> Bazaar p a b b -> Bazaar p a b a #

type Bazaar' p a = Bazaar p a a #

This alias is helpful when it comes to reducing repetition in type signatures.

    type Bazaar' p a t = Bazaar p a a t

newtype Bazaar1 p a b t #

This is used to characterize a `Traversal`.

a.k.a. indexed Cartesian store comonad, indexed Kleene store comonad, or an indexed `FunList`.

http://twanvl.nl/blog/haskell/non-regular1

A `Bazaar1` is like a `Traversal` that has already been applied to some structure.

Where a ``Context` a b t` holds an `a` and a function from `b` to `t`, a ``Bazaar1` a b t` holds `N` `a`s and a function from `N` `b`s to `t`, (where `N` might be infinite).

Mnemonically, a `Bazaar1` holds many stores and you can easily add more.

This is a final encoding of `Bazaar1`.

Constructors

Bazaar1 |
Fields runBazaar1 :: forall f. Apply f => p a (f b) -> f t

Instances

Corepresentable p => Sellable p (Bazaar1 p) # |
Methods sell :: p a (Bazaar1 p a b b) #
Profunctor p => Bizarre1 p (Bazaar1 p) # |
Methods bazaar1 :: Apply f => p a (f b) -> Bazaar1 p a b t -> f t #
Conjoined p => IndexedComonad (Bazaar1 p) # |
Methods iextract :: Bazaar1 p a a t -> t # iduplicate :: Bazaar1 p a c t -> Bazaar1 p a b (Bazaar1 p b c t) # iextend :: (Bazaar1 p b c t -> r) -> Bazaar1 p a c t -> Bazaar1 p a b r #
IndexedFunctor (Bazaar1 p) # |
Methods ifmap :: (s -> t) -> Bazaar1 p a b s -> Bazaar1 p a b t #
Functor (Bazaar1 p a b) # |
Methods fmap :: (a -> b) -> Bazaar1 p a b a -> Bazaar1 p a b b # (<$) :: a -> Bazaar1 p a b b -> Bazaar1 p a b a #
((~) * a b, Conjoined p) => Comonad (Bazaar1 p a b) # |
Methods extract :: Bazaar1 p a b a -> a # duplicate :: Bazaar1 p a b a -> Bazaar1 p a b (Bazaar1 p a b a) # extend :: (Bazaar1 p a b a -> b) -> Bazaar1 p a b a -> Bazaar1 p a b b #
((~) * a b, Conjoined p) => ComonadApply (Bazaar1 p a b) # |
Methods (<@>) :: Bazaar1 p a b (a -> b) -> Bazaar1 p a b a -> Bazaar1 p a b b # (@>) :: Bazaar1 p a b a -> Bazaar1 p a b b -> Bazaar1 p a b b # (<@) :: Bazaar1 p a b a -> Bazaar1 p a b b -> Bazaar1 p a b a #
Apply (Bazaar1 p a b) # |
Methods (<.>) :: Bazaar1 p a b (a -> b) -> Bazaar1 p a b a -> Bazaar1 p a b b # (.>) :: Bazaar1 p a b a -> Bazaar1 p a b b -> Bazaar1 p a b b # (<.) :: Bazaar1 p a b a -> Bazaar1 p a b b -> Bazaar1 p a b a #

type Bazaar1' p a = Bazaar1 p a a #

This alias is helpful when it comes to reducing repetition in type signatures.

    type Bazaar1' p a t = Bazaar1 p a a t

loci :: Traversal (Bazaar (->) a c s) (Bazaar (->) b c s) a b #

This `Traversal` allows you to `traverse` the individual stores in a `Bazaar`.

iloci :: IndexedTraversal i (Bazaar (Indexed i) a c s) (Bazaar (Indexed i) b c s) a b #

This `IndexedTraversal` allows you to `traverse` the individual stores in a `Bazaar` with access to their indices.

# Fusion

confusing :: Applicative f => LensLike (Curried (Yoneda f) (Yoneda f)) s t a b -> LensLike f s t a b #

Fuse a `Traversal` by reassociating all of the `\<*\>` operations to the left and fusing all of the `fmap` calls into one. This is particularly useful when constructing a `Traversal` using operations from GHC.Generics.

Given a pair of `Traversal`s `foo` and `bar`,

    confusing (foo.bar) = foo.bar

However, `foo` and `bar` are each going to use the `Applicative` they are given.

`confusing` exploits the `Yoneda` lemma to merge their separate uses of `fmap` into a single `fmap`. and it further exploits an interesting property of the right Kan lift (or `Curried`) to left associate all of the uses of '(*)' to make it possible to fuse together more fmaps.

This is particularly effective when the choice of functor `f` is unknown at compile time or when the `Traversal` `foo.bar` in the above description is recursive or complex enough to prevent inlining.

`fusing` is a version of this combinator suitable for fusing lenses.

    confusing :: Traversal s t a b -> Traversal s t a b