Lens.Micro.Classes

Documentation

class Each s t a b | s -> a, t -> b, s b -> t, t a -> s where

Minimal complete definition

Nothing

Methods

each :: Traversal s t a b

each tries to be a universal Traversal – it behaves like traversed in most situations, but also adds support for e.g. tuples with same-typed values:

>>> (1,2) & each %~ succ
(2,3)

>>> ["x", "y", "z"] ^. each
"xyz"

However, note that each doesn't work on every instance of Traversable. If you have a Traversable which isn't supported by each, you can use traversed instead. Personally, I like using each instead of traversed whenever possible – it's shorter and more descriptive.

You can use each with these things:

each :: Traversal [a] [b] a b

each :: Traversal (Maybe a) (Maybe b) a b

each :: Traversal (a,a) (b,b) a b
each :: Traversal (a,a,a) (b,b,b) a b
each :: Traversal (a,a,a,a) (b,b,b,b) a b
each :: Traversal (a,a,a,a,a) (b,b,b,b,b) a b

each :: (RealFloat a, RealFloat b) => Traversal (Complex a) (Complex b) a b

Additionally, you can use each with types from array, bytestring, and containers by importing Lens.Micro.GHC from the microlens-ghc package.

Instances

Each [a] [b] a b

Each (Complex a) (Complex b) a b

Each (Maybe a) (Maybe b) a b

((~) * a b, (~) * q r) => Each (a, b) (q, r) a q

((~) * a b, (~) * a c, (~) * q r, (~) * q s) => Each (a, b, c) (q, r, s) a q

((~) * a b, (~) * a c, (~) * a d, (~) * q r, (~) * q s, (~) * q t) => Each (a, b, c, d) (q, r, s, t) a q

((~) * a b, (~) * a c, (~) * a d, (~) * a e, (~) * q r, (~) * q s, (~) * q t, (~) * q u) => Each (a, b, c, d, e) (q, r, s, t, u) a q

type family Index s :: *

Instances

type Index [a] = Int

type Index (e -> a) = e

type family IxValue m :: *

Instances

type IxValue [a] = a

type IxValue (e -> a) = a

class Ixed m where

Minimal complete definition

Nothing

Methods

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

This traversal lets you access (and update) an arbitrary element in a list, array, Map, etc. (If you want to insert or delete elements as well, look at at.)

An example for lists:

>>> [0..5] & ix 3 .~ 10
[0,1,2,100,4,5]

You can use it for getting, too:

>>> [0..5] ^? ix 3
Just 3

Of course, the element may not be present (which means that you can use ix as a safe variant of (!!)):

>>> [0..5] ^? ix 10
Nothing

Another useful instance is the one for functions – it lets you modify their outputs for specific inputs. For instance, here's maximum that returns 0 when the list is empty (instead of throwing an exception):

maximum0 = maximum & ix [] .~ 0

The following instances are provided in this package:

ix :: Int -> Traversal' [a] a

ix :: (Eq e) => e -> Traversal' (e -> a) a

Additionally, you can use ix with types from array, bytestring, and containers by importing Lens.Micro.GHC from the microlens-ghc package.

Instances

Ixed [a]

Eq e => Ixed (e -> a)

class Ixed m => At m where

Methods

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

This lens lets you read, write, or delete elements in Map-like structures. It returns Nothing when the value isn't found, just like lookup:

Data.Map.lookup k m = m ^. at k

However, it also lets you insert and delete values by setting the value to Just value or Nothing:

Data.Map.insert k a m = m & at k .~ Just a

Data.Map.delete k m = m & at k .~ Nothing

at doesn't work for arrays, because you can't delete an arbitrary element from an array.

If you want to modify an already existing value, you should use ix instead because then you won't have to deal with Maybe (ix is available for all types that have at).

This package doesn't actually provide any instances for at, but you can import Lens.Micro.GHC from the microlens-ghc package and get instances for Map and IntMap.

class Field1 s t a b | s -> a, t -> b, s b -> t, t a -> s where

Minimal complete definition

Nothing

Methods

_1 :: Lens s t a b

Gives access to the 1st field of a tuple (up to 5-tuples).

Getting the 1st component:

>>> (1,2,3,4,5) ^. _1
1

Setting the 1st component:

>>> (1,2,3) & _1 .~ 10
(10,2,3)

Note that this lens is lazy, and can set fields even of undefined:

>>> set _1 10 undefined :: (Int, Int)
(10,*** Exception: Prelude.undefined

This is done to avoid violating a lens law stating that you can get back what you put:

>>> view _1 . set _1 10 $ (undefined :: (Int, Int))
10

The implementation (for 2-tuples) is:

_1 f t = (,) <$> f    (fst t)
             <*> pure (snd t)

or, alternatively,

_1 f ~(a,b) = (\a' -> (a',b)) <$> f a

(where ~ means a lazy pattern).

_2, _3, _4, and _5 are also available (see below).

Instances

Field1 (a, b) (a', b) a a'

Field1 (a, b, c) (a', b, c) a a'

Field1 (a, b, c, d) (a', b, c, d) a a'

Field1 (a, b, c, d, e) (a', b, c, d, e) a a'

class Field2 s t a b | s -> a, t -> b, s b -> t, t a -> s where

Minimal complete definition

Nothing

Methods

_2 :: Lens s t a b

Instances

Field2 (a, b) (a, b') b b'

Field2 (a, b, c) (a, b', c) b b'

Field2 (a, b, c, d) (a, b', c, d) b b'

Field2 (a, b, c, d, e) (a, b', c, d, e) b b'

class Field3 s t a b | s -> a, t -> b, s b -> t, t a -> s where

Minimal complete definition

Nothing

Methods

_3 :: Lens s t a b

Instances

Field3 (a, b, c) (a, b, c') c c'

Field3 (a, b, c, d) (a, b, c', d) c c'

Field3 (a, b, c, d, e) (a, b, c', d, e) c c'

class Field4 s t a b | s -> a, t -> b, s b -> t, t a -> s where

Minimal complete definition

Nothing

Methods

_4 :: Lens s t a b

Instances

Field4 (a, b, c, d) (a, b, c, d') d d'

Field4 (a, b, c, d, e) (a, b, c, d', e) d d'

class Field5 s t a b | s -> a, t -> b, s b -> t, t a -> s where

Minimal complete definition

Nothing

Methods

_5 :: Lens s t a b

Instances

Field5 (a, b, c, d, e) (a, b, c, d, e') e e'