lens-family-core-2.0.0: Haskell 2022 Lens Families

Safe HaskellSafe
LanguageHaskell98

Lens.Family.Stock

Contents

Description

This module contains lenses, prisms, grids, grates and traversals for common structures in Haskell. It also contains the combinators for various kinds of optics.

A Function name with ' is a grate variant of a grid, and a function name with _ is a traversal variants of a grid or prism. For example, both' is the grate variant of both while both_ is the traversal variant.

Synopsis

Stock Lenses

_1 :: Functor f => LensLike f (a, r) (b, r) a b Source #

_1 :: Lens (a, r) (b, r) a b

Lens on the first element of a pair.

_2 :: Functor f => LensLike f (r, a) (r, b) a b Source #

_2 :: Lens (r, a) (r, b) a b

Lens on the second element of a pair.

chosen :: Functor f => LensLike f (Either a a) (Either b b) a b Source #

chosen :: Lens (Either a a) (Either b b) a b

Lens on the Left or Right element of an (Either a a).

ix :: (Eq k, Functor f) => k -> LensLike' f (k -> v) v Source #

ix :: Eq k => k -> Lens' (k -> v) v

Lens on a given point of a function.

at :: (Ord k, Functor f) => k -> LensLike' f (Map k v) (Maybe v) Source #

at :: Ord k => k -> Lens' (Map.Map k v) (Maybe v)

Lens on a given point of a Map.

intAt :: Functor f => Int -> LensLike' f (IntMap v) (Maybe v) Source #

intAt :: Int -> Lens (IntMap.IntMap v) (Maybe v)

Lens on a given point of a IntMap.

at' :: (Ord k, Functor f) => k -> LensLike' f (Map k v) (Maybe v) Source #

at :: Ord k => k -> Lens' (Map.Map k v) (Maybe v)

Lens providing strict access to a given point of a Map.

intAt' :: Functor f => Int -> LensLike' f (IntMap v) (Maybe v) Source #

intAt :: Int -> Lens (IntMap.IntMap v) (Maybe v)

Lens providing strict access to a given point of a IntMap.

contains :: (Ord k, Functor f) => k -> LensLike' f (Set k) Bool Source #

contains :: Ord => k -> Lens' (Set.Set k) Bool

Lens on a given point of a Set.

intContains :: Functor f => Int -> LensLike' f IntSet Bool Source #

intContains :: Int -> Lens' IntSet.IntSet Bool

Lens on a given point of a IntSet.

Stock Prisms

lft :: (Applicative f, Traversable g) => AdapterLike f g (Either a r) (Either b r) a b Source #

lft :: Prism (Either a r) (Either b r) a b

A prism on the Left element of an Either.

rgt :: (Applicative f, Traversable g) => AdapterLike f g (Either r a) (Either r b) a b Source #

rgt :: Prism (Either r a) (Either r b) a b

A prism on the Right element of an Either.

some :: (Applicative f, Traversable g) => AdapterLike f g (Maybe a) (Maybe b) a b Source #

some :: Prism (Maybe a) (Maybe b) a b

A prism on the Just element of a Maybe.

none :: (Applicative f, Traversable g) => AdapterLike' f g (Maybe a) () Source #

none :: Prism' (Maybe a) ()

A prism on the Nothing element of a Maybe.

Stock Grids

both :: (Applicative f, Functor g) => AdapterLike f g (a, a) (b, b) a b Source #

both :: Grid (a,a) (b,b) a b

A grid on both elements of a pair (a,a).

bend :: (FiniteBits b, Applicative f, Functor g) => AdapterLike' f g b Bool Source #

bend :: FiniteBits b => Grid' b Bool

A grid from the most significant bit to the least significant bit of a FiniteBits type.

Big endian order.

lend :: (FiniteBits b, Applicative f, Functor g) => AdapterLike' f g b Bool Source #

lend :: FiniteBits b => Grid' b Bool

A grid from the least significant bit to the most significant bit of a FiniteBits type.

Little endian order.

Stock Grates

cod :: Functor g => GrateLike g (r -> a) (r -> b) a b Source #

