Data.Lens.Types

type AGetter s t a b = Fold a s t a b

type AGetter' s a = AGetter s s a a

type AGrate s t a b = Optic (Grating a b) s t a b

A grate defined in terms of Grating, which can be used to avoid issues with impredicativity.

type AGrate' s a = AGrate s s a a

type ALens s t a b = Optic (Shop a b) s t a b

A lens defined in terms of Shop, which can be used to avoid issues with impredicativity.

type ALens' s a = ALens s s a a

type APrism s t a b = Optic (Market a b) s t a b

A prism defined in terms of Market to be safe from impredicativity issues in the type checker. See the docs/ folder for a more detailed explanation.

type APrism' s a = APrism s s a a

type ATraversal s t a b = Optic (Bazaar Function a b) s t a b

A traversal defined in terms of Bazaar, which can be used to avoid issues with impredicativity.

type ATraversal' s a = ATraversal s s a a

type AffineTraversal s t a b = forall p. Strong p => Choice p => Optic p s t a b

An affine traversal (has at most one focus, but is not a prism).

type AffineTraversal' s a = AffineTraversal s s a a

type AnAffineTraversal s t a b = Optic (Stall a b) s t a b

An affine traversal defined in terms of Stall, which can be used to avoid issues with impredicativity.

type AnAffineTraversal' s a = AnAffineTraversal s s a a

type AnIndexedLens i s t a b = IndexedOptic (Shop (Tuple i a) b) i s t a b

An indexed lens defined in terms of Shop, which can be used to avoid issues with impredicativity.

type AnIndexedLens' i s a = AnIndexedLens i s s a a

type AnIso s t a b = Optic (Exchange a b) s t a b

An isomorphism defined in terms of Exchange, which can be used to avoid issues with impredicativity.

type AnIso' s a = AnIso s s a a

type Fold r s t a b = Optic (Forget r) s t a b

A fold.

type Fold' r s a = Fold r s s a a

type Getter s t a b = forall r. Fold r s t a b

A getter.

type Getter' s a = Getter s s a a

type Grate s t a b = forall p. Closed p => Optic p s t a b

