<<

Put something inside an HTML element.

Precomposition with a pure function (right-to-left variant).

(<>) a Semigroup value onto the front of the target of a Lens into your Monad's state and return the old result. However, unlike (<<<>=), it is prepended to the head side. When you do not need the result of the operation, (<>:=) is more flexible.

(<>) a Semigroup value onto the front of the target of a Lens and return the old result. However, unlike (<<>~), it is prepended to the head side. When you do not need the result of the operation, (<>:~) is more flexible.

(<|) a value onto the target of a Lens into your Monad's state and return the old result. When you do not need the result of the operation, (<|=) is more flexible.

(<|) a value onto the target of a Lens and return the old result. When you do not need the result of the operation, (<|~) is more flexible.

(|>) a value onto the target of a Lens into your Monad's state and return the old result. When you do not need the result of the operation, (|>=) is more flexible.

(|>) a value onto the target of a Lens and return the old result. When you do not need the result of the operation, (|>~) is more flexible.

(<|) a value onto the target of a Lens into your Monad's state and return the result. When you do not need the result of the operation, (<|=) is more flexible.

(<|) a value onto the target of a Lens and return the result. When you do not need the result of the operation, (<|~) is more flexible.

Modify the target of a Lens into your Monad's state by a user supplied function and return the old value that was replaced. When applied to a Traversal, this will return a monoidal summary of all of the old values present. When you do not need the result of the operation, (%=) is more flexible.

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

(<<%=) :: MonadState s m => LensLike ((,)a) s s a b -> (a -> b) -> m a

Adjust the target of an IndexedLens returning the old value, or adjust all of the targets of an IndexedTraversal within the current state, and return a monoidal summary of the old values.

(<<%@=) :: MonadState s m                 => IndexedLens i s s a b      -> (i -> a -> b) -> m a
(<<%@=) :: (MonadState s m, Monoid b) => IndexedTraversal i s s a b -> (i -> a -> b) -> m a

Adjust the target of an IndexedLens returning the old value, or adjust all of the targets of an IndexedTraversal and return a monoidal summary of the old values along with the answer.

(<<%@~) ::             IndexedLens i s t a b      -> (i -> a -> b) -> s -> (a, t)
(<<%@~) :: Monoid a => IndexedTraversal i s t a b -> (i -> a -> b) -> s -> (a, t)

Modify the target of a Lens, but return the old value. When you do not need the old value, (%~) is more flexible.

(<<%~) ::             Lens s t a b      -> (a -> b) -> s -> (a, t)
(<<%~) ::             Iso s t a b       -> (a -> b) -> s -> (a, t)
(<<%~) :: Monoid a => Traversal s t a b -> (a -> b) -> s -> (a, t)

Modify the target of a Lens into your Monad's state by taking its logical && with a value and return the old value that was replaced. When you do not need the result of the operation, (&&=) is more flexible.

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

Logically && the target of a Bool-valued Lens and return the old value. When you do not need the old value, (&&~) is more flexible.

>>> (False,6) & _1 <<&&~ True
(False,(False,6))

>>> ("hello",True) & _2 <<&&~ False
(True,("hello",False))

(<<&&~) :: Lens' s Bool -> Bool -> s -> (Bool, s)
(<<&&~) :: Iso' s Bool -> Bool -> s -> (Bool, s)

Modify the target of a Lens into your Monad's state by raising it by an arbitrary power and return the old value that was replaced. When you do not need the result of the operation, (**=) is more flexible.

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

Raise the target of a floating-point valued Lens to an arbitrary power and return the old value. When you do not need the old value, (**~) is more flexible.

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

>>> (a,b) & _2 <<**~ c
(b,(a,b**c))

(<<**~) :: Floating a => Lens' s a -> a -> s -> (a, s)
(<<**~) :: Floating a => Iso' s a -> a -> s -> (a, s)

Modify the target of a Lens into your Monad's state by multipling a value and return the old value that was replaced. When you do not need the result of the operation, (*=) is more flexible.

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

Multiply the target of a numerically valued Lens and return the old value. When you do not need the old value, (-~) is more flexible.

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

>>> (a,b) & _2 <<*~ c
(b,(a,b * c))

(<<*~) :: Num a => Lens' s a -> a -> s -> (a, s)
(<<*~) :: Num a => Iso' s a -> a -> s -> (a, s)

Modify the target of a Lens into your Monad's state by adding a value and return the old value that was replaced. When you do not need the result of the operation, (+=) is more flexible.

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