Control.Lens.IndexedTraversal

Indexed Traversals

type IndexedTraversal i s t a b = forall f k. (Indexed i k, Applicative f) => k (a -> f b) (s -> f t)

Every indexed traversal 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.

Common Indexed Traversals

_at :: At k m => k -> SimpleIndexedTraversal k (m v) v

This simple indexed traversal lets you traverse the value at a given key in a map.

_at k = at k <. traverse

iwhereOf :: (Indexed i k, Applicative f) => Overloaded (Index i) f s t a a -> (i -> Bool) -> Overloaded k f s t a a

Access the element of an IndexedTraversal where the index matches a predicate.

>>> over (iwhereOf traversed (>0)) reverse ["He","was","stressed","o_O"]
["He","saw","desserts","O_o"]

 iwhereOf :: IndexedFold i s a            -> (i -> Bool) -> IndexedFold i s a
 iwhereOf :: IndexedGetter i s a          -> (i -> Bool) -> IndexedFold i s a
 iwhereOf :: SimpleIndexedLens i s a      -> (i -> Bool) -> SimpleIndexedTraversal i s a
 iwhereOf :: SimpleIndexedTraversal i s a -> (i -> Bool) -> SimpleIndexedTraversal i s a
 iwhereOf :: SimpleIndexedSetter i s a    -> (i -> Bool) -> SimpleIndexedSetter i s a

value :: (k -> Bool) -> SimpleIndexedTraversal k (k, v) v

This provides a Traversal that checks a predicate on a key before allowing you to traverse into a value.

ignored :: forall k f i s a b. (Indexed i k, Applicative f) => Overloaded k f s s a b

This is the trivial empty traversal.

ignored :: IndexedTraversal i s s a b

ignored ≡ const pure

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

Allows IndexedTraversal the value at the smallest index.

Methods

traverseMin :: SimpleIndexedTraversal k (m v) v

IndexedTraversal of the element with the smallest index.

Instances

TraverseMin Int IntMap

Ord k => TraverseMin k (Map k)

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

Allows IndexedTraversal of the value at the largest index.

Methods

traverseMax :: SimpleIndexedTraversal k (m v) v

IndexedTraversal of the element at the largest index.

Instances

TraverseMax Int IntMap

Ord k => TraverseMax k (Map k)

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.

elementOf :: (Applicative f, Indexed Int k) => LensLike (Indexing f) s t a a -> Int -> Overloaded k f s t a a

Traverse the nth element 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

>>> [0..] ^?! elementOf folded 5
5

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

 elementOf :: Simple Traversal s a -> Int -> SimpleIndexedTraversal Int s a
 elementOf :: Fold s a            -> Int -> IndexedFold Int s a

element :: Traversable t => Int -> SimpleIndexedTraversal Int (t a) a

Traverse the nth element of a Traversable container.

element ≡ elementOf traverse

elementsOf :: (Applicative f, Indexed Int k) => LensLike (Indexing f) s t a a -> (Int -> Bool) -> Overloaded k f s t a a

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

 elementsOf :: Simple Traversal s a -> (Int -> Bool) -> SimpleIndexedTraversal Int s a
 elementsOf :: Fold s a            -> (Int -> Bool) -> IndexedFold Int s a

elements :: Traversable t => (Int -> Bool) -> SimpleIndexedTraversal Int (t a) a

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

elements ≡ elementsOf traverse

Indexed Traversal Combinators

itraverseOf :: Overloaded (Index i) f s t a b -> (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 :: IndexedLens i s t a b      -> (i -> a -> f b) -> s -> f t
 itraverseOf :: IndexedTraversal i s t a b -> (i -> a -> f b) -> s -> f t

iforOf :: Overloaded (Index i) f s t a b -> 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 :: IndexedLens i s t a b      -> s -> (i -> a -> f b) -> f t
 iforOf :: IndexedTraversal i s t a b -> s -> (i -> a -> f b) -> f t

imapMOf :: Overloaded (Index 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

iforMOf :: Overloaded (Index i) (WrappedMonad m) s t a b -> 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 :: Overloaded (Index i) (State s) s t a b -> (i -> s -> a -> (s, b)) -> s -> s -> (s, 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 -> s -> a -> (s, b)) -> s -> s -> (s, t)
 imapAccumROf :: IndexedTraversal i s t a b -> (i -> s -> a -> (s, b)) -> s -> s -> (s, t)

imapAccumLOf :: Overloaded (Index i) (Backwards (State s)) s t a b -> (i -> s -> a -> (s, b)) -> s -> s -> (s, 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 -> s -> a -> (s, b)) -> s -> s -> (s, t)
 imapAccumLOf :: IndexedTraversal i s t a b -> (i -> s -> a -> (s, b)) -> s -> s -> (s, t)

Storing Indexed Traversals

newtype ReifiedIndexedTraversal i s t a b

Useful for storage.

Constructors

ReifyIndexedTraversal

Fields

reflectIndexedTraversal :: IndexedTraversal i s t a b

Simple

type SimpleIndexedTraversal i s a = IndexedTraversal i s s a a

type SimpleIndexedTraversal i = Simple (IndexedTraversal i)

type SimpleReifiedIndexedTraversal i s a = ReifiedIndexedTraversal i s s a a

type SimpleIndexedTraversal i = Simple (ReifiedIndexedTraversal i)