A grate (http://r6research.livejournal.com/28050.html)

type Grate' s a = Grate s s a a

type IndexedFold r i s t a b = IndexedOptic (Forget r) i s t a b

An indexed fold.

type IndexedFold' r i s a = IndexedFold r i s s a a

type IndexedGetter i s t a b = IndexedFold a i s t a b

An indexed getter.

type IndexedGetter' i s a = IndexedGetter i s s a a

type IndexedLens i s t a b = forall p. Strong p => IndexedOptic p i s t a b

An indexed lens.

type IndexedLens' i s a = IndexedLens i s s a a

type IndexedOptic :: (Type -> Type -> Type) -> Type -> Type -> Type -> Type -> Type -> Typetype IndexedOptic p i s t a b = Indexed p i a b -> p s t

An indexed optic.

type IndexedOptic' :: (Type -> Type -> Type) -> Type -> Type -> Type -> Typetype IndexedOptic' p i s a = IndexedOptic p i s s a a

type IndexedSetter i s t a b = IndexedOptic Function i s t a b

An indexed setter.

type IndexedSetter' i s a = IndexedSetter i s s a a

type IndexedTraversal i s t a b = forall p. Wander p => IndexedOptic p i s t a b

An indexed traversal.

type IndexedTraversal' i s a = IndexedTraversal i s s a a

type Iso s t a b = forall p. Profunctor p => Optic p s t a b

A generalized isomorphism.

type Iso' s a = Iso s s a a

type Lens s t a b = forall p. Strong p => Optic p s t a b

Given a type whose "focus element" always exists, a lens provides a convenient way to view, set, and transform that element.

For example, _2 is a tuple-specific Lens available from Data.Lens, so:

over _2 String.length $ Tuple "ignore" "four" == Tuple "ignore" 4

Note the result has a different type than the original tuple. That is, the four Lens type variables have been narrowed to:

• s is Tuple String String
• t is Tuple String Int
• a is String
• b is Int

See Data.Lens.Getter and Data.Lens.Setter for functions and operators frequently used with lenses.

type Lens' s a = Lens s s a a

Lens' is a specialization of Lens. An optic of type Lens' can change only the value of its focus, not its type. As an example, consider the Lens _2, which has this type:

_2 :: forall s t a b. Lens (Tuple s a) (Tuple t b) a b

_2 can produce a Tuple Int String from a Tuple Int Int:

set _2 "NEW" (Tuple 1 2) == (Tuple 1 "NEW")

If we specialize _2's type with Lens', the following will not type check:

set (_2 :: Lens' (Tuple Int Int) Int) "NEW" (Tuple 1 2)
           ^^^^^^^^^^^^^^^^^^^^^^^^^

See Data.Lens.Getter and Data.Lens.Setter for functions and operators frequently used with lenses.

type Optic :: (Type -> Type -> Type) -> Type -> Type -> Type -> Type -> Typetype Optic p s t a b = p a b -> p s t

A general-purpose Data.Lens.

type Optic' :: (Type -> Type -> Type) -> Type -> Type -> Typetype Optic' p s a = Optic p s s a a

type Prism s t a b = forall p. Choice p => Optic p s t a b

A prism.

type Prism' s a = Prism s s a a

type Review s t a b = Optic Tagged s t a b

A review.

type Review' s a = Review s s a a

type Setter s t a b = Optic Function s t a b

A setter.

type Setter' s a = Setter s s a a

type Traversal s t a b = forall p. Wander p => Optic p s t a b

A traversal.

type Traversal' s a = Traversal s s a a

data Exchange a b s t

The Exchange profunctor characterizes an Iso.

Constructors

• Exchange (s -> a) (b -> t)

Instances

• Functor (Exchange a b s)
• Profunctor (Exchange a b)

newtype Forget :: forall k. Type -> Type -> k -> Typenewtype Forget r a b

Profunctor that forgets the b value and returns (and accumulates) a value of type r.

Forget r is isomorphic to Star (Const r), but can be given a Cochoice instance.

Constructors

• Forget (a -> r)

Instances

• Newtype (Forget r a b) _
• (Semigroup r) => Semigroup (Forget r a b)
• (Monoid r) => Monoid (Forget r a b)
• Profunctor (Forget r)
• (Monoid r) => Choice (Forget r)
• Strong (Forget r)
• Cochoice (Forget r)
• (Monoid r) => Wander (Forget r)

newtype Grating a b s t

Instances

• Newtype (Grating a b s t) _
• Profunctor (Grating a b)
• Closed (Grating a b)

newtype Indexed :: (Type -> Type -> Type) -> Type -> Type -> Type -> Typenewtype Indexed p i s t

Profunctor used for IndexedOptics.

Constructors

• Indexed (p (Tuple i s) t)

Instances

• Newtype (Indexed p i s t) _
• (Profunctor p) => Profunctor (Indexed p i)
• (Strong p) => Strong (Indexed p i)
• (Choice p) => Choice (Indexed p i)
• (Wander p) => Wander (Indexed p i)

data Market a b s t

The Market profunctor characterizes a Prism.

Constructors

• Market (b -> t) (s -> Either t a)

Instances

• Functor (Market a b s)
• Profunctor (Market a b)
• Choice (Market a b)

newtype Re :: (Type -> Type -> Type) -> Type -> Type -> Type -> Type -> Typenewtype Re p s t a b

Constructors

• Re (p b a -> p t s)

Instances

• Newtype (Re p s t a b) _
• (Profunctor p) => Profunctor (Re p s t)
• (Choice p) => Cochoice (Re p s t)
• (Cochoice p) => Choice (Re p s t)
• (Strong p) => Costrong (Re p s t)
• (Costrong p) => Strong (Re p s t)

data Shop a b s t

The Shop profunctor characterizes a Lens.

Constructors

• Shop (s -> a) (s -> b -> t)

Instances

• Profunctor (Shop a b)
• Strong (Shop a b)

data Stall a b s t

The Stall profunctor characterizes an AffineTraversal.

Constructors

• Stall (s -> b -> t) (s -> Either t a)

Instances

• Functor (Stall a b s)
• Profunctor (Stall a b)
• Strong (Stall a b)
• Choice (Stall a b)

newtype Tagged :: forall k. k -> Type -> Typenewtype Tagged a b

Constructors

• Tagged b

Instances

• Newtype (Tagged a b) _
• (Eq b) => Eq (Tagged a b)
• Eq1 (Tagged a)
• (Ord b) => Ord (Tagged a b)
• Ord1 (Tagged a)
• Functor (Tagged a)
• Profunctor Tagged
• Choice Tagged
• Costrong Tagged
• Closed Tagged
• Foldable (Tagged a)
• Traversable (Tagged a)

class Wander :: (Type -> Type -> Type) -> Constraintclass (Strong p, Choice p) <= Wander p  where

Class for profunctors that support polymorphic traversals.

Members

• wander :: forall s t a b. (forall f. Applicative f => (a -> f b) -> s -> f t) -> p a b -> p s t

Instances

• Wander Function
• (Applicative f) => Wander (Star f)