Portability | portable |
---|---|
Stability | provisional |
Maintainer | Edward Kmett <ekmett@gmail.com> |
Safe Haskell | Safe-Inferred |
Traversals for manipulating parts of a list.
- _head :: Simple Lens [a] a
- _tail :: Simple Lens [a] [a]
- _last :: Simple Lens [a] a
- _init :: Simple Lens [a] [a]
- interspersed :: a -> Getter [a] [a]
- intercalated :: [a] -> Getter [[a]] [a]
- traverseList :: IndexedTraversal Int [a] [b] a b
- traverseHead :: SimpleIndexedTraversal Int [a] a
- traverseTail :: SimpleIndexedTraversal Int [a] a
- traverseInit :: SimpleIndexedTraversal Int [a] a
- traverseLast :: SimpleIndexedTraversal Int [a] a
- (~:) :: a -> Setting s t [a] [a] -> s -> t
- (=:) :: MonadState s m => a -> SimpleSetting s [a] -> m ()
- (<~:) :: a -> LensLike ((,) [a]) s t [a] [a] -> s -> ([a], t)
- (<=:) :: MonadState s m => a -> SimpleLensLike ((,) [a]) s [a] -> m [a]
- (++~) :: Setting s t [a] [a] -> [a] -> s -> t
- (<++~) :: LensLike ((,) [a]) s t [a] [a] -> [a] -> s -> ([a], t)
- (++=) :: MonadState s m => SimpleSetting s [a] -> [a] -> m ()
- (<++=) :: MonadState s m => SimpleLensLike ((,) [a]) s [a] -> [a] -> m [a]
Documentation
_head :: Simple Lens [a] aSource
A lens reading and writing to the head of a non-empty list.
Attempting to read or write to the head of an empty list will result in an error
.
>>>
[1,2,3]^._head
1
_tail :: Simple Lens [a] [a]Source
A lens reading and writing to the tail of a non-empty list
Attempting to read or write to the tail of an empty list will result in an error
.
>>>
_tail .~ [3,4,5] $ [1,2]
[1,3,4,5]
_last :: Simple Lens [a] aSource
A lens reading and writing to the last element of a non-empty list
Attempting to read or write to the last element of an empty list will result in an error
.
>>>
[1,2]^._last
2
_init :: Simple Lens [a] [a]Source
A lens reading and replacing all but the a last element of a non-empty list
Attempting to read or write to all but the last element of an empty list will result in an error
.
>>>
[1,2,3,4]^._init
[1,2,3]
interspersed :: a -> Getter [a] [a]Source
Obtain a version of the list with the supplied value interspersed.
>>>
"abcde"^.interspersed ','
"a,b,c,d,e"
xs^.interspersed a = intersperse a xs
intercalated :: [a] -> Getter [[a]] [a]Source
Obtain a version of the list with the supplied value intercalated.
Traversals
traverseList :: IndexedTraversal Int [a] [b] a bSource
Indexed traversal of a list. The position in the list is available as the index.
traverseHead :: SimpleIndexedTraversal Int [a] aSource
A traversal for reading and writing to the head of a list
The position of the head in the original list (0) is available as the index.
>>>
traverseHead +~ 1 $ [1,2,3]
[2,2,3]
traverseHead
::Applicative
f => (a -> f a) -> [a] -> f [a]
traverseTail :: SimpleIndexedTraversal Int [a] aSource
A traversal for editing the tail of a list
The position of each element in the original list is available as the index.
>>>
traverseTail +~ 1 $ [1,2,3]
[1,3,4]
traverseTail
::Applicative
f => (a -> f a) -> [a] -> f [a]
traverseInit :: SimpleIndexedTraversal Int [a] aSource
A traversal of all but the last element of a list
The position of each element is available as the index.
>>>
traverseInit +~ 1 $ [1,2,3]
[2,3,3]
traverseInit
::Applicative
f => (a -> f a) -> [a] -> f [a]
traverseLast :: SimpleIndexedTraversal Int [a] aSource
A traversal the last element in a list
The position of the last element in the original list is available as the index.
>>>
traverseLast +~ 1 $ [1,2,3]
[1,2,4]
traverseLast
::Applicative
f => (a -> f a) -> [a] -> f [a]
(=:) :: MonadState s m => a -> SimpleSetting s [a] -> m ()Source
Cons onto the list(s) referenced by a Setter
in your monad state
(=:
) ::MonadState
s m => a ->Simple
Setter
s [a] -> m () (=:
) ::MonadState
s m => a ->Simple
Traversal
s [a] -> m () (=:
) ::MonadState
s m => a ->Simple
Lens
s [a] -> m () (=:
) ::MonadState
s m => a ->Simple
Iso
s [a] -> m ()
(<~:) :: a -> LensLike ((,) [a]) s t [a] [a] -> s -> ([a], t)Source
Cons onto the list(s) referenced by a Lens
(or Traversal
), returning the result.
If you use this with a Traversal
you will receive back the concatenation of all of
the resulting lists instead of an individual result.
>>>
'h' <~: _1 $ ("ello","world")
("hello",("hello","world"))
(<~:
) :: b ->Simple
Lens
s [a] -> s -> ([a], s) (<~:
) :: b ->Simple
Iso
s [a] -> s -> ([a], s) (<~:
) :: b ->Simple
Traversal
s [a] -> s -> ([a], s)
(<=:) :: MonadState s m => a -> SimpleLensLike ((,) [a]) s [a] -> m [a]Source
Cons onto the list(s) referenced by a Lens
(or Traversal
) into your monad state,
returning the result.
If you use this with a Traversal
, you will receive back the concatenation of all
of the resulting lists instead of an individual result.
(<=:
) ::MonadState
s m =>Simple
Lens
s [a] -> a -> m [a] (<=:
) ::MonadState
s m =>Simple
Iso
s [a] -> a -> m [a] (<=:
) ::MonadState
s m =>Simple
Traversal
s [a] -> a -> m [a]
(++~) :: Setting s t [a] [a] -> [a] -> s -> tSource
Append to the target of a list-valued setter by appending to it with (++
).
(<>~
) generalizes this operation to an arbitrary Monoid
.
>>>
:m + Control.Lens
>>>
both ++~ "!!!" $ ("hello","world")
("hello!!!","world!!!")
(++~
) ::Simple
Setter
s [a] -> [a] -> s -> s (++~
) ::Simple
Iso
s [a] -> [a] -> s -> s (++~
) ::Simple
Lens
s [a] -> [a] -> s -> s (++~
) ::Simple
Traversal
s [a] -> [a] -> s -> s
(<++~) :: LensLike ((,) [a]) s t [a] [a] -> [a] -> s -> ([a], t)Source
Append onto the end of the list targeted by a Lens
and return the result.
(<<>~
) generalizes this operation to an arbitrary Monoid
.
When using a Traversal
, the result returned is actually the concatenation of all of the results.
When you do not need the result of the operation, (++~
) is more flexible.
(++=) :: MonadState s m => SimpleSetting s [a] -> [a] -> m ()Source
Append to the target(s) of a Simple
Lens
, Iso
, Setter
or Traversal
with (++
) in the current state.
(<>=
) generalizes this operation to an arbitrary Monoid
.
(++=
) ::MonadState
s m =>Simple
Setter
s [a] -> [a] -> m () (++=
) ::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 => SimpleLensLike ((,) [a]) s [a] -> [a] -> m [a]Source
Append onto the end of the list targeted by a Lens
into the current monadic state, and return the result.
(<<>=
) generalizes this operation to an arbitrary Monoid
.
When using a Traversal
, the result returned is actually the concatenation of all of the results.
When you do not need the result of the operation, (++=
) is more flexible.