lens-3.5.1: Lenses, Folds and Traversals

Portability Rank2Types provisional Edward Kmett Safe-Inferred

Control.Lens.Setter

Description

A Setter s t a b is a generalization of fmap from Functor. It allows you to map into a structure and change out the contents, but it isn't strong enough to allow you to enumerate those contents. Starting with fmap :: Functor f => (a -> b) -> f a -> f b we monomorphize the type to obtain (a -> b) -> s -> t and then decorate it with Identity to obtain

type Setter s t a b = (a -> Identity b) -> s -> Identity t

Every Traversal is a valid Setter, since Identity is Applicative.

Everything you can do with a Functor, you can do with a Setter. There are combinators that generalize fmap and (<\$).

Synopsis

# Setters

type Setter s t a b = forall f. Settable f => (a -> f b) -> s -> f tSource

The only Lens-like law that can apply to a Setter l is that

set l y (set l x a) ≡ set l y a

You can't view a Setter in general, so the other two laws are irrelevant.

However, two Functor laws apply to a Setter:

over l idid
over l f . over l g ≡ over l (f . g)

These an be stated more directly:

l purepure
l f . untainted . l g ≡ l (f . untainted . g)

You can compose a Setter with a Lens or a Traversal using (.) from the Prelude and the result is always only a Setter and nothing more.

# Building Setters

sets :: ((a -> b) -> s -> t) -> Setter s t a bSource

Build a Setter from a map-like function.

Your supplied function f is required to satisfy:

f idid
f g . f h ≡ f (g . h)

Equational reasoning:

sets . overid
over . setsid

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

# Common Setters

mapped :: Functor f => Setter (f a) (f b) a bSource

This setter can be used to map over all of the values in a Functor.

fmapover mapped
fmapDefaultover traverse
(<\$) ≡ set mapped
>>> over mapped (+1) [1,2,3]
[2,3,4]
>>> set mapped () [1,2,3]
[(),(),()]
>>> mapped.mapped %~ (+1) \$ [[1,2],[3]]
[[2,3],[4]]

lifted :: Monad m => Setter (m a) (m b) a bSource

This setter can be used to modify all of the values in a Monad.

You sometimes have to use this, rather than mapped, because due to temporary insanity Functor is not a superclass of Monad.

liftMover lifted
>>> over lifted (+1) [1,2,3]
[2,3,4]

# Functional Combinators

over :: Setting s t a b -> (a -> b) -> s -> tSource

Modify the target of a Lens or all the targets of a Setter or Traversal with a function.

fmapover mapped
fmapDefaultover traverse
sets . overid
over . setsid
>>> over mapped (*10) [1,2,3]
[10,20,30]
>>> over _1 show (10,20)
("10",20)

Another way to view over is to say that it transformers a Setter into a "semantic editor combinator".

over :: Setter s t a b -> (a -> b) -> s -> t

mapOf :: Setting s t a b -> (a -> b) -> s -> tSource

Modify the target of a Lens or all the targets of a Setter or Traversal with a function. This is an alias for over that is provided for consistency.

mapOfover
fmapmapOf mapped
fmapDefaultmapOf traverse
sets . mapOfid
mapOf . setsid
>>> mapOf mapped (+1) [1,2,3,4]
[2,3,4,5]
>>> mapOf _1 (+1) (1,2)
(2,2)
>>> mapOf both (+1) (1,2)
(2,3)
mapOf :: Setter s t a b      -> (a -> b) -> s -> t
mapOf :: Iso s t a b         -> (a -> b) -> s -> t
mapOf :: Lens s t a b        -> (a -> b) -> s -> t
mapOf :: Traversal s t a b   -> (a -> b) -> s -> t

set :: Setting s t a b -> b -> s -> tSource

Replace the target of a Lens or all of the targets of a Setter or Traversal with a constant value.

(<\$) ≡ set mapped
>>> set _2 "hello" (1,())
(1,"hello")
>>> set mapped () [1,2,3,4]
[(),(),(),()]

Note: Attempting to set a Fold or Getter will fail at compile time with an relatively nice error message.

