lens-4.15.3: Lenses, Folds and Traversals

Copyright | (C) 2012-16 Edward Kmett
License | BSD-style (see the file LICENSE)
Maintainer | Edward Kmett <ekmett@gmail.com>
Stability | experimental
Portability | non-portable
Safe Haskell | Trustworthy
Language | Haskell98

Control.Lens.At

Contents

- At
- Ixed
- Contains

Description

Synopsis

- class Ixed m => At m where
- sans :: At m => Index m -> m -> m
- iat :: At m => Index m -> IndexedLens' (Index m) m (Maybe (IxValue m))
- type family Index (s :: *) :: *
- type family IxValue (m :: *) :: *
- class Ixed m where
- ixAt :: At m => Index m -> Traversal' m (IxValue m)
- iix :: Ixed m => Index m -> IndexedTraversal' (Index m) m (IxValue m)
- class Contains m where
- icontains :: Contains m => Index m -> IndexedLens' (Index m) m Bool

# At

class Ixed m => At m where #

`At` provides a `Lens` that can be used to read, write or delete the value associated with a key in a `Map`-like container on an ad hoc basis.

An instance of `At` should satisfy:

    ix k ≡ at k . traverse

Minimal complete definition

at

Methods

at :: Index m -> Lens' m (Maybe (IxValue m)) #

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

    >>> at 1 ?~ "hello" $ Map.empty
    fromList [(1,"hello")]

Note: `Map`-like containers form a reasonable instance, but not `Array`-like ones, where you cannot satisfy the `Lens` laws.

Instances

At IntSet # |
Methods at :: Index IntSet -> Lens' IntSet (Maybe (IxValue IntSet)) #
At (Maybe a) # |
Methods at :: Index (Maybe a) -> Lens' (Maybe a) (Maybe (IxValue (Maybe a))) #
At (IntMap a) # |
Methods at :: Index (IntMap a) -> Lens' (IntMap a) (Maybe (IxValue (IntMap a))) #
Ord k => At (Set k) # |
Methods at :: Index (Set k) -> Lens' (Set k) (Maybe (IxValue (Set k))) #
(Eq k, Hashable k) => At (HashSet k) # |
Methods at :: Index (HashSet k) -> Lens' (HashSet k) (Maybe (IxValue (HashSet k))) #
Ord k => At (Map k a) # |
Methods at :: Index (Map k a) -> Lens' (Map k a) (Maybe (IxValue (Map k a))) #
(Eq k, Hashable k) => At (HashMap k a) # |
Methods at :: Index (HashMap k a) -> Lens' (HashMap k a) (Maybe (IxValue (HashMap k a))) #

sans :: At m => Index m -> m -> m #

Delete the value associated with a key in a `Map`-like container

    sans k = at k .~ Nothing

iat :: At m => Index m -> IndexedLens' (Index m) m (Maybe (IxValue m)) #

An indexed version of `at`.

    >>> Map.fromList [(1,"world")] ^@. iat 1
    (1,Just "world")

    >>> iat 1 %@~ (\i x -> if odd i then Just "hello" else Nothing) $ Map.empty
    fromList [(1,"hello")]

    >>> iat 2 %@~ (\i x -> if odd i then Just "hello" else Nothing) $ Map.empty
    fromList []

# Ixed

type family Index (s :: *) :: * #

Instances

type Index ByteString # |
type Index ByteString = Int64
type Index ByteString # |
type Index ByteString = Int
type Index IntSet # |
type Index IntSet = Int
type Index Text # |
type Index Text = Int64
type Index Text # |
type Index Text = Int
type Index [a] # |
type Index [a] = Int
type Index (Maybe a) # |
type Index (Maybe a) = ()
type Index (Identity a) # |
type Index (Identity a) = ()
type Index (NonEmpty a) # |
type Index (NonEmpty a) = Int
type Index (Complex a) # |
type Index (Complex a) = Int
type Index (IntMap a) # |
type Index (IntMap a) = Int
type Index (Tree a) # |
type Index (Tree a) = [Int]
type Index (Seq a) # |
type Index (Seq a) = Int
type Index (Set a) # |
type Index (Set a) = a
type Index (HashSet a) # |
type Index (HashSet a) = a
type Index (Vector a) # |
type Index (Vector a) = Int
type Index (Vector a) # |
type Index (Vector a) = Int
type Index (Vector a) # |
type Index (Vector a) = Int
type Index (Vector a) # |
type Index (Vector a) = Int
type Index (e -> a) # |
type Index (e -> a) = e
type Index (a, b) # |
type Index (a, b) = Int
type Index (UArray i e) # |
type Index (UArray i e) = i
type Index (Array i e) # |
type Index (Array i e) = i
type Index (Map k a) # |
type Index (Map k a) = k
type Index (HashMap k a) # |
type Index (HashMap k a) = k
type Index (a, b, c) # |
type Index (a, b, c) = Int
type Index (a, b, c, d) # |
type Index (a, b, c, d) = Int
type Index (a, b, c, d, e) # |
type Index (a, b, c, d, e) = Int
type Index (a, b, c, d, e, f) # |
type Index (a, b, c, d, e, f) = Int
type Index (a, b, c, d, e, f, g) # |
type Index (a, b, c, d, e, f, g) = Int
type Index (a, b, c, d, e, f, g, h) # |
type Index (a, b, c, d, e, f, g, h) = Int
type Index (a, b, c, d, e, f, g, h, i) # |
type Index (a, b, c, d, e, f, g, h, i) = Int