cod :: Grate (r -> a) (r -> b) a b

A grate accessing the codomain of a function.

both' :: Functor g => GrateLike g (a, a) (b, b) a b Source #

both' :: Grate (a,a) (b,b) a b

A grate on both elements of a pair (a,a).

both' = over both

bend' :: (FiniteBits b, Functor g) => GrateLike' g b Bool Source #

bend' :: FiniteBits b => Grate' b Bool

A grate from the most significant bit to the least significant bit of a FiniteBits type.

Big endian order.

bend' = over bend

lend' :: (FiniteBits b, Functor g) => GrateLike' g b Bool Source #

lend' :: FiniteBits b => Grate' b Bool

A grate from the least significant bit to the most significant bit of a FiniteBits type.

Little endian order.

lend' = over lend

Stock Traversals

both_ :: Applicative f => LensLike f (a, a) (b, b) a b Source #

both_ :: Traversal (a,a) (b,b) a b

Traversals on both elements of a pair (a,a).

both_ = under both

bend_ :: (FiniteBits b, Applicative f) => LensLike' f b Bool Source #

bend_ :: FiniteBits b => Traversal' b Bool

A traversal from the most significant bit to the least significant bit of a FiniteBits type.

Big endian order.

bend_ = under bend

lend_ :: (FiniteBits b, Applicative f) => LensLike' f b Bool Source #

lend_ :: FiniteBits b => Traversal' b Bool

A traversal from the least significant bit to the most significant bit of a FiniteBits type.

Little endian order.

lend_ = under lend

lft_ :: Applicative f => LensLike f (Either a r) (Either b r) a b Source #

lft_ :: Traversal (Either a r) (Either b r) a b

Traversal on the Left element of an Either.

lft_ = under lft

rgt_ :: Applicative f => LensLike f (Either r a) (Either r b) a b Source #

rgt_ :: Traversal (Either r a) (Either r b) a b

Traversal on the Right element of an Either.

rgt_ = under rgt

some_ :: Applicative f => LensLike f (Maybe a) (Maybe b) a b Source #

some_ :: Traversal (Maybe a) (Maybe b) a b

Traversal on the Just element of a Maybe.

none_ :: Applicative f => LensLike' f (Maybe a) () Source #

none_ :: Traversal' (Maybe a) ()

Traversal on the Nothing element of a Maybe.

ignored :: Applicative f => null -> s -> f s Source #

ignored :: Traversal s s a b

The empty traversal on any type.

Stock SECs

mapped :: (Identical f, Functor h) => LensLike f (h a) (h b) a b Source #

mapped :: Functor h => Setter (h a) (h b) a b

An SEC referencing the parameter of a functor.

Lens Combinators

alongside :: Functor f => LensLike (AlongsideLeft f b1) s0 t0 a0 b0 -> LensLike (AlongsideRight f t0) s1 t1 a1 b1 -> LensLike f (s0, s1) (t0, t1) (a0, a1) (b0, b1) Source #

alongside :: Lens s0 t0 a0 b0 -> Lens s1 t1 a1 b1 -> Lens (s0, s1) (t0, t1) (a0, a1) (b0, b1)
alongside :: Getter s0 t0 a0 b0 -> Getter s1 t1 a1 b1 -> Getter (s0, s1) (t0, t1) (a0, a1) (b0, b1)

Given two lens/getter families, make a new lens/getter on their product.

backwards :: LensLike (Backwards f) s t a b -> LensLike f s t a b Source #

backwards :: Traversal s t a b -> Traversal s t a b
backwards :: Fold s t a b -> Fold s t a b

Given a traversal or fold, reverse the order that elements are traversed.

backwards :: Lens s t a b -> Lens s t a b
backwards :: Getter s t a b -> Getter s t a b
backwards :: Setter s t a b -> Setter s t a b

No effect on lenses, getters or setters.

beside :: (Applicative f, Functor g) => AdapterLike f g s0 t0 a b -> AdapterLike f g s1 t1 a b -> AdapterLike f g (s0, s1) (t0, t1) a b Source #

