Control.Lens.Cons

This class provides a way to attach or detach elements on the left side of a structure in a flexible manner.

cons an element onto a container.

This is an infix alias for cons.

>>> a <| [][a]

>>> a <| [b, c][a,b,c]

>>> a <| Seq.fromList []fromList [a]

>>> a <| Seq.fromList [b, c]fromList [a,b,c]

cons an element onto a container.

>>> cons a [][a]

>>> cons a [b, c][a,b,c]

>>> cons a (Seq.fromList [])fromList [a]

>>> cons a (Seq.fromList [b, c])fromList [a,b,c]

Attempt to extract the left-most element from a container, and a version of the container without that element.

>>> uncons []Nothing

>>> uncons [a, b, c]Just (a,[b,c])

A Traversal reading and writing to the head of a non-empty container.

>>> [a,b,c]^? _headJust a

>>> [a,b,c] & _head .~ d[d,b,c]

>>> [a,b,c] & _head %~ f[f a,b,c]

>>> [] & _head %~ f[]

>>> [1,2,3]^?!_head1

>>> []^?_headNothing

>>> [1,2]^?_headJust 1

>>> [] & _head .~ 1[]

>>> [0] & _head .~ 2[2]

>>> [0,1] & _head .~ 2[2,1]

This isn't limited to lists.

For instance you can also traverse the head of a Seq:

>>> Seq.fromList [a,b,c,d] & _head %~ ffromList [f a,b,c,d]

>>> Seq.fromList [] ^? _headNothing

>>> Seq.fromList [a,b,c,d] ^? _headJust a

_head :: Traversal' [a] a
_head :: Traversal' (Seq a) a
_head :: Traversal' (Vector a) a

A Traversal reading and writing to the tail of a non-empty container.

>>> [a,b] & _tail .~ [c,d,e][a,c,d,e]

>>> [] & _tail .~ [a,b][]

>>> [a,b,c,d,e] & _tail.traverse %~ f[a,f b,f c,f d,f e]

>>> [1,2] & _tail .~ [3,4,5][1,3,4,5]

>>> [] & _tail .~ [1,2][]

>>> [a,b,c]^?_tailJust [b,c]

>>> [1,2]^?!_tail[2]

>>> "hello"^._tail"ello"

>>> ""^._tail""

This isn't limited to lists. For instance you can also Control.Traversable.traverse the tail of a Seq.

>>> Seq.fromList [a,b] & _tail .~ Seq.fromList [c,d,e]fromList [a,c,d,e]

>>> Seq.fromList [a,b,c] ^? _tailJust (fromList [b,c])

>>> Seq.fromList [] ^? _tailNothing

_tail :: Traversal' [a] [a]
_tail :: Traversal' (Seq a) (Seq a)
_tail :: Traversal' (Vector a) (Vector a)

Modify the target(s) of a Lens', Iso, Setter or Traversal using (<|).

>>> (["world"], ["lens"]) & _1 <|~ "hello"(["hello","world"],["lens"])

Modify the target(s) of a Lens', Iso, Setter or Traversal using (<|).

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

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

This class provides a way to attach or detach elements on the right side of a structure in a flexible manner.

snoc an element onto a container.

This is an infix alias for snoc.

>>> Seq.fromList [] |> afromList [a]

>>> Seq.fromList [b, c] |> afromList [b,c,a]

>>> LazyT.pack "hello" |> '!'"hello!"

snoc an element onto a container.

>>> snoc (Seq.fromList []) afromList [a]

>>> snoc (Seq.fromList [b, c]) afromList [b,c,a]

>>> snoc (LazyT.pack "hello") '!'"hello!"

Attempt to extract the right-most element from a container, and a version of the container without that element.

>>> unsnoc (LazyT.pack "hello!")Just ("hello",'!')

>>> unsnoc (LazyT.pack "")Nothing

>>> unsnoc (Seq.fromList [b,c,a])Just (fromList [b,c],a)

>>> unsnoc (Seq.fromList [])Nothing

A Traversal reading and replacing all but the a last element of a non-empty container.

>>> [a,b,c,d]^?_initJust [a,b,c]

>>> []^?_initNothing

>>> [a,b] & _init .~ [c,d,e][c,d,e,b]

>>> [] & _init .~ [a,b][]

>>> [a,b,c,d] & _init.traverse %~ f[f a,f b,f c,d]

>>> [1,2,3]^?_initJust [1,2]

>>> [1,2,3,4]^?!_init[1,2,3]

>>> "hello"^._init"hell"

>>> ""^._init""

_init :: Traversal' [a] [a]
_init :: Traversal' (Seq a) (Seq a)
_init :: Traversal' (Vector a) (Vector a)

A Traversal reading and writing to the last element of a non-empty container.

>>> [a,b,c]^?!_lastc

>>> []^?_lastNothing

>>> [a,b,c] & _last %~ f[a,b,f c]

>>> [1,2]^?_lastJust 2

>>> [] & _last .~ 1[]

>>> [0] & _last .~ 2[2]

>>> [0,1] & _last .~ 2[0,2]

This Traversal is not limited to lists, however. We can also work with other containers, such as a Vector.

>>> Vector.fromList "abcde" ^? _lastJust 'e'

>>> Vector.empty ^? _lastNothing

>>> (Vector.fromList "abcde" & _last .~ 'Q') == Vector.fromList "abcdQ"True

_last :: Traversal' [a] a
_last :: Traversal' (Seq a) a
_last :: Traversal' (Vector a) a

Modify the target(s) of a Lens', Iso, Setter or Traversal using (|>).

>>> (["world"], ["lens"]) & _1 |>~ "hello"(["world","hello"],["lens"])

Modify the target(s) of a Lens', Iso, Setter or Traversal using (|>).

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

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