Control.Lens.IndexedSetter

Indexed Setter

type IndexedSetter i s t a b = forall f k. (Indexable i k, Settable f) => k (a -> f b) (s -> f t)

Every IndexedSetter is a valid Setter

The Setter laws are still required to hold.

imapOf :: Overloaded (Indexed i) Mutator s t a b -> (i -> a -> b) -> s -> t

Map with index.

When you do not need access to the index, then mapOf is more liberal in what it can accept.

mapOf l ≡ imapOf l . const

 imapOf :: IndexedSetter i s t a b    -> (i -> a -> b) -> s -> t
 imapOf :: IndexedLens i s t a b      -> (i -> a -> b) -> s -> t
 imapOf :: IndexedTraversal i s t a b -> (i -> a -> b) -> s -> t

iover :: Overloaded (Indexed i) Mutator s t a b -> (i -> a -> b) -> s -> t

Map with index. This is an alias for imapOf.

When you do not need access to the index, then over is more liberal in what it can accept.

over l ≡ iover l . const

 iover :: IndexedSetter i s t a b    -> (i -> a -> b) -> s -> t
 iover :: IndexedLens i s t a b      -> (i -> a -> b) -> s -> t
 iover :: IndexedTraversal i s t a b -> (i -> a -> b) -> s -> t

isets :: ((i -> a -> b) -> s -> t) -> IndexedSetter i s t a b

Build an IndexedSetter from an imap-like function.

Your supplied function f is required to satisfy:

 f id ≡ id
 f g . f h ≡ f (g . h)

Equational reasoning:

 isets . iover ≡ id
 iover . isets ≡ id

Another way to view sets is that it takes a "semantic editor combinator" and transforms it into a Setter.

(%@~) :: Overloaded (Indexed i) Mutator s t a b -> (i -> a -> b) -> s -> t

Adjust every target of an IndexedSetter, IndexedLens or IndexedTraversal with access to the index.

(%@~) ≡ imapOf

When you do not need access to the index then (%@~) is more liberal in what it can accept.

l %~ f ≡ l %@~ const f

 (%@~) :: IndexedSetter i s t a b    -> (i -> a -> b) -> s -> t
 (%@~) :: IndexedLens i s t a b      -> (i -> a -> b) -> s -> t
 (%@~) :: IndexedTraversal i s t a b -> (i -> a -> b) -> s -> t

(%@=) :: MonadState s m => Overloaded (Indexed i) Mutator s s a b -> (i -> a -> b) -> m ()

Adjust every target in the current state of an IndexedSetter, IndexedLens or IndexedTraversal with access to the index.

When you do not need access to the index then (%=) is more liberal in what it can accept.

l %= f ≡ l %@= const f

 (%@=) :: MonadState s m => IndexedSetter i s s a b    -> (i -> a -> b) -> m ()
 (%@=) :: MonadState s m => IndexedLens i s s a b      -> (i -> a -> b) -> m ()
 (%@=) :: MonadState s m => IndexedTraversal i s t a b -> (i -> a -> b) -> m ()

Storing Indexed Setters

newtype ReifiedIndexedSetter i s t a b

Useful for storage.

Constructors

ReifyIndexedSetter

Fields

reflectIndexedSetter :: IndexedSetter i s t a b

Simple

type SimpleIndexedSetter i s a = IndexedSetter i s s a a

type SimpleIndexedSetter i = Simple (IndexedSetter i)

type SimpleReifiedIndexedSetter i s a = ReifiedIndexedSetter i s s a a

type SimpleIndexedSetter i = Simple (ReifiedIndexedSetter i)