Reverse an optic to obtain its dual.

>>> 5 ^. re left'
Left 5

>>> 6 ^. re (left' . from succ)
Left 7

re . re  ≡ id

re :: Iso s t a b   -> Iso b a t s
re :: Lens s t a b  -> Colens b a t s
re :: Prism s t a b -> Coprism b a t s

Invert an isomorphism.

invert (invert o) ≡ o

& is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator $, which allows & to be nested in $.

>>> 5 & (+1) & show
"6"

Since: base-4.8.0.0

Function composition.

Compose two coindexed traversals, combining indices.

Its precedence is one lower than that of function composition, which allows . to be nested in #.

If you only need the final index then use ..

A prefix alias for ^..

view . to ≡ id

>>> view second' (1, "hello")
"hello"

>>> view (to succ) 5
6

>>> view (second' . first') ("hello",("world","!!!"))
"world"

View the focus of an optic.

Fixity and semantics are such that subsequent field accesses can be performed with (.).

>>> ("hello","world") ^. second'
"world"

>>> 5 ^. to succ
6

>>> import Data.Complex
>>> ((0, 1 :+ 2), 3) ^. first' . second' . to magnitude
2.23606797749979

A prefix alias for ^%.

>>> iview ifirst ("foo", 42)
(Just (),"foo")

View the focus of an indexed optic along with its index.

>>> ("foo", 42) ^% ifirst
(Just (),"foo")

A prefix alias of #^.

review ≡ view . re
review . from ≡ id

>>> review (from succ) 5
6

Dual to ^..

from f #^ x ≡ f x
o #^ x ≡ x ^. re o

This is commonly used when using a Prism as a smart constructor.

>>> left' #^ 4
Left 4

Prefix variant of .~.

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

Set all referenced fields to the given value.

Prefix alias of %~.

Equivalent to iover with the current value ignored.

set o ≡ iset o . const

>>> iset (iat 2) (2-) [1,2,3 :: Int]
[1,2,0]
>>> iset (iat 5) (const 0) [1,2,3 :: Int]
[1,2,3]

Set the focus of an indexed optic.

See also #~.

Note if you're looking for the infix over it is ..~.

Prefix alias of #~.

Equivalent to kover with the current value ignored.

Set the focus of a coindexed optic.

See also %~.

Prefix alias of ..~.

over o id ≡ id 
over o f . over o g ≡ over o (f . g)
over . setter ≡ id
over . resetter ≡ id

>>> over fmapped (+1) (Just 1)
Just 2
>>> over fmapped (*10) [1,2,3]
[10,20,30]
>>> over first' (+1) (1,2)
(2,2)
>>> over first' show (10,20)
("10",20)

Map over an optic.

>>> Just 1 & just ..~ (+1)
Just 2

>>> Nothing & just ..~ (+1)
Nothing

>>> [1,2,3] & fmapped ..~ (*10)
[10,20,30]

>>> (1,2) & first' ..~ (+1)
(2,2)

>>> (10,20) & first' ..~ show
("10",20)

Prefix alias of %%~.

>>> iover (iat 1) (+) [1,2,3 :: Int]
[1,3,3]
>>> iover (iat 5) (+) [1,2,3 :: Int]
[1,2,3]

Map over an indexed optic.

See also ##~.

Prefix alias of ##~.

Map over a coindexed optic.

Infix variant of kover.

See also %%~.

Modify the target by adding another value.

>>> both <>~ "!" $ ("bar","baz")
("bar!","baz!")

TODO: Document

An infix alias for preview'.

(^?) ≡ flip preview'

Perform a safe head of a Fold or Traversal or retrieve Just the result from a View or Lens.

When using a Traversal as a partial Lens, or a Fold as a partial View this can be a convenient way to extract the optional value.

>>> Left 4 ^? left'
Just 4
>>> Right 4 ^? left'
Nothing

Check whether the optic is matched.

>>> is just Nothing
False

Check whether the optic isn't matched.

>>> isnt just Nothing
True

Test whether the optic matches or not.

>>> matches just (Just 2)
Right 2

>>> matches just (Nothing :: Maybe Int) :: Either (Maybe Bool) Int
Left Nothing

Collect the foci of an optic into a list.

Infix alias of lists.

toList xs ≡ xs ^.. folding
(^..) ≡ flip lists

>>> [[1,2], [3 :: Int64]] ^.. id
[[[1,2],[3]]]
>>> [[1,2], [3 :: Int64]] ^.. traversed
[[1,2],[3]]
>>> [[1,2], [3 :: Int64]] ^.. traversed . traversed
[1,2,3]

>>> (1,2) ^.. bitraversed
[1,2]

(^..) :: s -> View s a     -> a :: s -> Fold s a       -> a :: s -> Lens' s a      -> a :: s -> Iso' s a       -> a :: s -> Traversal' s a -> a :: s -> Prism' s a     -> a :: s -> Affine' s a    -> [a]

Collect the foci of an indexed optic into a list of index-value pairs.

lists l ≡ map snd . ilists l

>>> ilists (itraversed . imapping swapped) [(40,'f'),(41,'o'),(42,'o')]
[(0,('f',40)),(1,('o',41)),(2,('o',42))]

Collect the foci of an indexed optic into a list of index-value pairs.

This is only for use with the few indexed optics that don't ignore their output index. You most likely want to use ilists.

Infix version of ilists.

TODO: Document

TODO: Document

foldsa :: Fold s a -> s -> [a]
foldsa :: Applicative f => Setter s t a b -> s -> f a

Right fold over an optic.

>>> foldsr folded (+) 0 [1..5::Int64]
15

Indexed right fold over an indexed optic.

foldsr o ≡ ifoldsr o . const
foldrWithKey f ≡ ifoldsr ifolded f

>>> ifoldsr itraversed (\i a -> ((show i ++ ":" ++ show a ++ ", ") ++)) [] [1,3,5,7,9]
"0:1, 1:3, 2:5, 3:7, 4:9, "

Indexed right fold over an indexed optic, using an initial index value.

This is only for use with the few indexed optics that don't ignore their output index. You most likely want to use ifoldsr.

Left fold over an optic.

Left fold over an indexed optic.

foldsl o ≡ ifoldsl o . const
foldlWithKey f ≡ ifoldsl ifolded f

Left fold over an indexed optic, using an initial index value.

This is only for use with the few indexed optics that don't ignore their output index. You most likely want to use ifoldsl.

Strict right fold over an optic.

Strict right fold over an indexed optic.

foldsr' o ≡ ifoldsr' o . const
foldrWithKey' f ≡ ifoldsr' ifolded f

Strict left fold over an optic.

foldl' ≡ foldsl' folding

foldsl' :: Iso' s a        -> (c -> a -> c) -> c -> s -> c
foldsl' :: Lens' s a       -> (c -> a -> c) -> c -> s -> c
foldsl' :: View s a        -> (c -> a -> c) -> c -> s -> c
foldsl' :: Fold s a        -> (c -> a -> c) -> c -> s -> c
foldsl' :: Traversal' s a  -> (c -> a -> c) -> c -> s -> c
foldsl' :: Affine' s a -> (c -> a -> c) -> c -> s -> c

Strict left fold over an indexed optic.

foldsl' o ≡ ifoldsl' o . const
foldlWithKey' f ≡ ifoldsl' ifolded f

Monadic right fold over an optic.

Monadic right fold over an indexed optic.

foldsrM ≡ ifoldrM . const

Monadic left fold over an optic.

Monadic left fold over an indexed optic.

foldslM ≡ ifoldslM . const

Applicative fold over an optic.

>>> traverses_ both putStrLn ("hello","world")
hello
world

traverse_ ≡ traverses_ folded

Applicative fold over an indexed optic.

The sum of a collection.

The product of a collection.

The sum of a collection of actions, generalizing concats.

>>> asums both ("hello","world")
"helloworld"

>>> asums both (Nothing, Just "hello")
Just "hello"

asum ≡ asums folded

Map a function over the foci of an optic and concatenate the resulting lists.

>>> concats both (\x -> [x, x + 1]) (1,3)
[1,2,3,4]

concatMap ≡ concats folded

Concatenate the results of a function of the foci of an indexed optic.

concats o ≡ iconcats o . const

>>> iconcats itraversed (\i x -> [i + x, i + x + 1]) [1,2,3,4]
[1,2,3,4,5,6,7,8]

TODO: Document

TODO: Document

Find the first focus of an optic that satisfies a predicate, if one exists.

>>> finds both even (1,4)
Just 4

>>> finds folded even [1,3,5,7]
Nothing

find ≡ finds folded

Find the first focus of an indexed optic that satisfies a predicate, if one exists.

Determine whether an optic has at least one focus.

Determine whether an optic does not have a focus.

Determine whether the targets of a Fold contain a given element.

Determine whether the foci of an optic contain an element equivalent to a given element.

Compute the join of the foci of an optic.

Compute the join of the foci of an optic including a least element.

Compute the meet of the foci of an optic .

Compute the meet of the foci of an optic including a greatest element.

Compute the minimum of the targets of a totally ordered fold.

Compute the maximum of the targets of a totally ordered fold.