type family IxValue (m :: *) :: * #

This provides a common notion of a value at an index that is shared by both `Ixed` and `At`.

Instances

type IxValue ByteString # |
type IxValue ByteString = Word8
type IxValue ByteString # |
type IxValue ByteString = Word8
type IxValue IntSet # |
type IxValue IntSet = ()
type IxValue Text # |
type IxValue Text = Char
type IxValue Text # |
type IxValue Text = Char
type IxValue [a] # |
type IxValue [a] = a
type IxValue (Maybe a) # |
type IxValue (Maybe a) = a
type IxValue (Identity a) # |
type IxValue (Identity a) = a
type IxValue (NonEmpty a) # |
type IxValue (NonEmpty a) = a
type IxValue (IntMap a) # |
type IxValue (IntMap a) = a
type IxValue (Tree a) # |
type IxValue (Tree a) = a
type IxValue (Seq a) # |
type IxValue (Seq a) = a
type IxValue (Set k) # |
type IxValue (Set k) = ()
type IxValue (HashSet k) # |
type IxValue (HashSet k) = ()
type IxValue (Vector a) # |
type IxValue (Vector a) = a
type IxValue (Vector a) # |
type IxValue (Vector a) = a
type IxValue (Vector a) # |
type IxValue (Vector a) = a
type IxValue (Vector a) # |
type IxValue (Vector a) = a
type IxValue (e -> a) # |
type IxValue (e -> a) = a
type IxValue (a, a2) # |
type IxValue (a, a2) = a
type IxValue (UArray i e) # |
type IxValue (UArray i e) = e
type IxValue (Array i e) # |
type IxValue (Array i e) = e
type IxValue (Map k a) # |
type IxValue (Map k a) = a
type IxValue (HashMap k a) # |
type IxValue (HashMap k a) = a
type IxValue (a, a2, a3) # |
type IxValue (a, a2, a3) = a
type IxValue (a, a2, a3, a4) # |
type IxValue (a, a2, a3, a4) = a
type IxValue (a, a2, a3, a4, a5) # |
type IxValue (a, a2, a3, a4, a5) = a
type IxValue (a, a2, a3, a4, a5, a6) # |
type IxValue (a, a2, a3, a4, a5, a6) = a
type IxValue (a, a2, a3, a4, a5, a6, a7) # |
type IxValue (a, a2, a3, a4, a5, a6, a7) = a
type IxValue (a, a2, a3, a4, a5, a6, a7, a8) # |
type IxValue (a, a2, a3, a4, a5, a6, a7, a8) = a
type IxValue (a, a2, a3, a4, a5, a6, a7, a8, a9) # |
type IxValue (a, a2, a3, a4, a5, a6, a7, a8, a9) = a

class Ixed m where #

Provides a simple `Traversal` lets you `traverse` the value at a given key in a `Map` or element at an ordinal position in a list or `Seq`.

Methods

ix :: Index m -> Traversal' m (IxValue m) #

NB: Setting the value of this `Traversal` will only set the value in `at` if it is already present.

If you want to be able to insert missing values, you want `at`.

    >>> Seq.fromList [a,b,c,d] & ix 2 %~ f
    fromList [a,b,f c,d]

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

    >>> Seq.fromList [a,b,c,d] ^? ix 2
    Just c

    >>> Seq.fromList [] ^? ix 2
    Nothing

