optics-core-0.4.1.1: Optics as an abstract interface: core definitions

Safe Haskell | None
Language | Haskell2010

Data.IntMap.Optics

Description

`IntMap` is an instance of `At` and provides `at` as a lens on values at keys:

    >>> IntMap.fromList [(1, "world")] ^. at 1
    Just "world"

    >>> IntMap.empty & at 1 .~ Just "world"
    fromList [(1,"world")]

    >>> IntMap.empty & at 0 .~ Just "hello"
    fromList [(0,"hello")]

We can traverse, fold over, and map over key-value pairs in an `IntMap`, thanks to indexed traversals, folds and setters.

    >>> iover imapped const $ IntMap.fromList [(1, "Venus")]
    fromList [(1,1)]

    >>> ifoldMapOf ifolded (\i _ -> Sum i) $ IntMap.fromList [(2, "Earth"), (3, "Mars")]
    Sum {getSum = 5}

    >>> itraverseOf_ ifolded (curry print) $ IntMap.fromList [(4, "Jupiter")]
    (4,"Jupiter")

    >>> itoListOf ifolded $ IntMap.fromList [(5, "Saturn")]
    [(5,"Saturn")]

A related class, `Ixed`, allows us to use `ix` to traverse a value at a particular key.

    >>> IntMap.fromList [(2, "Earth")] & ix 2 %~ ("New " ++)
    fromList [(2,"New Earth")]

    >>> preview (ix 8) IntMap.empty
    Nothing

Synopsis

- toMapOf :: forall k (is :: IxList) s a. (Is k A_Fold, HasSingleIndex is Int) => Optic' k is s a -> s -> IntMap a
- lt :: Int -> IxAffineTraversal' Int (IntMap v) v
- gt :: Int -> IxAffineTraversal' Int (IntMap v) v
- le :: Int -> IxAffineTraversal' Int (IntMap v) v
- ge :: Int -> IxAffineTraversal' Int (IntMap v) v

# Documentation

toMapOf :: forall k (is :: IxList) s a. (Is k A_Fold, HasSingleIndex is Int) => Optic' k is s a -> s -> IntMap a Source #

Construct a map from an `IxFold`.

The construction is left-biased (see `union`), i.e. the first occurrences of keys in the fold or traversal order are preferred.

    >>> toMapOf ifolded ["hello", "world"]
    fromList [(0,"hello"),(1,"world")]

    >>> toMapOf (folded % ifolded) [(1,"alpha"),(2, "beta")]
    fromList [(1,"alpha"),(2,"beta")]

    >>> toMapOf (icompose (\a b -> 10*a+b) $ ifolded % ifolded) ["foo", "bar"]
    fromList [(0,'f'),(1,'o'),(2,'o'),(10,'b'),(11,'a'),(12,'r')]

    >>> toMapOf (folded % ifolded) [(1, "hello"), (2, "world"), (1, "dummy")]
    fromList [(1,"hello"),(2,"world")]

lt :: Int -> IxAffineTraversal' Int (IntMap v) v Source #

Focus on the largest key smaller than the given one and its corresponding value.

    >>> IntMap.fromList [(1, "hi"), (2, "there")] & over (lt 2) (++ "!")
    fromList [(1,"hi!"),(2,"there")]

    >>> ipreview (lt 1) $ IntMap.fromList [(1, 'x'), (2, 'y')]
    Nothing

gt :: Int -> IxAffineTraversal' Int (IntMap v) v Source #

Focus on the smallest key greater than the given one and its corresponding value.

    >>> IntMap.fromList [(1, "hi"), (2, "there")] & over (gt 2) (++ "!")
    fromList [(1,"hi"),(2,"there")]

    >>> ipreview (gt 1) $ IntMap.fromList [(1, 'x'), (2, 'y')]
    Just (2,'y')

le :: Int -> IxAffineTraversal' Int (IntMap v) v Source #

Focus on the largest key smaller or equal than the given one and its corresponding value.

    >>> IntMap.fromList [(1, "hi"), (2, "there")] & over (le 2) (++ "!")
    fromList [(1,"hi"),(2,"there!")]

    >>> ipreview (le 1) $ IntMap.fromList [(1, 'x'), (2, 'y')]
    Just (1,'x')

ge :: Int -> IxAffineTraversal' Int (IntMap v) v Source #

Focus on the smallest key greater or equal than the given one and its corresponding value.

    >>> IntMap.fromList [(1, "hi"), (3, "there")] & over (ge 2) (++ "!")
    fromList [(1,"hi"),(3,"there!")]

    >>> ipreview (ge 2) $ IntMap.fromList [(1, 'x'), (3, 'y')]
    Just (3,'y')