beside :: Grid s1 t1 a b -> Grid s2 t2 a b -> Grid (s1, s2) (t1, t2) a b

Given two grids referencing a type c, create a grid on the pair referencing c.

beside' :: Functor g => GrateLike g s0 t0 a b -> GrateLike g s1 t1 a b -> GrateLike g (s0, s1) (t0, t1) a b Source #

beside' :: Grate s0 t0 a b -> Grate s1 t1 a b -> Grate (s0, s1) (t0, t1) a b
beside' :: Resetter s0 t0 a b -> Resetter s1 t1 a b -> Resetter (s0, s1) (t0, t1) a b

Given two grates/resetters referencing a type c, create a grate/resetter on the pair referencing c.

beside_ :: Applicative f => LensLike f s0 t0 a b -> LensLike f s1 t1 a b -> LensLike f (s0, s1) (t0, t1) a b Source #

beside_ :: Traversal s0 t0 a b -> Traversal s1 t1 a b -> Traversal (s0, s1) (t0, t1) a b
beside_ :: Fold s0 t0 a b -> Fold s1 t1 a b -> Fold (s0, s1) (t0, t1) a b
beside_ :: Setter s0 t0 a b -> Setter s1 t1 a b -> Setter (s0, s1) (t0, t1) a b

Given two traversals/folds/setters referencing a type c, create a traversal/fold/setter on the pair referencing c.

choosing :: Functor f => LensLike f s0 t0 a b -> LensLike f s1 t1 a b -> LensLike f (Either s0 s1) (Either t0 t1) a b Source #

choosing :: Lens s0 t0 a b -> Lens s1 t1 a b -> Lens (Either s0 s1) (Either t0 t1) a b
choosing :: Traversal s0 t0 a b -> Traversal s1 t1 a b -> Traversal (Either s0 s1) (Either t0 t1) a b
choosing :: Getter s0 t0 a b -> Getter s1 t1 a b -> Getter (Either s0 s1) (Either t0 t1) a b
choosing :: Fold s0 t0 a b -> Fold s1 t1 a b -> Fold (Either s0 s1) (Either t0 t1) a b
choosing :: Setter s0 t0 a b -> Setter s1 t1 a b -> Setter (Either s0 s1) (Either t0 t1) a b

Given two lens/traversal/getter/fold/setter families with the same substructure, make a new lens/traversal/getter/fold/setter on Either.

from :: (Functor f, Functor g) => AdapterLike (FromF (g s -> f t) (f b) g) (FromG (f b) f) b a t s -> AdapterLike f g s t a b Source #

from :: Adapter b a t s -> Adapter s t a b

Reverses the direction of an adapter.

from :: Getter b a t s -> Reviewer s t a b
from :: Reviewer b a t s -> Getter s t a b

Changes a Getter into a Reviewer and vice versa.

Types

data AlongsideLeft f b a Source #

Instances
Functor f => Functor (AlongsideLeft f a) Source # 
Instance details

Defined in Lens.Family.Stock

Methods

fmap :: (a0 -> b) -> AlongsideLeft f a a0 -> AlongsideLeft f a b #

(<$) :: a0 -> AlongsideLeft f a b -> AlongsideLeft f a a0 #

Phantom f => Phantom (AlongsideLeft f a) Source # 
Instance details

Defined in Lens.Family.Stock

Methods

coerce :: AlongsideLeft f a a0 -> AlongsideLeft f a b

data AlongsideRight f a b Source #

Instances
Functor f => Functor (AlongsideRight f a) Source # 
Instance details

Defined in Lens.Family.Stock

Methods

fmap :: (a0 -> b) -> AlongsideRight f a a0 -> AlongsideRight f a b #

(<$) :: a0 -> AlongsideRight f a b -> AlongsideRight f a a0 #

Phantom f => Phantom (AlongsideRight f a) Source # 
Instance details

Defined in Lens.Family.Stock

Methods

coerce :: AlongsideRight f a a0 -> AlongsideRight f a b

data FromF i j g x Source #

Instances
Functor g => Functor (FromF i j g) Source # 
Instance details