ix :: (Applicative f, At m) => Index m -> LensLike' f m (IxValue m) #

NB: Setting the value of this `Traversal` will only set the value in `at` if it is already present.

If you want to be able to insert missing values, you want `at`.

    >>> Seq.fromList [a,b,c,d] & ix 2 %~ f
    fromList [a,b,f c,d]

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

    >>> Seq.fromList [a,b,c,d] ^? ix 2
    Just c

    >>> Seq.fromList [] ^? ix 2
    Nothing

Instances

Ixed ByteString # |
Methods ix :: Index ByteString -> Traversal' ByteString (IxValue ByteString) #
Ixed ByteString # |
Methods ix :: Index ByteString -> Traversal' ByteString (IxValue ByteString) #
Ixed IntSet # |
Methods ix :: Index IntSet -> Traversal' IntSet (IxValue IntSet) #
Ixed Text # |
Methods ix :: Index Text -> Traversal' Text (IxValue Text) #
Ixed Text # |
Methods ix :: Index Text -> Traversal' Text (IxValue Text) #
Ixed [a] # |
Methods ix :: Index [a] -> Traversal' [a] (IxValue [a]) #
Ixed (Maybe a) # |
Methods ix :: Index (Maybe a) -> Traversal' (Maybe a) (IxValue (Maybe a)) #
Ixed (Identity a) # |
Methods ix :: Index (Identity a) -> Traversal' (Identity a) (IxValue (Identity a)) #
Ixed (NonEmpty a) # |
Methods ix :: Index (NonEmpty a) -> Traversal' (NonEmpty a) (IxValue (NonEmpty a)) #
Ixed (IntMap a) # |
Methods ix :: Index (IntMap a) -> Traversal' (IntMap a) (IxValue (IntMap a)) #
Ixed (Tree a) # |
Methods ix :: Index (Tree a) -> Traversal' (Tree a) (IxValue (Tree a)) #
Ixed (Seq a) # |
Methods ix :: Index (Seq a) -> Traversal' (Seq a) (IxValue (Seq a)) #
Ord k => Ixed (Set k) # |
Methods ix :: Index (Set k) -> Traversal' (Set k) (IxValue (Set k)) #
(Eq k, Hashable k) => Ixed (HashSet k) # |
Methods ix :: Index (HashSet k) -> Traversal' (HashSet k) (IxValue (HashSet k)) #
Ixed (Vector a) # |
Methods ix :: Index (Vector a) -> Traversal' (Vector a) (IxValue (Vector a)) #
Storable a => Ixed (Vector a) # |
Methods ix :: Index (Vector a) -> Traversal' (Vector a) (IxValue (Vector a)) #
Unbox a => Ixed (Vector a) # |
Methods ix :: Index (Vector a) -> Traversal' (Vector a) (IxValue (Vector a)) #
Prim a => Ixed (Vector a) # |
Methods ix :: Index (Vector a) -> Traversal' (Vector a) (IxValue (Vector a)) #
Eq e => Ixed (e -> a) # |
Methods ix :: Index (e -> a) -> Traversal' (e -> a) (IxValue (e -> a)) #
(~) * a a2 => Ixed (a, a2) # |
Methods ix :: Index (a, a2) -> Traversal' (a, a2) (IxValue (a, a2)) #
(IArray UArray e, Ix i) => Ixed (UArray i e) # |
    arr ! i ≡ arr ^. ix i
    arr // [(i,e)] ≡ ix i .~ e $ arr
Methods ix :: Index (UArray i e) -> Traversal' (UArray i e) (IxValue (UArray i e)) #
Ix i => Ixed (Array i e) # |
    arr ! i ≡ arr ^. ix i
    arr // [(i,e)] ≡ ix i .~ e $ arr