set :: Setter s t a b    -> b -> s -> t
set :: Iso s t a b       -> b -> s -> t
set :: Lens s t a b      -> b -> s -> t
set :: Traversal s t a b -> b -> s -> t

(.~) :: Setting s t a b -> b -> s -> tSource

Replace the target of a Lens or all of the targets of a Setter or Traversal with a constant value.

This is an infix version of set, provided for consistency with (.=)

f <\$ a ≡ mapped .~ f \$ a
>>> _1 .~ "hello" \$ (42,"world")
("hello","world")
(.~) :: Setter s t a b    -> b -> s -> t
(.~) :: Iso s t a b       -> b -> s -> t
(.~) :: Lens s t a b      -> b -> s -> t
(.~) :: Traversal s t a b -> b -> s -> t

(%~) :: Setting s t a b -> (a -> b) -> s -> tSource

Modifies the target of a Lens or all of the targets of a Setter or Traversal with a user supplied function.

This is an infix version of over

fmap f ≡ mapped %~ f
fmapDefault f ≡ traverse %~ f
>>> _2 %~ length \$ (1,"hello")
(1,5)
>>> traverse %~ (+1) \$ [1,2,3]
[2,3,4]
>>> _2 %~ (+1) \$ (3,4)
(3,5)
>>> traverse.traverse %~ length \$ [["hello","world"],["!!!"]]
[[5,5],[3]]
(%~) :: Setter s t a b    -> (a -> b) -> s -> t
(%~) :: Iso s t a b       -> (a -> b) -> s -> t
(%~) :: Lens s t a b      -> (a -> b) -> s -> t
(%~) :: Traversal s t a b -> (a -> b) -> s -> t

(+~) :: Num a => Setting s t a a -> a -> s -> tSource

Increment the target(s) of a numerically valued Lens, Setter or Traversal

>>> _1 +~ 1 \$ (1,2)
(2,2)
>>> both +~ 2 \$ (5,6)
(7,8)
(+~) :: Num a => Simple Setter s a -> a -> s -> s
(+~) :: Num a => Simple Iso s a -> a -> s -> s
(+~) :: Num a => Simple Lens s a -> a -> s -> s
(+~) :: Num a => Simple Traversal s a -> a -> s -> s

(-~) :: Num a => Setting s t a a -> a -> s -> tSource

Decrement the target(s) of a numerically valued Lens, Iso, Setter or Traversal

>>> _1 -~ 2 \$ (1,2)
(-1,2)
>>> mapped.mapped -~ 1 \$ [[4,5],[6,7]]
[[3,4],[5,6]]
(-~) :: Num a => Simple Setter s a -> a -> s -> s
(-~) :: Num a => Simple Iso s a -> a -> s -> s
(-~) :: Num a => Simple Lens s a -> a -> s -> s
(-~) :: Num a => Simple Traversal s a -> a -> s -> s

(*~) :: Num a => Setting s t a a -> a -> s -> tSource

Multiply the target(s) of a numerically valued Lens, Iso, Setter or Traversal

>>> _2 *~ 4 \$ (1,2)
(1,8)
>>> mapped *~ 2 \$ Just 24
Just 48
(*~) :: Num a => Simple Setter s a -> a -> s -> s
(*~) :: Num a => Simple Iso s a -> a -> s -> s
(*~) :: Num a => Simple Lens s a -> a -> s -> s
(*~) :: Num a => Simple Traversal s a -> a -> s -> s