Defined in Lens.Family.Stock

Methods

fmap :: (a -> b) -> FromF i j g a -> FromF i j g b #

(<$) :: a -> FromF i j g b -> FromF i j g a #

Phantom g => Phantom (FromF i j g) Source # 
Instance details

Defined in Lens.Family.Stock

Methods

coerce :: FromF i j g a -> FromF i j g b

data FromG e f x Source #

Instances
Functor f => Functor (FromG e f) Source # 
Instance details

Defined in Lens.Family.Stock

Methods

fmap :: (a -> b) -> FromG e f a -> FromG e f b #

(<$) :: a -> FromG e f b -> FromG e f a #

Phantom g => Phantom (FromG e g) Source # 
Instance details

Defined in Lens.Family.Stock

Methods

coerce :: FromG e g a -> FromG e g b

Re-exports

type AdapterLike f g s t a b = (g a -> f b) -> g s -> f t Source #

type AdapterLike' f g s a = (g a -> f a) -> g s -> f s Source #

type LensLike f s t a b = (a -> f b) -> s -> f t Source #

type LensLike' f s a = (a -> f a) -> s -> f s Source #

type GrateLike g s t a b = (g a -> b) -> g s -> t Source #

type GrateLike' g s a = (g a -> a) -> g s -> s Source #

class (Traversable f, Applicative f) => Identical f Source #

Minimal complete definition

extract

Instances
Identical Identity Source # 
Instance details

Defined in Lens.Family.Identical

Methods

extract :: Identity a -> a

Identical f => Identical (Backwards f) Source # 
Instance details

Defined in Lens.Family.Identical

Methods

extract :: Backwards f a -> a

(Identical f, Identical g) => Identical (Compose f g) Source # 
Instance details

Defined in Lens.Family.Identical

Methods

extract :: Compose f g a -> a

data Backwards (f :: k -> Type) (a :: k) :: forall k. (k -> Type) -> k -> Type #

The same functor, but with an Applicative instance that performs actions in the reverse order.

Instances
Functor f => Functor (Backwards f)

Derived instance.

Instance details

Defined in Control.Applicative.Backwards

Methods

fmap :: (a -> b) -> Backwards f a -> Backwards f b #

(<$) :: a -> Backwards f b -> Backwards f a #

Applicative f => Applicative (Backwards f)

Apply f-actions in the reverse order.

Instance details

Defined in Control.Applicative.Backwards

Methods

pure :: a -> Backwards f a #

(<*>) :: Backwards f (a -> b) -> Backwards f a -> Backwards f b #

liftA2 :: (a -> b -> c) -> Backwards f a -> Backwards f b -> Backwards f c #

(*>) :: Backwards f a -> Backwards f b -> Backwards f b #

(<*) :: Backwards f a -> Backwards f b -> Backwards f a #

Foldable f => Foldable (Backwards f)

Derived instance.

Instance details

Defined in Control.Applicative.Backwards

Methods

fold :: Monoid m => Backwards f m -> m #

foldMap :: Monoid m => (a -> m) -> Backwards f a -> m #

foldr :: (a -> b -> b) -> b -> Backwards f a -> b #

foldr' :: (a -> b -> b) -> b -> Backwards f a -> b #

foldl :: (b -> a -> b) -> b -> Backwards f a -> b #

foldl' :: (b -> a -> b) -> b -> Backwards f a -> b #

foldr1 :: (a -> a -> a) -> Backwards f a -> a #

foldl1 :: (a -> a -> a) -> Backwards f a -> a #

toList :: Backwards f a -> [a] #

null :: Backwards f a -> Bool #

length :: Backwards f a -> Int #

elem :: Eq a => a -> Backwards f a -> Bool #

maximum :: Ord a => Backwards f a -> a #

minimum :: Ord a => Backwards f a -> a #

sum :: Num a => Backwards f a -> a #

product :: Num a => Backwards f a -> a #

Traversable f => Traversable (Backwards f)

Derived instance.

Instance details

Defined in Control.Applicative.Backwards

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Backwards f a -> f0 (Backwards f b) #