Methods ix :: Index (Array i e) -> Traversal' (Array i e) (IxValue (Array i e)) #
Ord k => Ixed (Map k a) # |
Methods ix :: Index (Map k a) -> Traversal' (Map k a) (IxValue (Map k a)) #
(Eq k, Hashable k) => Ixed (HashMap k a) # |
Methods ix :: Index (HashMap k a) -> Traversal' (HashMap k a) (IxValue (HashMap k a)) #
((~) * a a2, (~) * a a3) => Ixed (a, a2, a3) # |
Methods ix :: Index (a, a2, a3) -> Traversal' (a, a2, a3) (IxValue (a, a2, a3)) #
((~) * a a2, (~) * a a3, (~) * a a4) => Ixed (a, a2, a3, a4) # |
Methods ix :: Index (a, a2, a3, a4) -> Traversal' (a, a2, a3, a4) (IxValue (a, a2, a3, a4)) #
((~) * a a2, (~) * a a3, (~) * a a4, (~) * a a5) => Ixed (a, a2, a3, a4, a5) # |
Methods ix :: Index (a, a2, a3, a4, a5) -> Traversal' (a, a2, a3, a4, a5) (IxValue (a, a2, a3, a4, a5)) #
((~) * a a2, (~) * a a3, (~) * a a4, (~) * a a5, (~) * a a6) => Ixed (a, a2, a3, a4, a5, a6) # |
Methods ix :: Index (a, a2, a3, a4, a5, a6) -> Traversal' (a, a2, a3, a4, a5, a6) (IxValue (a, a2, a3, a4, a5, a6)) #
((~) * a a2, (~) * a a3, (~) * a a4, (~) * a a5, (~) * a a6, (~) * a a7) => Ixed (a, a2, a3, a4, a5, a6, a7) # |
Methods ix :: Index (a, a2, a3, a4, a5, a6, a7) -> Traversal' (a, a2, a3, a4, a5, a6, a7) (IxValue (a, a2, a3, a4, a5, a6, a7)) #
((~) * a a2, (~) * a a3, (~) * a a4, (~) * a a5, (~) * a a6, (~) * a a7, (~) * a a8) => Ixed (a, a2, a3, a4, a5, a6, a7, a8) # |
Methods ix :: Index (a, a2, a3, a4, a5, a6, a7, a8) -> Traversal' (a, a2, a3, a4, a5, a6, a7, a8) (IxValue (a, a2, a3, a4, a5, a6, a7, a8)) #
((~) * a a2, (~) * a a3, (~) * a a4, (~) * a a5, (~) * a a6, (~) * a a7, (~) * a a8, (~) * a a9) => Ixed (a, a2, a3, a4, a5, a6, a7, a8, a9) # |
Methods ix :: Index (a, a2, a3, a4, a5, a6, a7, a8, a9) -> Traversal' (a, a2, a3, a4, a5, a6, a7, a8, a9) (IxValue (a, a2, a3, a4, a5, a6, a7, a8, a9)) #

ixAt :: At m => Index m -> Traversal' m (IxValue m) #

A definition of `ix` for types with an `At` instance. This is the default if you don't specify a definition for `ix`.

iix :: Ixed m => Index m -> IndexedTraversal' (Index m) m (IxValue m) #

An indexed version of `ix`.

    >>> Seq.fromList [a,b,c,d] & iix 2 %@~ f'
    fromList [a,b,f' 2 c,d]

    >>> Seq.fromList [a,b,c,d] & iix 2 .@~ h
    fromList [a,b,h 2,d]

    >>> Seq.fromList [a,b,c,d] ^@? iix 2
    Just (2,c)

    >>> Seq.fromList [] ^@? iix 2
    Nothing

# Contains

class Contains m where #

This class provides a simple `Lens` that lets you view (and modify) information about whether or not a container contains a given `Index`.

Minimal complete definition

contains

Methods

contains :: Index m -> Lens' m Bool #

    >>> IntSet.fromList [1,2,3,4] ^. contains 3
    True

    >>> IntSet.fromList [1,2,3,4] ^. contains 5
    False

    >>> IntSet.fromList [1,2,3,4] & contains 3 .~ False
    fromList [1,2,4]

Instances

Contains IntSet # |
Methods contains :: Index IntSet -> Lens' IntSet Bool #
Ord a => Contains (Set a) # |
Methods contains :: Index (Set a) -> Lens' (Set a) Bool #
(Eq a, Hashable a) => Contains (HashSet a) # |
Methods contains :: Index (HashSet a) -> Lens' (HashSet a) Bool #

icontains :: Contains m => Index m -> IndexedLens' (Index m) m Bool #

An indexed version of `contains`.

    >>> IntSet.fromList [1,2,3,4] ^@. icontains 3
    (3,True)

    >>> IntSet.fromList [1,2,3,4] ^@. icontains 5
    (5,False)

    >>> IntSet.fromList [1,2,3,4] & icontains 3 %@~ \i x -> if odd i then not x else x
    fromList [1,2,4]

    >>> IntSet.fromList [1,2,3,4] & icontains 3 %@~ \i x -> if even i then not x else x
    fromList [1,2,3,4]