(//~) :: Fractional s => Setting a b s s -> s -> a -> bSource

Divide the target(s) of a numerically valued Lens, Iso, Setter or Traversal

>>> _2 //~ 2 \$ ("Hawaii",10)
("Hawaii",5.0)
(//~) :: Fractional a => Simple Setter s a -> a -> s -> s
(//~) :: Fractional a => Simple Iso s a -> a -> s -> s
(//~) :: Fractional a => Simple Lens s a -> a -> s -> s
(//~) :: Fractional a => Simple Traversal s a -> a -> s -> s

(^~) :: (Num a, Integral e) => Setting s t a a -> e -> s -> tSource

Raise the target(s) of a numerically valued Lens, Setter or Traversal to a non-negative integral power

>>> _2 ^~ 2 \$ (1,3)
(1,9)
(^~) :: (Num a, Integral e) => Simple Setter s a -> e -> s -> s
(^~) :: (Num a, Integral e) => Simple Iso s a -> e -> s -> s
(^~) :: (Num a, Integral e) => Simple Lens s a -> e -> s -> s
(^~) :: (Num a, Integral e) => Simple Traversal s a -> e -> s -> s

(^^~) :: (Fractional a, Integral e) => Setting s t a a -> e -> s -> tSource

Raise the target(s) of a fractionally valued Lens, Setter or Traversal to an integral power

>>> _2 ^^~ (-1) \$ (1,2)
(1,0.5)
(^^~) :: (Fractional a, Integral e) => Simple Setter s a -> e -> s -> s
(^^~) :: (Fractional a, Integral e) => Simple Iso s a -> e -> s -> s
(^^~) :: (Fractional a, Integral e) => Simple Lens s a -> e -> s -> s
(^^~) :: (Fractional a, Integral e) => Simple Traversal s a -> e -> s -> s

(**~) :: Floating a => Setting s t a a -> a -> s -> tSource

Raise the target(s) of a floating-point valued Lens, Setter or Traversal to an arbitrary power.

>>> _2 **~ pi \$ (1,3)
(1,31.54428070019754)
(**~) :: Floating a => Simple Setter s a -> a -> s -> s
(**~) :: Floating a => Simple Iso s a -> a -> s -> s
(**~) :: Floating a => Simple Lens s a -> a -> s -> s
(**~) :: Floating a => Simple Traversal s a -> a -> s -> s

(||~) :: Setting s t Bool Bool -> Bool -> s -> tSource

Logically || the target(s) of a Bool-valued Lens or Setter

>>> both ||~ True \$ (False,True)
(True,True)
>>> both ||~ False \$ (False,True)
(False,True)
(||~) :: Simple Setter s Bool -> Bool -> s -> s
(||~) :: Simple Iso s Bool -> Bool -> s -> s
(||~) :: Simple Lens s Bool -> Bool -> s -> s
(||~) :: Simple Traversal s Bool -> Bool -> s -> s

(&&~) :: Setting s t Bool Bool -> Bool -> s -> tSource

Logically && the target(s) of a Bool-valued Lens or Setter

>>> both &&~ True \$ (False, True)
(False,True)
>>> both &&~ False \$ (False, True)
(False,False)
(&&~) :: Simple Setter s Bool -> Bool -> s -> s
(&&~) :: Simple Iso s Bool -> Bool -> s -> s
(&&~) :: Simple Lens s Bool -> Bool -> s -> s
(&&~) :: Simple Traversal s Bool -> Bool -> s -> s

(<.~) :: Setting s t a b -> b -> s -> (b, t)Source

Set with pass-through

This is mostly present for consistency, but may be useful for for chaining assignments

If you do not need a copy of the intermediate result, then using l .~ t directly is a good idea.

>>> _3 <.~ "world" \$ ("good","morning","vietnam")
("world",("good","morning","world"))
>>> import Data.Map as Map
>>> _2.at "hello" <.~ Just "world" \$ (42,Map.fromList [("goodnight","gracie")])
(Just "world",(42,fromList [("goodnight","gracie"),("hello","world")]))
(<.~) :: Setter s t a b    -> b -> s -> (b, t)
(<.~) :: Iso s t a b       -> b -> s -> (b, t)
(<.~) :: Lens s t a b      -> b -> s -> (b, t)
(<.~) :: Traversal s t a b -> b -> s -> (b, t)

(?~) :: Setting s t a (Maybe b) -> b -> s -> tSource

Set the target of a Lens, Traversal or Setter to Just a value.

l ?~ t ≡ set l (Just t)
(?~) :: Setter s t a (Maybe b)    -> b -> s -> t
(?~) :: Iso s t a (Maybe b)       -> b -> s -> t
(?~) :: Lens s t a (Maybe b)      -> b -> s -> t
(?~) :: Traversal s t a (Maybe b) -> b -> s -> t

(<?~) :: Setting s t a (Maybe b) -> b -> s -> (b, t)Source

Set to Just a value with pass-through

This is mostly present for consistency, but may be useful for for chaining assignments

If you do not need a copy of the intermediate result, then using l ?~ d directly is a good idea.

>>> import Data.Map as Map
>>> _2.at "hello" <?~ "world" \$ (42,Map.fromList [("goodnight","gracie")])
("world",(42,fromList [("goodnight","gracie"),("hello","world")]))
(<?~) :: Setter s t a b    -> (Maybe b) -> s -> (b, t)
(<?~) :: Iso s t a (Maybe b)       -> b -> s -> (b, t)
(<?~) :: Lens s t a (Maybe b)      -> b -> s -> (b, t)
(<?~) :: Traversal s t a (Maybe b) -> b -> s -> (b, t)

# State Combinators

assign :: MonadState s m => Setting s s a b -> b -> m ()Source

Replace the target of a Lens or all of the targets of a Setter or Traversal in our monadic state with a new value, irrespective of the old.

This is an alias for (.=).

assign :: MonadState s m => Simple Iso s a       -> a -> m ()
assign :: MonadState s m => Simple Lens s a      -> a -> m ()
assign :: MonadState s m => Simple Traversal s a -> a -> m ()
assign :: MonadState s m => Simple Setter s a    -> a -> m ()

(.=) :: MonadState s m => Setting s s a b -> b -> m ()Source

Replace the target of a Lens or all of the targets of a Setter or Traversal in our monadic state with a new value, irrespective of the old.

This is an infix version of assign.

(.=) :: MonadState s m => Simple Iso s a       -> a -> m ()
(.=) :: MonadState s m => Simple Lens s a      -> a -> m ()
(.=) :: MonadState s m => Simple Traversal s a -> a -> m ()
(.=) :: MonadState s m => Simple Setter s a    -> a -> m ()

(%=) :: MonadState s m => Setting s s a b -> (a -> b) -> m ()Source

Map over the target of a Lens or all of the targets of a Setter or Traversal in our monadic state.

(%=) :: MonadState s m => Simple Iso s a       -> (a -> a) -> m ()
(%=) :: MonadState s m => Simple Lens s a      -> (a -> a) -> m ()
(%=) :: MonadState s m => Simple Traversal s a -> (a -> a) -> m ()
(%=) :: MonadState s m => Simple Setter s a    -> (a -> a) -> m ()

(+=) :: (MonadState s m, Num a) => SimpleSetting s a -> a -> m ()Source

Modify the target(s) of a Simple Lens, Iso, Setter or Traversal by adding a value

Example:

fresh :: MonadState Int m => m Int
fresh = do
id += 1
use id
(+=) :: (MonadState s m, Num a) => Simple Setter s a -> a -> m ()
(+=) :: (MonadState s m, Num a) => Simple Iso s a -> a -> m ()
(+=) :: (MonadState s m, Num a) => Simple Lens s a -> a -> m ()
(+=) :: (MonadState s m, Num a) => Simple Traversal s a -> a -> m ()

(-=) :: (MonadState s m, Num a) => SimpleSetting s a -> a -> m ()Source

Modify the target(s) of a Simple Lens, Iso, Setter or Traversal by subtracting a value

(-=) :: (MonadState s m, Num a) => Simple Setter s a -> a -> m ()
(-=) :: (MonadState s m, Num a) => Simple Iso s a -> a -> m ()
(-=) :: (MonadState s m, Num a) => Simple Lens s a -> a -> m ()
(-=) :: (MonadState s m, Num a) => Simple Traversal s a -> a -> m ()

(*=) :: (MonadState s m, Num a) => SimpleSetting s a -> a -> m ()Source

Modify the target(s) of a Simple Lens, Iso, Setter or Traversal by multiplying by value.

(*=) :: (MonadState s m, Num a) => Simple Setter s a -> a -> m ()
(*=) :: (MonadState s m, Num a) => Simple Iso s a -> a -> m ()
(*=) :: (MonadState s m, Num a) => Simple Lens s a -> a -> m ()
(*=) :: (MonadState s m, Num a) => Simple Traversal s a -> a -> m ()

(//=) :: (MonadState s m, Fractional a) => SimpleSetting s a -> a -> m ()Source

Modify the target(s) of a Simple Lens, Iso, Setter or Traversal by dividing by a value.

(//=) :: (MonadState s m, Fractional a) => Simple Setter s a -> a -> m ()
(//=) :: (MonadState s m, Fractional a) => Simple Iso s a -> a -> m ()
(//=) :: (MonadState s m, Fractional a) => Simple Lens s a -> a -> m ()
(//=) :: (MonadState s m, Fractional a) => Simple Traversal s a -> a -> m ()

(^=) :: (MonadState s m, Num a, Integral e) => SimpleSetting s a -> e -> m ()Source

Raise the target(s) of a numerically valued Lens, Setter or Traversal to a non-negative integral power.

(^=) ::  (MonadState s m, Num a, Integral e) => Simple Setter s a -> e -> m ()
(^=) ::  (MonadState s m, Num a, Integral e) => Simple Iso s a -> e -> m ()
(^=) ::  (MonadState s m, Num a, Integral e) => Simple Lens s a -> e -> m ()
(^=) ::  (MonadState s m, Num a, Integral e) => Simple Traversal s a -> e -> m ()

(^^=) :: (MonadState s m, Fractional a, Integral e) => SimpleSetting s a -> e -> m ()Source

Raise the target(s) of a numerically valued Lens, Setter or Traversal to an integral power.

(^^=) ::  (MonadState s m, Fractional a, Integral e) => Simple Setter s a -> e -> m ()
(^^=) ::  (MonadState s m, Fractional a, Integral e) => Simple Iso s a -> e -> m ()
(^^=) ::  (MonadState s m, Fractional a, Integral e) => Simple Lens s a -> e -> m ()
(^^=) ::  (MonadState s m, Fractional a, Integral e) => Simple Traversal s a -> e -> m ()

(**=) :: (MonadState s m, Floating a) => SimpleSetting s a -> a -> m ()Source

Raise the target(s) of a numerically valued Lens, Setter or Traversal to an arbitrary power

(**=) ::  (MonadState s m, Floating a) => Simple Setter s a -> a -> m ()
(**=) ::  (MonadState s m, Floating a) => Simple Iso s a -> a -> m ()
(**=) ::  (MonadState s m, Floating a) => Simple Lens s a -> a -> m ()
(**=) ::  (MonadState s m, Floating a) => Simple Traversal s a -> a -> m ()

(||=) :: MonadState s m => SimpleSetting s Bool -> Bool -> m ()Source

Modify the target(s) of a Simple Lens, 'Iso, Setter or Traversal by taking their logical || with a value

(||=) :: MonadState s m => Simple Setter s Bool -> Bool -> m ()
(||=) :: MonadState s m => Simple Iso s Bool -> Bool -> m ()
(||=) :: MonadState s m => Simple Lens s Bool -> Bool -> m ()
(||=) :: MonadState s m => Simple Traversal s Bool -> Bool -> m ()

(&&=) :: MonadState s m => SimpleSetting s Bool -> Bool -> m ()Source

Modify the target(s) of a Simple Lens, Iso, Setter or Traversal by taking their logical && with a value

(&&=) :: MonadState s m => Simple Setter s Bool -> Bool -> m ()
(&&=) :: MonadState s m => Simple Iso s Bool -> Bool -> m ()
(&&=) :: MonadState s m => Simple Lens s Bool -> Bool -> m ()
(&&=) :: MonadState s m => Simple Traversal s Bool -> Bool -> m ()

(<.=) :: MonadState s m => Setting s s a b -> b -> m bSource

Set with pass-through

This is useful for chaining assignment without round-tripping through your monad stack.

do x <- _2 <.= ninety_nine_bottles_of_beer_on_the_wall

If you do not need a copy of the intermediate result, then using l .= d will avoid unused binding warnings

(<.=) :: MonadState s m => Setter s s a b -> b -> m b
(<.=) :: MonadState s m => Iso s s a b -> b -> m b
(<.=) :: MonadState s m => Lens s s a b -> b -> m b
(<.=) :: MonadState s m => Traversal s s a b -> b -> m b

(?=) :: MonadState s m => Setting s s a (Maybe b) -> b -> m ()Source

Replace the target of a Lens or all of the targets of a Setter or Traversal in our monadic state with Just a new value, irrespective of the old.

(?=) :: MonadState s m => Simple Iso s (Maybe a)       -> a -> m ()
(?=) :: MonadState s m => Simple Lens s (Maybe a)      -> a -> m ()
(?=) :: MonadState s m => Simple Traversal s (Maybe a) -> a -> m ()
(?=) :: MonadState s m => Simple Setter s (Maybe a)    -> a -> m ()

(<?=) :: MonadState s m => Setting s s a (Maybe b) -> b -> m bSource

Set Just a value with pass-through

This is useful for chaining assignment without round-tripping through your monad stack.

do x <- at foo <?= ninety_nine_bottles_of_beer_on_the_wall

If you do not need a copy of the intermediate result, then using l ?= d will avoid unused binding warnings

(<?=) :: MonadState s m => Setter s s a (Maybe b) -> b -> m b
(<?=) :: MonadState s m => Iso s s a (Maybe b) -> b -> m b
(<?=) :: MonadState s m => Lens s s a (Maybe b) -> b -> m b
(<?=) :: MonadState s m => Traversal s s a (Maybe b) -> b -> m b

(<~) :: MonadState s m => Setting s s a b -> m b -> m ()Source

Run a monadic action, and set all of the targets of a Lens, Setter or Traversal to its result.

(<~) :: MonadState s m => Iso s s a b       -> m b -> m ()
(<~) :: MonadState s m => Lens s s a b      -> m b -> m ()
(<~) :: MonadState s m => Traversal s s a b -> m b -> m ()
(<~) :: MonadState s m => Setter s s a b    -> m b -> m ()

As a reasonable mnemonic, this lets you store the result of a monadic action in a lens rather than in a local variable.

do foo <- bar
...

will store the result in a variable, while

do foo <~ bar
...

will store the result in a Lens, Setter, or Traversal.

# Storing Setters

newtype ReifiedSetter s t a b Source

Reify a setter so it can be stored safely in a container.

Constructors

 ReifySetter FieldsreflectSetter :: Setter s t a b

# Setter Internals

type Setting s t a b = (a -> Mutator b) -> s -> Mutator tSource

Running a Setter instantiates it to a concrete type.

When consuming a setter directly to perform a mapping, you can use this type, but most user code will not need to use this type.

By choosing Mutator rather than Identity, we get nicer error messages.

type SimpleSetting s a = Setting s s a aSource

This is a useful alias for use when consuming a SimpleSetter.

Most user code will never have to use this type.

type SimpleSetting m = Simple Setting

# Simplicity

type SimpleSetter s a = Setter s s a aSource

A Simple Setter is just a Setter that doesn't change the types.

These are particularly common when talking about monomorphic containers. e.g.

sets Data.Text.map :: SimpleSetter Text Char
type SimpleSetter = Simple Setter

# Exported for legible error messages

class Applicative f => Settable f Source

Anything Settable must be isomorphic to the Identity Functor.

Instances

 Settable Identity so you can pass our a Setter into combinators from other lens libraries Settable Mutator (Applicative (Backwards f), Settable f) => Settable (Backwards f) (Applicative (Compose f g), Settable f, Settable g) => Settable (Compose f g)

data Mutator a Source

Mutator is just a renamed Identity functor to give better error messages when someone attempts to use a getter as a setter.

Most user code will never need to see this type.

Instances

 Functor Mutator Applicative Mutator Settable Mutator