Control.Lens.Setter

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 | None
Language | Haskell98

Control.Lens.Setter

Contents

- Setters
- Building Setters
- Common Setters
- Functional Combinators
- State Combinators
- Writer Combinators
- Simplified State Setting
- Indexed Setters
- Arrow operators
- Exported for legible error messages
- Deprecated

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

- type Setter s t a b = forall f. Settable f => (a -> f b) -> s -> f t
- type Setter' s a = Setter s s a a
- type IndexedSetter i s t a b = forall f p. (Indexable i p, Settable f) => p a (f b) -> s -> f t
- type IndexedSetter' i s a = IndexedSetter i s s a a
- type ASetter s t a b = (a -> Identity b) -> s -> Identity t
- type ASetter' s a = ASetter s s a a
- type AnIndexedSetter i s t a b = Indexed i a (Identity b) -> s -> Identity t
- type AnIndexedSetter' i s a = AnIndexedSetter i s s a a
- type Setting p s t a b = p a (Identity b) -> s -> Identity t
- type Setting' p s a = Setting p s s a a
- sets :: (Profunctor p, Profunctor q, Settable f) => (p a b -> q s t) -> Optical p q f s t a b
- setting :: ((a -> b) -> s -> t) -> IndexPreservingSetter s t a b
- cloneSetter :: ASetter s t a b -> Setter s t a b
- cloneIndexPreservingSetter :: ASetter s t a b -> IndexPreservingSetter s t a b
- cloneIndexedSetter :: AnIndexedSetter i s t a b -> IndexedSetter i s t a b
- mapped :: Functor f => Setter (f a) (f b) a b
- lifted :: Monad m => Setter (m a) (m b) a b
- contramapped :: Contravariant f => Setter (f b) (f a) a b
- argument :: Profunctor p => Setter (p b r) (p a r) a b
- over :: ASetter s t a b -> (a -> b) -> s -> t
- set :: ASetter s t a b -> b -> s -> t
- (.~) :: ASetter s t a b -> b -> s -> t
- (%~) :: ASetter s t a b -> (a -> b) -> s -> t
- (+~) :: Num a => ASetter s t a a -> a -> s -> t
- (-~) :: Num a => ASetter s t a a -> a -> s -> t
- (*~) :: Num a => ASetter s t a a -> a -> s -> t
- (//~) :: Fractional a => ASetter s t a a -> a -> s -> t
- (^~) :: (Num a, Integral e) => ASetter s t a a -> e -> s -> t
- (^^~) :: (Fractional a, Integral e) => ASetter s t a a -> e -> s -> t
- (**~) :: Floating a => ASetter s t a a -> a -> s -> t
- (||~) :: ASetter s t Bool Bool -> Bool -> s -> t
- (<>~) :: Monoid a => ASetter s t a a -> a -> s -> t
- (&&~) :: ASetter s t Bool Bool -> Bool -> s -> t
- (<.~) :: ASetter s t a b -> b -> s -> (b, t)
- (?~) :: ASetter s t a (Maybe b) -> b -> s -> t
- (<?~) :: ASetter s t a (Maybe b) -> b -> s -> (b, t)
- assign :: MonadState s m => ASetter s s a b -> b -> m ()
- modifying :: MonadState s m => ASetter s s a b -> (a -> b) -> m ()
- (.=) :: MonadState s m => ASetter s s a b -> b -> m ()
- (%=) :: MonadState s m => ASetter s s a b -> (a -> b) -> m ()
- (+=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
- (-=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
- (*=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
- (//=) :: (MonadState s m, Fractional a) => ASetter' s a -> a -> m ()
- (^=) :: (MonadState s m, Num a, Integral e) => ASetter' s a -> e -> m ()
- (^^=) :: (MonadState s m, Fractional a, Integral e) => ASetter' s a -> e -> m ()
- (**=) :: (MonadState s m, Floating a) => ASetter' s a -> a -> m ()
- (||=) :: MonadState s m => ASetter' s Bool -> Bool -> m ()
- (<>=) :: (MonadState s m, Monoid a) => ASetter' s a -> a -> m ()
- (&&=) :: MonadState s m => ASetter' s Bool -> Bool -> m ()
- (<.=) :: MonadState s m => ASetter s s a b -> b -> m b
- (?=) :: MonadState s m => ASetter s s a (Maybe b) -> b -> m ()
- (<?=) :: MonadState s m => ASetter s s a (Maybe b) -> b -> m b
- (<~) :: MonadState s m => ASetter s s a b -> m b -> m ()
- scribe :: (MonadWriter t m, Monoid s) => ASetter s t a b -> b -> m ()
- passing :: MonadWriter w m => Setter w w u v -> m (a, u -> v) -> m a
- ipassing :: MonadWriter w m => IndexedSetter i w w u v -> m (a, i -> u -> v) -> m a
- censoring :: MonadWriter w m => Setter w w u v -> (u -> v) -> m a -> m a
- icensoring :: MonadWriter w m => IndexedSetter i w w u v -> (i -> u -> v) -> m a -> m a
- set' :: ASetter' s a -> a -> s -> s
- imapOf :: AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t
- iover :: AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t
- iset :: AnIndexedSetter i s t a b -> (i -> b) -> s -> t
- imodifying :: MonadState s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m ()
- isets :: ((i -> a -> b) -> s -> t) -> IndexedSetter i s t a b
- (%@~) :: AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t
- (.@~) :: AnIndexedSetter i s t a b -> (i -> b) -> s -> t
- (%@=) :: MonadState s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m ()
- (.@=) :: MonadState s m => AnIndexedSetter i s s a b -> (i -> b) -> m ()
- assignA :: Arrow p => ASetter s t a b -> p s b -> p s t
- class (Applicative f, Distributive f, Traversable f) => Settable f
- newtype Identity a :: * -> * = Identity {
  - runIdentity :: a
  }
- mapOf :: ASetter s t a b -> (a -> b) -> s -> t

# Setters

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

The only `LensLike` 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 id ≡ id
    over l f . over l g ≡ over l (f . g)

These can be stated more directly:

    l pure ≡ pure
    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.

    >>> over traverse f [a,b,c,d]
    [f a,f b,f c,f d]

    >>> over _1 f (a,b)
    (f a,b)

    >>> over (traverse._1) f [(a,b),(c,d)]
    [(f a,b),(f c,d)]

    >>> over both f (a,b)
    (f a,f b)

    >>> over (traverse.both) f [(a,b),(c,d)]
    [(f a,f b),(f c,f d)]

type Setter' s a = Setter s s a a #

A `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 :: Setter' Text Char

    type Setter' = Setter'

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

Every `IndexedSetter` is a valid `Setter`.

The `Setter` laws are still required to hold.

type IndexedSetter' i s a = IndexedSetter i s s a a #

    type IndexedSetter' i = Simple (IndexedSetter i)

type ASetter s t a b = (a -> Identity b) -> s -> Identity t #

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.

type ASetter' s a = ASetter s s a a #

This is a useful alias for use when consuming a `Setter'`.

Most user code will never have to use this type.

    type ASetter' = Simple ASetter

type AnIndexedSetter i s t a b = Indexed i a (Identity b) -> s -> Identity t #

Running an `IndexedSetter` 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.

type AnIndexedSetter' i s a = AnIndexedSetter i s s a a #

    type AnIndexedSetter' i = Simple (AnIndexedSetter i)

type Setting p s t a b = p a (Identity b) -> s -> Identity t #

This is a convenient alias when defining highly polymorphic code that takes both `ASetter` and `AnIndexedSetter` as appropriate. If a function takes this it is expecting one of those two things based on context.

type Setting' p s a = Setting p s s a a #

This is a convenient alias when defining highly polymorphic code that takes both `ASetter'` and `AnIndexedSetter'` as appropriate. If a function takes this it is expecting one of those two things based on context.

# Building Setters

sets :: (Profunctor p, Profunctor q, Settable f) => (p a b -> q s t) -> Optical p q f s t a b #

Build a `Setter`, `IndexedSetter` or `IndexPreservingSetter` depending on your choice of `Profunctor`.

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

setting :: ((a -> b) -> s -> t) -> IndexPreservingSetter s t a b #

Build an index-preserving `Setter` from a map-like function.

Your supplied function `f` is required to satisfy:

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

Equational reasoning:

    setting . over ≡ id
    over . setting ≡ id

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

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

cloneSetter :: ASetter s t a b -> Setter s t a b #

Restore `ASetter` to a full `Setter`.

cloneIndexPreservingSetter :: ASetter s t a b -> IndexPreservingSetter s t a b #

Build an `IndexPreservingSetter` from any `Setter`.

cloneIndexedSetter :: AnIndexedSetter i s t a b -> IndexedSetter i s t a b #

Clone an `IndexedSetter`.

# Common Setters

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

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

    fmap ≡ over mapped
    fmapDefault ≡ over traverse
    (<$) ≡ set mapped

    >>> over mapped f [a,b,c]
    [f a,f b,f c]

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

    >>> set mapped x [a,b,c]
    [x,x,x]

    >>> [[a,b],[c]] & mapped.mapped +~ x
    [[a + x,b + x],[c + x]]

    >>> over (mapped._2) length [("hello","world"),("leaders","!!!")]
    [("hello",5),("leaders",3)]

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

If you want an `IndexPreservingSetter` use ``setting` `fmap``.

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

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

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

    liftM ≡ over lifted

    >>> over lifted f [a,b,c]
    [f a,f b,f c]

    >>> set lifted b (Just a)
    Just b

If you want an `IndexPreservingSetter` use ``setting` `liftM``.

contramapped :: Contravariant f => Setter (f b) (f a) a b #

This `Setter` can be used to map over all of the inputs to a `Contravariant`.

    contramap ≡ over contramapped

    >>> getPredicate (over contramapped (*2) (Predicate even)) 5
    True

    >>> getOp (over contramapped (*5) (Op show)) 100
    "500"

    >>> Prelude.map ($ 1) $ over (mapped . _Unwrapping' Op . contramapped) (*12) [(*2),(+1),(^3)]
    [24,13,1728]

argument :: Profunctor p => Setter (p b r) (p a r) a b #

This `Setter` can be used to map over the input of a `Profunctor`.

The most common `Profunctor` to use this with is `(->)`.

    >>> (argument %~ f) g x
    g (f x)

    >>> (argument %~ show) length [1,2,3]
    7

    >>> (argument %~ f) h x y
    h (f x) y

Map over the argument of the result of a function -- i.e., its second argument:

    >>> (mapped.argument %~ f) h x y
    h x (f y)

    argument :: Setter (b -> r) (a -> r) a b

# Functional Combinators

over :: ASetter s t a b -> (a -> b) -> s -> t #

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

    fmap ≡ over mapped
    fmapDefault ≡ over traverse
    sets . over ≡ id
    over . sets ≡ id

Given any valid `Setter` `l`, you can also rely on the law:

    over l f . over l g = over l (f . g)

e.g.

    >>> over mapped f (over mapped g [a,b,c]) == over mapped (f . g) [a,b,c]
    True

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

    >>> over mapped f (Just a)
    Just (f a)

    >>> over mapped (*10) [1,2,3]
    [10,20,30]

    >>> over _1 f (a,b)
    (f a,b)

    >>> over _1 show (10,20)
    ("10",20)

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

set :: ASetter s t a b -> b -> s -> t #

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

(.~) :: ASetter s t a b -> b -> s -> t infixr 4 #

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

    >>> (a,b,c,d) & _4 .~ e
    (a,b,c,e)

    >>> (42,"world") & _1 .~ "hello"
    ("hello","world")

    >>> (a,b) & both .~ c
    (c,c)

    (.~) :: 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

(%~) :: ASetter s t a b -> (a -> b) -> s -> t infixr 4 #

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

    >>> (a,b,c) & _3 %~ f
    (a,b,f c)

    >>> (a,b) & both %~ f
    (f a,f b)

    >>> _2 %~ length $ (1,"hello")
    (1,5)

    >>> traverse %~ f $ [a,b,c]
    [f a,f b,f c]

    >>> traverse %~ even $ [1,2,3]
    [False,True,False]

    >>> 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 => ASetter s t a a -> a -> s -> t infixr 4 #

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

    >>> (a,b) & _1 +~ c
    (a + c,b)

    >>> (a,b) & both +~ c
    (a + c,b + c)

    >>> (1,2) & _2 +~ 1
    (1,3)

    >>> [(a,b),(c,d)] & traverse.both +~ e
    [(a + e,b + e),(c + e,d + e)]

    (+~) :: Num a => Setter' s a    -> a -> s -> s
    (+~) :: Num a => Iso' s a       -> a -> s -> s
    (+~) :: Num a => Lens' s a      -> a -> s -> s
    (+~) :: Num a => Traversal' s a -> a -> s -> s

(-~) :: Num a => ASetter s t a a -> a -> s -> t infixr 4 #

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

    >>> (a,b) & _1 -~ c
    (a - c,b)

    >>> (a,b) & both -~ c
    (a - c,b - c)

    >>> _1 -~ 2 $ (1,2)
    (-1,2)

    >>> mapped.mapped -~ 1 $ [[4,5],[6,7]]
    [[3,4],[5,6]]

    (-~) :: Num a => Setter' s a    -> a -> s -> s
    (-~) :: Num a => Iso' s a       -> a -> s -> s
    (-~) :: Num a => Lens' s a      -> a -> s -> s
    (-~) :: Num a => Traversal' s a -> a -> s -> s

(*~) :: Num a => ASetter s t a a -> a -> s -> t infixr 4 #

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

    >>> (a,b) & _1 *~ c
    (a * c,b)

    >>> (a,b) & both *~ c
    (a * c,b * c)

    >>> (1,2) & _2 *~ 4
    (1,8)

    >>> Just 24 & mapped *~ 2
    Just 48

    (*~) :: Num a => Setter' s a    -> a -> s -> s
    (*~) :: Num a => Iso' s a       -> a -> s -> s
    (*~) :: Num a => Lens' s a      -> a -> s -> s
    (*~) :: Num a => Traversal' s a -> a -> s -> s

(//~) :: Fractional a => ASetter s t a a -> a -> s -> t infixr 4 #

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

    >>> (a,b) & _1 //~ c
    (a / c,b)

    >>> (a,b) & both //~ c
    (a / c,b / c)

    >>> ("Hawaii",10) & _2 //~ 2
    ("Hawaii",5.0)

    (//~) :: Fractional a => Setter' s a    -> a -> s -> s
    (//~) :: Fractional a => Iso' s a       -> a -> s -> s
    (//~) :: Fractional a => Lens' s a      -> a -> s -> s
    (//~) :: Fractional a => Traversal' s a -> a -> s -> s

(^~) :: (Num a, Integral e) => ASetter s t a a -> e -> s -> t infixr 4 #

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

    >>> (1,3) & _2 ^~ 2
    (1,9)

    (^~) :: (Num a, Integral e) => Setter' s a    -> e -> s -> s
    (^~) :: (Num a, Integral e) => Iso' s a       -> e -> s -> s
    (^~) :: (Num a, Integral e) => Lens' s a      -> e -> s -> s
    (^~) :: (Num a, Integral e) => Traversal' s a -> e -> s -> s

(^^~) :: (Fractional a, Integral e) => ASetter s t a a -> e -> s -> t infixr 4 #

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

    >>> (1,2) & _2 ^^~ (-1)
    (1,0.5)

    (^^~) :: (Fractional a, Integral e) => Setter' s a    -> e -> s -> s
    (^^~) :: (Fractional a, Integral e) => Iso' s a       -> e -> s -> s
    (^^~) :: (Fractional a, Integral e) => Lens' s a      -> e -> s -> s
    (^^~) :: (Fractional a, Integral e) => Traversal' s a -> e -> s -> s

(**~) :: Floating a => ASetter s t a a -> a -> s -> t infixr 4 #

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

    >>> (a,b) & _1 **~ c
    (a**c,b)

    >>> (a,b) & both **~ c
    (a**c,b**c)

    >>> _2 **~ 10 $ (3,2)
    (3,1024.0)

    (**~) :: Floating a => Setter' s a    -> a -> s -> s
    (**~) :: Floating a => Iso' s a       -> a -> s -> s
    (**~) :: Floating a => Lens' s a      -> a -> s -> s
    (**~) :: Floating a => Traversal' s a -> a -> s -> s

(||~) :: ASetter s t Bool Bool -> Bool -> s -> t infixr 4 #

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

    >>> both ||~ True $ (False,True)
    (True,True)

    >>> both ||~ False $ (False,True)
    (False,True)

    (||~) :: Setter' s Bool    -> Bool -> s -> s
    (||~) :: Iso' s Bool       -> Bool -> s -> s
    (||~) :: Lens' s Bool      -> Bool -> s -> s
    (||~) :: Traversal' s Bool -> Bool -> s -> s

(<>~) :: Monoid a => ASetter s t a a -> a -> s -> t infixr 4 #

Modify the target of a monoidally valued by `mappend`ing another value.

    >>> (Sum a,b) & _1 <>~ Sum c
    (Sum {getSum = a + c},b)

    >>> (Sum a,Sum b) & both <>~ Sum c
    (Sum {getSum = a + c},Sum {getSum = b + c})

    >>> both <>~ "!!!" $ ("hello","world")
    ("hello!!!","world!!!")

    (<>~) :: Monoid a => Setter s t a a    -> a -> s -> t
    (<>~) :: Monoid a => Iso s t a a       -> a -> s -> t
    (<>~) :: Monoid a => Lens s t a a      -> a -> s -> t
    (<>~) :: Monoid a => Traversal s t a a -> a -> s -> t

(&&~) :: ASetter s t Bool Bool -> Bool -> s -> t infixr 4 #

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

    >>> both &&~ True $ (False, True)
    (False,True)

    >>> both &&~ False $ (False, True)
    (False,False)

    (&&~) :: Setter' s Bool    -> Bool -> s -> s
    (&&~) :: Iso' s Bool       -> Bool -> s -> s
    (&&~) :: Lens' s Bool      -> Bool -> s -> s
    (&&~) :: Traversal' s Bool -> Bool -> s -> s

(<.~) :: ASetter s t a b -> b -> s -> (b, t) infixr 4 #

Set with pass-through.

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

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

    >>> (a,b) & _1 <.~ c
    (c,(c,b))

    >>> ("good","morning","vietnam") & _3 <.~ "world"
    ("world",("good","morning","world"))

    >>> (42,Map.fromList [("goodnight","gracie")]) & _2.at "hello" <.~ Just "world"
    (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)

(?~) :: ASetter s t a (Maybe b) -> b -> s -> t infixr 4 #

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

    l ?~ t ≡ set l (Just t)

    >>> Nothing & id ?~ a
    Just a

    >>> Map.empty & at 3 ?~ x
    fromList [(3,x)]

    (?~) :: 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

(<?~) :: ASetter s t a (Maybe b) -> b -> s -> (b, t) infixr 4 #

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 (Maybe b)    -> 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 => ASetter s s a b -> b -> m () #

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 (`.=`).

    >>> execState (do assign _1 c; assign _2 d) (a,b)
    (c,d)

    >>> execState (both .= c) (a,b)
    (c,c)

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

modifying :: MonadState s m => ASetter s s a b -> (a -> b) -> m () #

This is an alias for (`%=`).

(.=) :: MonadState s m => ASetter s s a b -> b -> m () infix 4 #

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`.

    >>> execState (do _1 .= c; _2 .= d) (a,b)
    (c,d)

    >>> execState (both .= c) (a,b)
    (c,c)

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

It puts the state in the monad or it gets the hose again.

(%=) :: MonadState s m => ASetter s s a b -> (a -> b) -> m () infix 4 #

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

    >>> execState (do _1 %= f;_2 %= g) (a,b)
    (f a,g b)

    >>> execState (do both %= f) (a,b)
    (f a,f b)

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

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

(+=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m () infix 4 #

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

Example:

    fresh :: MonadState Int m => m Int
    fresh = do
      id += 1
      use id

    >>> execState (do _1 += c; _2 += d) (a,b)
    (a + c,b + d)

    >>> execState (do _1.at 1.non 0 += 10) (Map.fromList [(2,100)],"hello")
    (fromList [(1,10),(2,100)],"hello")

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

(-=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m () infix 4 #

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

    >>> execState (do _1 -= c; _2 -= d) (a,b)
    (a - c,b - d)

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

(*=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m () infix 4 #

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

    >>> execState (do _1 *= c; _2 *= d) (a,b)
    (a * c,b * d)

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

(//=) :: (MonadState s m, Fractional a) => ASetter' s a -> a -> m () infix 4 #

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

    >>> execState (do _1 //= c; _2 //= d) (a,b)
    (a / c,b / d)

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

(^=) :: (MonadState s m, Num a, Integral e) => ASetter' s a -> e -> m () infix 4 #

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) => Setter' s a    -> e -> m ()
    (^=) ::  (MonadState s m, Num a, Integral e) => Iso' s a       -> e -> m ()
    (^=) ::  (MonadState s m, Num a, Integral e) => Lens' s a      -> e -> m ()
    (^=) ::  (MonadState s m, Num a, Integral e) => Traversal' s a -> e -> m ()

(^^=) :: (MonadState s m, Fractional a, Integral e) => ASetter' s a -> e -> m () infix 4 #

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

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

(**=) :: (MonadState s m, Floating a) => ASetter' s a -> a -> m () infix 4 #

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

    >>> execState (do _1 **= c; _2 **= d) (a,b)
    (a**c,b**d)

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

(||=) :: MonadState s m => ASetter' s Bool -> Bool -> m () infix 4 #

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

    >>> execState (do _1 ||= True; _2 ||= False; _3 ||= True; _4 ||= False) (True,True,False,False)
    (True,True,True,False)

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

(<>=) :: (MonadState s m, Monoid a) => ASetter' s a -> a -> m () infix 4 #

Modify the target(s) of a `Lens'`, `Iso`, `Setter` or `Traversal` by `mappend`ing a value.

    >>> execState (do _1 <>= Sum c; _2 <>= Product d) (Sum a,Product b)
    (Sum {getSum = a + c},Product {getProduct = b * d})

    >>> execState (both <>= "!!!") ("hello","world")
    ("hello!!!","world!!!")

    (<>=) :: (MonadState s m, Monoid a) => Setter' s a -> a -> m ()
    (<>=) :: (MonadState s m, Monoid a) => Iso' s a -> a -> m ()
    (<>=) :: (MonadState s m, Monoid a) => Lens' s a -> a -> m ()
    (<>=) :: (MonadState s m, Monoid a) => Traversal' s a -> a -> m ()

(&&=) :: MonadState s m => ASetter' s Bool -> Bool -> m () infix 4 #

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

    >>> execState (do _1 &&= True; _2 &&= False; _3 &&= True; _4 &&= False) (True,True,False,False)
    (True,False,False,False)

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

(<.=) :: MonadState s m => ASetter s s a b -> b -> m b infix 4 #

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 => ASetter s s a (Maybe b) -> b -> m () infix 4 #

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.

    >>> execState (do at 1 ?= a; at 2 ?= b) Map.empty
    fromList [(1,a),(2,b)]

    >>> execState (do _1 ?= b; _2 ?= c) (Just a, Nothing)
    (Just b,Just c)

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

(<?=) :: MonadState s m => ASetter s s a (Maybe b) -> b -> m b infix 4 #

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 => ASetter s s a b -> m b -> m () infixr 2 #

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`.

# Writer Combinators

scribe :: (MonadWriter t m, Monoid s) => ASetter s t a b -> b -> m () #

Write to a fragment of a larger `Writer` format.

passing :: MonadWriter w m => Setter w w u v -> m (a, u -> v) -> m a #

This is a generalization of `pass` that alows you to modify just a portion of the resulting `MonadWriter`.

ipassing :: MonadWriter w m => IndexedSetter i w w u v -> m (a, i -> u -> v) -> m a #

This is a generalization of `pass` that alows you to modify just a portion of the resulting `MonadWriter` with access to the index of an `IndexedSetter`.

censoring :: MonadWriter w m => Setter w w u v -> (u -> v) -> m a -> m a #

This is a generalization of `censor` that alows you to `censor` just a portion of the resulting `MonadWriter`.

icensoring :: MonadWriter w m => IndexedSetter i w w u v -> (i -> u -> v) -> m a -> m a #

This is a generalization of `censor` that alows you to `censor` just a portion of the resulting `MonadWriter`, with access to the index of an `IndexedSetter`.

# Simplified State Setting

set' :: ASetter' s a -> a -> s -> s #

Replace the target of a `Lens` or all of the targets of a `Setter'` or `Traversal` with a constant value, without changing its type.

This is a type restricted version of `set`, which retains the type of the original.

    >>> set' mapped x [a,b,c,d]
    [x,x,x,x]

    >>> set' _2 "hello" (1,"world")
    (1,"hello")

    >>> set' mapped 0 [1,2,3,4]
    [0,0,0,0]

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

    set' :: Setter' s a    -> a -> s -> s
    set' :: Iso' s a       -> a -> s -> s
    set' :: Lens' s a      -> a -> s -> s
    set' :: Traversal' s a -> a -> s -> s

# Indexed Setters

imapOf :: AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t #

Deprecated: Use `iover`

Map with index. (Deprecated alias for `iover`).

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 :: AnIndexedSetter i 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 l ≡ over l . Indexed

    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

iset :: AnIndexedSetter i s t a b -> (i -> b) -> s -> t #

Set with index. Equivalent to `iover` with the current value ignored.

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

    set l ≡ iset l . const

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

imodifying :: MonadState s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m () #

This is an alias for (`%@=`).

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 `isets` is that it takes a "semantic editor combinator" which has been modified to carry an index and transforms it into a `IndexedSetter`.

(%@~) :: AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t infixr 4 #

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

    (%@~) ≡ iover

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

(.@~) :: AnIndexedSetter i s t a b -> (i -> b) -> s -> t infixr 4 #

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

    (.@~) ≡ iset

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

    l .~ b ≡ l .@~ const b

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

(%@=) :: MonadState s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m () infix 4 #

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 ()

(.@=) :: MonadState s m => AnIndexedSetter i s s a b -> (i -> b) -> m () infix 4 #

Replace 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 .= b ≡ l .@= const b

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

# Arrow operators

assignA :: Arrow p => ASetter s t a b -> p s b -> p s t #

Run an arrow command and use the output to set all the targets of a `Lens`, `Setter` or `Traversal` to the result.

`assignA` can be used very similarly to (`<~`), except that the type of the object being modified can change; for example:

    runKleisli action ((), (), ()) where
      action =      assignA _1 (Kleisli (const getVal1))
               >>> assignA _2 (Kleisli (const getVal2))
               >>> assignA _3 (Kleisli (const getVal3))
      getVal1 :: Either String Int
      getVal1 = ...
      getVal2 :: Either String Bool
      getVal2 = ...
      getVal3 :: Either String Char
      getVal3 = ...

has the type ``Either` `String` (`Int`, `Bool`, `Char`)`

    assignA :: Arrow p => Iso s t a b       -> p s b -> p s t
    assignA :: Arrow p => Lens s t a b      -> p s b -> p s t
    assignA :: Arrow p => Traversal s t a b -> p s b -> p s t
    assignA :: Arrow p => Setter s t a b    -> p s b -> p s t

# Exported for legible error messages

class (Applicative f, Distributive f, Traversable f) => Settable f #

Anything `Settable` must be isomorphic to the `Identity` `Functor`.

Minimal complete definition

untainted

Instances

Settable Identity # | So you can pass our `Setter` into combinators from other lens libraries.
Methods untainted :: Identity a -> a # untaintedDot :: Profunctor p => p a (Identity b) -> p a b # taintedDot :: Profunctor p => p a b -> p a (Identity b) #
Settable f => Settable (Backwards * f) # | `backwards`
Methods untainted :: Backwards * f a -> a # untaintedDot :: Profunctor p => p a (Backwards * f b) -> p a b # taintedDot :: Profunctor p => p a b -> p a (Backwards * f b) #
(Settable f, Settable g) => Settable (Compose * * f g) # |
Methods untainted :: Compose * * f g a -> a # untaintedDot :: Profunctor p => p a (Compose * * f g b) -> p a b # taintedDot :: Profunctor p => p a b -> p a (Compose * * f g b) #

newtype Identity a :: * -> * #

Identity functor and monad. (a non-strict monad)

Since: 4.8.0.0

Constructors

Identity |
Fields runIdentity :: a

Instances

Monad Identity |
Methods (>>=) :: Identity a -> (a -> Identity b) -> Identity b # (>>) :: Identity a -> Identity b -> Identity b # return :: a -> Identity a # fail :: String -> Identity a #
Functor Identity |
Methods fmap :: (a -> b) -> Identity a -> Identity b # (<$) :: a -> Identity b -> Identity a #
MonadFix Identity |
Methods mfix :: (a -> Identity a) -> Identity a #
Applicative Identity |
Methods pure :: a -> Identity a # (<*>) :: Identity (a -> b) -> Identity a -> Identity b # (*>) :: Identity a -> Identity b -> Identity b # (<*) :: Identity a -> Identity b -> Identity a #
Foldable Identity |
Methods fold :: Monoid m => Identity m -> m # foldMap :: Monoid m => (a -> m) -> Identity a -> m # foldr :: (a -> b -> b) -> b -> Identity a -> b # foldr' :: (a -> b -> b) -> b -> Identity a -> b # foldl :: (b -> a -> b) -> b -> Identity a -> b # foldl' :: (b -> a -> b) -> b -> Identity a -> b # foldr1 :: (a -> a -> a) -> Identity a -> a # foldl1 :: (a -> a -> a) -> Identity a -> a # toList :: Identity a -> [a] # null :: Identity a -> Bool # length :: Identity a -> Int # elem :: Eq a => a -> Identity a -> Bool # maximum :: Ord a => Identity a -> a # minimum :: Ord a => Identity a -> a # sum :: Num a => Identity a -> a # product :: Num a => Identity a -> 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) #
Generic1 Identity |
Associated Types type Rep1 (Identity :: * -> *) :: * -> * # Methods from1 :: Identity a -> Rep1 Identity a # to1 :: Rep1 Identity a -> Identity a #
Distributive Identity |
Methods distribute :: Functor f => f (Identity a) -> Identity (f a) # collect :: Functor f => (a -> Identity b) -> f a -> Identity (f b) # distributeM :: Monad m => m (Identity a) -> Identity (m a) # collectM :: Monad m => (a -> Identity b) -> m a -> Identity (m b) #
Representable Identity |
Associated Types type Rep (Identity :: * -> *) :: * # Methods tabulate :: (Rep Identity -> a) -> Identity a # index :: Identity a -> Rep Identity -> a #
Eq1 Identity |
Methods liftEq :: (a -> b -> Bool) -> Identity a -> Identity b -> Bool #
Ord1 Identity |
Methods liftCompare :: (a -> b -> Ordering) -> Identity a -> Identity b -> Ordering #
Read1 Identity |
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Identity a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Identity a] #
Show1 Identity |
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Identity a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Identity a] -> ShowS #
MonadZip Identity |
Methods mzip :: Identity a -> Identity b -> Identity (a, b) # mzipWith :: (a -> b -> c) -> Identity a -> Identity b -> Identity c # munzip :: Identity (a, b) -> (Identity a, Identity b) #
Comonad Identity |
Methods extract :: Identity a -> a # duplicate :: Identity a -> Identity (Identity a) # extend :: (Identity a -> b) -> Identity a -> Identity b #
ComonadApply Identity |
Methods (<@>) :: Identity (a -> b) -> Identity a -> Identity b # (@>) :: Identity a -> Identity b -> Identity b # (<@) :: Identity a -> Identity b -> Identity a #
Hashable1 Identity |
Methods liftHashWithSalt :: (Int -> a -> Int) -> Int -> Identity a -> Int #
Traversable1 Identity |
Methods traverse1 :: Apply f => (a -> f b) -> Identity a -> f (Identity b) # sequence1 :: Apply f => Identity (f b) -> f (Identity b) #
Apply Identity |
Methods (<.>) :: Identity (a -> b) -> Identity a -> Identity b # (.>) :: Identity a -> Identity b -> Identity b # (<.) :: Identity a -> Identity b -> Identity a #
Bind Identity |
Methods (>>-) :: Identity a -> (a -> Identity b) -> Identity b # join :: Identity (Identity a) -> Identity a #
Extend Identity |
Methods duplicated :: Identity a -> Identity (Identity a) # extended :: (Identity a -> b) -> Identity a -> Identity b #
Foldable1 Identity |
Methods fold1 :: Semigroup m => Identity m -> m # foldMap1 :: Semigroup m => (a -> m) -> Identity a -> m #
Settable Identity # | So you can pass our `Setter` into combinators from other lens libraries.
Methods untainted :: Identity a -> a # untaintedDot :: Profunctor p => p a (Identity b) -> p a b # taintedDot :: Profunctor p => p a b -> p a (Identity b) #
Sieve (->) Identity |
Methods sieve :: (a -> b) -> a -> Identity b #
Sieve ReifiedGetter Identity # |
Methods sieve :: ReifiedGetter a b -> a -> Identity b #
Cosieve (->) Identity |
Methods cosieve :: (a -> b) -> Identity a -> b #
Cosieve ReifiedGetter Identity # |
Methods cosieve :: ReifiedGetter a b -> Identity a -> b #
TraversableWithIndex () Identity # |
Methods itraverse :: Applicative f => (() -> a -> f b) -> Identity a -> f (Identity b) # itraversed :: (Indexable () p, Applicative f) => p a (f b) -> Identity a -> f (Identity b) #
FoldableWithIndex () Identity # |
Methods ifoldMap :: Monoid m => (() -> a -> m) -> Identity a -> m # ifolded :: (Indexable () p, Contravariant f, Applicative f) => p a (f a) -> Identity a -> f (Identity a) # ifoldr :: (() -> a -> b -> b) -> b -> Identity a -> b # ifoldl :: (() -> b -> a -> b) -> b -> Identity a -> b # ifoldr' :: (() -> a -> b -> b) -> b -> Identity a -> b # ifoldl' :: (() -> b -> a -> b) -> b -> Identity a -> b #
FunctorWithIndex () Identity # |
Methods imap :: (() -> a -> b) -> Identity a -> Identity b # imapped :: (Indexable () p, Settable f) => p a (f b) -> Identity a -> f (Identity b) #
Comonad w => ComonadCofree Identity (CoiterT w) |
Methods unwrap :: CoiterT w a -> Identity (CoiterT w a) #
Monad m => MonadFree Identity (IterT m) |
Methods wrap :: Identity (IterT m a) -> IterT m a #
Bounded a => Bounded (Identity a) |
Methods minBound :: Identity a # maxBound :: Identity a #
Enum a => Enum (Identity a) |
Methods succ :: Identity a -> Identity a # pred :: Identity a -> Identity a # toEnum :: Int -> Identity a # fromEnum :: Identity a -> Int # enumFrom :: Identity a -> [Identity a] # enumFromThen :: Identity a -> Identity a -> [Identity a] # enumFromTo :: Identity a -> Identity a -> [Identity a] # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] #
Eq a => Eq (Identity a) |
Methods (==) :: Identity a -> Identity a -> Bool # (/=) :: Identity a -> Identity a -> Bool #
Floating a => Floating (Identity a) |
Methods pi :: Identity a # exp :: Identity a -> Identity a # log :: Identity a -> Identity a # sqrt :: Identity a -> Identity a # (**) :: Identity a -> Identity a -> Identity a # logBase :: Identity a -> Identity a -> Identity a # sin :: Identity a -> Identity a # cos :: Identity a -> Identity a # tan :: Identity a -> Identity a # asin :: Identity a -> Identity a # acos :: Identity a -> Identity a # atan :: Identity a -> Identity a # sinh :: Identity a -> Identity a # cosh :: Identity a -> Identity a # tanh :: Identity a -> Identity a # asinh :: Identity a -> Identity a # acosh :: Identity a -> Identity a # atanh :: Identity a -> Identity a # log1p :: Identity a -> Identity a # expm1 :: Identity a -> Identity a # log1pexp :: Identity a -> Identity a # log1mexp :: Identity a -> Identity a #
Fractional a => Fractional (Identity a) |
Methods (/) :: Identity a -> Identity a -> Identity a # recip :: Identity a -> Identity a # fromRational :: Rational -> Identity a #
Integral a => Integral (Identity a) |
Methods quot :: Identity a -> Identity a -> Identity a # rem :: Identity a -> Identity a -> Identity a # div :: Identity a -> Identity a -> Identity a # mod :: Identity a -> Identity a -> Identity a # quotRem :: Identity a -> Identity a -> (Identity a, Identity a) # divMod :: Identity a -> Identity a -> (Identity a, Identity a) # toInteger :: Identity a -> Integer #
Data a => Data (Identity a) |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Identity a -> c (Identity a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Identity a) # toConstr :: Identity a -> Constr # dataTypeOf :: Identity a -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Identity a)) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Identity a)) # gmapT :: (forall b. Data b => b -> b) -> Identity a -> Identity a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Identity a -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Identity a -> r # gmapQ :: (forall d. Data d => d -> u) -> Identity a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Identity a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) #
Num a => Num (Identity a) |
Methods (+) :: Identity a -> Identity a -> Identity a # (-) :: Identity a -> Identity a -> Identity a # (*) :: Identity a -> Identity a -> Identity a # negate :: Identity a -> Identity a # abs :: Identity a -> Identity a # signum :: Identity a -> Identity a # fromInteger :: Integer -> Identity a #
Ord a => Ord (Identity a) |
Methods compare :: Identity a -> Identity a -> Ordering # (<) :: Identity a -> Identity a -> Bool # (<=) :: Identity a -> Identity a -> Bool # (>) :: Identity a -> Identity a -> Bool # (>=) :: Identity a -> Identity a -> Bool # max :: Identity a -> Identity a -> Identity a # min :: Identity a -> Identity a -> Identity a #
Read a => Read (Identity a) | This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed
Methods readsPrec :: Int -> ReadS (Identity a) # readList :: ReadS [Identity a] # readPrec :: ReadPrec (Identity a) # readListPrec :: ReadPrec [Identity a] #
Real a => Real (Identity a) |
Methods toRational :: Identity a -> Rational #
RealFloat a => RealFloat (Identity a) |
Methods floatRadix :: Identity a -> Integer # floatDigits :: Identity a -> Int # floatRange :: Identity a -> (Int, Int) # decodeFloat :: Identity a -> (Integer, Int) # encodeFloat :: Integer -> Int -> Identity a # exponent :: Identity a -> Int # significand :: Identity a -> Identity a # scaleFloat :: Int -> Identity a -> Identity a # isNaN :: Identity a -> Bool # isInfinite :: Identity a -> Bool # isDenormalized :: Identity a -> Bool # isNegativeZero :: Identity a -> Bool # isIEEE :: Identity a -> Bool # atan2 :: Identity a -> Identity a -> Identity a #
RealFrac a => RealFrac (Identity a) |
Methods properFraction :: Integral b => Identity a -> (b, Identity a) # truncate :: Integral b => Identity a -> b # round :: Integral b => Identity a -> b # ceiling :: Integral b => Identity a -> b # floor :: Integral b => Identity a -> b #
Show a => Show (Identity a) | This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed
Methods showsPrec :: Int -> Identity a -> ShowS # show :: Identity a -> String # showList :: [Identity a] -> ShowS #
Ix a => Ix (Identity a) |
Methods range :: (Identity a, Identity a) -> [Identity a] # index :: (Identity a, Identity a) -> Identity a -> Int # unsafeIndex :: (Identity a, Identity a) -> Identity a -> Int inRange :: (Identity a, Identity a) -> Identity a -> Bool # rangeSize :: (Identity a, Identity a) -> Int # unsafeRangeSize :: (Identity a, Identity a) -> Int
IsString a => IsString (Identity a) |
Methods fromString :: String -> Identity a #
Generic (Identity a) |
Associated Types type Rep (Identity a) :: * -> * # Methods from :: Identity a -> Rep (Identity a) x # to :: Rep (Identity a) x -> Identity a #
Semigroup a => Semigroup (Identity a) |
Methods (<>) :: Identity a -> Identity a -> Identity a # sconcat :: NonEmpty (Identity a) -> Identity a # stimes :: Integral b => b -> Identity a -> Identity a #
Monoid a => Monoid (Identity a) |
Methods mempty :: Identity a # mappend :: Identity a -> Identity a -> Identity a # mconcat :: [Identity a] -> Identity a #
Storable a => Storable (Identity a) |
Methods sizeOf :: Identity a -> Int # alignment :: Identity a -> Int # peekElemOff :: Ptr (Identity a) -> Int -> IO (Identity a) # pokeElemOff :: Ptr (Identity a) -> Int -> Identity a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Identity a) # pokeByteOff :: Ptr b -> Int -> Identity a -> IO () # peek :: Ptr (Identity a) -> IO (Identity a) # poke :: Ptr (Identity a) -> Identity a -> IO () #
Bits a => Bits (Identity a) |
Methods (.&.) :: Identity a -> Identity a -> Identity a # (.|.) :: Identity a -> Identity a -> Identity a # xor :: Identity a -> Identity a -> Identity a # complement :: Identity a -> Identity a # shift :: Identity a -> Int -> Identity a # rotate :: Identity a -> Int -> Identity a # zeroBits :: Identity a # bit :: Int -> Identity a # setBit :: Identity a -> Int -> Identity a # clearBit :: Identity a -> Int -> Identity a # complementBit :: Identity a -> Int -> Identity a # testBit :: Identity a -> Int -> Bool # bitSizeMaybe :: Identity a -> Maybe Int # bitSize :: Identity a -> Int # isSigned :: Identity a -> Bool # shiftL :: Identity a -> Int -> Identity a # unsafeShiftL :: Identity a -> Int -> Identity a # shiftR :: Identity a -> Int -> Identity a # unsafeShiftR :: Identity a -> Int -> Identity a # rotateL :: Identity a -> Int -> Identity a # rotateR :: Identity a -> Int -> Identity a # popCount :: Identity a -> Int #
FiniteBits a => FiniteBits (Identity a) |
Methods finiteBitSize :: Identity a -> Int # countLeadingZeros :: Identity a -> Int # countTrailingZeros :: Identity a -> Int #
Hashable a => Hashable (Identity a) |
Methods hashWithSalt :: Int -> Identity a -> Int # hash :: Identity a -> Int #
Wrapped (Identity a) # |
Associated Types type Unwrapped (Identity a) :: * # Methods _Wrapped' :: Iso' (Identity a) (Unwrapped (Identity a)) #
Ixed (Identity a) # |
Methods ix :: Index (Identity a) -> Traversal' (Identity a) (IxValue (Identity a)) #
(~) * t (Identity b) => Rewrapped (Identity a) t # |
Field1 (Identity a) (Identity b) a b # |
Methods _1 :: Lens (Identity a) (Identity b) a b #
Each (Identity a) (Identity b) a b # |
    each :: Traversal (Identity a) (Identity b) a b
Methods each :: Traversal (Identity a) (Identity b) a b #
type Rep1 Identity |
type Rep1 Identity = D1 (MetaData "Identity" "Data.Functor.Identity" "base" True) (C1 (MetaCons "Identity" PrefixI True) (S1 (MetaSel (Just Symbol "runIdentity") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))
type Rep Identity |
type Rep Identity = ()
type Rep (Identity a) |
type Rep (Identity a) = D1 (MetaData "Identity" "Data.Functor.Identity" "base" True) (C1 (MetaCons "Identity" PrefixI True) (S1 (MetaSel (Just Symbol "runIdentity") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))
type Unwrapped (Identity a) # |
type Unwrapped (Identity a) = a
type IxValue (Identity a) # |
type IxValue (Identity a) = a
type Index (Identity a) # |
type Index (Identity a) = ()

# Deprecated

mapOf :: ASetter s t a b -> (a -> b) -> s -> t #

Deprecated: Use `over`

`mapOf` is a deprecated alias for `over`.