sequenceA :: Applicative f0 => Backwards f (f0 a) -> f0 (Backwards f a) #

mapM :: Monad m => (a -> m b) -> Backwards f a -> m (Backwards f b) #

sequence :: Monad m => Backwards f (m a) -> m (Backwards f a) #

Contravariant f => Contravariant (Backwards f)

Derived instance.

Instance details

Defined in Control.Applicative.Backwards

Methods

contramap :: (a -> b) -> Backwards f b -> Backwards f a #

(>$) :: b -> Backwards f b -> Backwards f a #

Eq1 f => Eq1 (Backwards f) 
Instance details

Defined in Control.Applicative.Backwards

Methods

liftEq :: (a -> b -> Bool) -> Backwards f a -> Backwards f b -> Bool #

Ord1 f => Ord1 (Backwards f) 
Instance details

Defined in Control.Applicative.Backwards

Methods

liftCompare :: (a -> b -> Ordering) -> Backwards f a -> Backwards f b -> Ordering #

Read1 f => Read1 (Backwards f) 
Instance details

Defined in Control.Applicative.Backwards

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Backwards f a) #

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Backwards f a] #

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Backwards f a) #

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Backwards f a] #

Show1 f => Show1 (Backwards f) 
Instance details

Defined in Control.Applicative.Backwards

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Backwards f a -> ShowS #

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Backwards f a] -> ShowS #

Alternative f => Alternative (Backwards f)

Try alternatives in the same order as f.

Instance details

Defined in Control.Applicative.Backwards

Methods

empty :: Backwards f a #

(<|>) :: Backwards f a -> Backwards f a -> Backwards f a #

some :: Backwards f a -> Backwards f [a] #

many :: Backwards f a -> Backwards f [a] #

Identical f => Identical (Backwards f) Source # 
Instance details

Defined in Lens.Family.Identical

Methods

extract :: Backwards f a -> a

Phantom f => Phantom (Backwards f) Source # 
Instance details

Defined in Lens.Family.Phantom

Methods

coerce :: Backwards f a -> Backwards f b

(Eq1 f, Eq a) => Eq (Backwards f a) 
Instance details

Defined in Control.Applicative.Backwards

Methods

(==) :: Backwards f a -> Backwards f a -> Bool #

(/=) :: Backwards f a -> Backwards f a -> Bool #

(Ord1 f, Ord a) => Ord (Backwards f a) 
Instance details

Defined in Control.Applicative.Backwards

Methods

compare :: Backwards f a -> Backwards f a -> Ordering #

(<) :: Backwards f a -> Backwards f a -> Bool #

(<=) :: Backwards f a -> Backwards f a -> Bool #

(>) :: Backwards f a -> Backwards f a -> Bool #

(>=) :: Backwards f a -> Backwards f a -> Bool #

max :: Backwards f a -> Backwards f a -> Backwards f a #

min :: Backwards f a -> Backwards f a -> Backwards f a #

(Read1 f, Read a) => Read (Backwards f a) 
Instance details

Defined in Control.Applicative.Backwards

(Show1 f, Show a) => Show (Backwards f a) 
Instance details

Defined in Control.Applicative.Backwards

Methods

showsPrec :: Int -> Backwards f a -> ShowS #

show :: Backwards f a -> String #

showList :: [Backwards f a] -> ShowS #

class Bits b => FiniteBits b #

The FiniteBits class denotes types with a finite, fixed number of bits.

Since: base-4.7.0.0

Minimal complete definition

finiteBitSize

Instances
FiniteBits Bool

Since: base-4.7.0.0

Instance details

Defined in Data.Bits

FiniteBits Int

Since: base-4.6.0.0

Instance details

Defined in Data.Bits

FiniteBits Word

Since: base-4.6.0.0

Instance details

Defined in Data.Bits

FiniteBits a => FiniteBits (Identity a)

Since: base-4.9.0.0

Instance details

Defined in Data.Functor.Identity

FiniteBits a => FiniteBits (Const a b)

Since: base-4.9.0.0

Instance details

Defined in Data.Functor.Const