Control.Lens.At

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 (Complex a)

type Index (Complex a) = Int

type Index (NonEmpty a)

type Index (NonEmpty a) = Int

type Index (Identity a)

type Index (Identity a) = ()

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 (NonEmpty a)

type IxValue (NonEmpty a) = a

type IxValue (Identity a)

type IxValue (Identity 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 (NonEmpty a)

Methods

ix :: Index (NonEmpty a) -> Traversal' (NonEmpty a) (IxValue (NonEmpty a))

Ixed (Identity a)

Methods

ix :: Index (Identity a) -> Traversal' (Identity a) (IxValue (Identity 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))

Unbox a => 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))

Prim a => Ixed (Vector a)

Methods

ix :: Index (Vector a) -> Traversal' (Vector a) (IxValue (Vector 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]