Lens.Family.Clone

This module is provided for Haskell 98 compatibility. If you are able to use Rank2Types, I advise you to instead use the rank 2 aliases

• Lens, Lens'
• Traversal, Traversal'
• Setter, Setter'
• Fold, Fold'
• Getter, Getter'

from the lens-family package instead.

cloneLens allows one to circumvent the need for rank 2 types by allowing one to take a universal monomorphic lens instance and rederive a polymorphic instance. When you require a lens family parameter you use the type ALens a a' b b' (or ALens' a b). Then, inside a where clause, you use cloneLens to create a Lens type.

For example.

example :: ALens a a' b b' -> Example
example l = ... x^.cl ... cl .~ y ...
 where
  cl x = cloneLens l x

Note: It is important to eta-expand the definition of cl to avoid the dreaded monomorphism restriction.

cloneTraversal, cloneGetter, cloneSetter, and cloneFold provides similar functionality for traversals, getters, setters, and folds respectively.

Note: Cloning is only need if you use a functional reference multiple times with different instances.

Documentation

cloneLens :: Functor f => ALens a a' b b' -> LensLike f a a' b b'

Converts a universal lens instance back into a polymorphic lens.

cloneTraversal :: Applicative f => ATraversal a a' b b' -> LensLike f a a' b b'

Converts a universal traversal instance back into a polymorphic traversal.

cloneSetter :: Identical f => ASetter a a' b b' -> LensLike f a a' b b'

Converts a universal setter instance back into a polymorphic setter.

cloneGetter :: Phantom f => AGetter a a' b b' -> LensLike f a a' b b'

Converts a universal getter instance back into a polymorphic getter.

cloneFold :: (Phantom f, Applicative f) => AFold a a' b b' -> LensLike f a a' b b'

Converts a universal fold instance back into a polymorphic fold.

Types

type ALens a a' b b' = LensLike (IStore b b') a a' b b'

ALens a a' b b' is a universal Lens a a' b b' instance

type ALens' a b = LensLike' (IStore b b) a b

ALens' a b is a universal Lens' a b instance

type ATraversal a a' b b' = LensLike (IKleeneStore b b') a a' b b'

ATraversal a a' b b' is a universal Traversal a a' b b' instance

type ATraversal' a b = LensLike' (IKleeneStore b b) a b

ATraversal' a b is a universal Traversal' a b instance

type AGetter a a' b b' = FoldLike b a a' b b'

AGetter a a' b b' is a universal Fold a a' b b' instance

type AGetter' a b = FoldLike' b a b

AGetter' a b is a universal Fold' a b instance

type AFold a a' b b' = FoldLike [b] a a' b b'

AFold a a' b b' is a universal Fold' a a' b b' instance

type AFold' a b = FoldLike' [b] a b

AFold' a b is a universal Fold' a b instance

data IStore b b' a

Instances

Functor (IStore b b')

data IKleeneStore b b' a

Instances

Functor (IKleeneStore b b')

Applicative (IKleeneStore b b')

Re-exports

type LensLike f a a' b b' = (b -> f b') -> a -> f a'

type LensLike' f a b = (b -> f b) -> a -> f a

type FoldLike r a a' b b' = LensLike (Constant r) a a' b b'

type FoldLike' r a b = LensLike' (Constant r) a b

type ASetter a a' b b' = LensLike Identity a a' b b'

class Functor f => Applicative f

A functor with application, providing operations to

• embed pure expressions (pure), and
• sequence computations and combine their results (<*>).

A minimal complete definition must include implementations of these functions satisfying the following laws:

identity

pure id <*> v = v

composition

pure (.) <*> u <*> v <*> w = u <*> (v <*> w)

homomorphism

pure f <*> pure x = pure (f x)

interchange

u <*> pure y = pure ($ y) <*> u

The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:

• u *> v = pure (const id) <*> u <*> v

• u <* v = pure const <*> u <*> v

As a consequence of these laws, the Functor instance for f will satisfy

• fmap f x = pure f <*> x

If f is also a Monad, it should satisfy

• pure = return

• (<*>) = ap

(which implies that pure and <*> satisfy the applicative functor laws).

Minimal complete definition

pure, (<*>)

Instances

Applicative []

Applicative IO

Applicative ZipList

Applicative STM

Applicative ReadPrec

Applicative ReadP

Applicative Maybe

Applicative Identity

Applicative ((->) a)

Applicative (Either e)

Monoid a => Applicative ((,) a)

Applicative (ST s)

Monoid m => Applicative (Const m)

Monad m => Applicative (WrappedMonad m)

Applicative (ST s)

Arrow a => Applicative (ArrowMonad a)

Applicative (Proxy *)

Applicative f => Applicative (Backwards f)

Apply f-actions in the reverse order.

Monoid a => Applicative (Constant a)

Arrow a => Applicative (WrappedArrow a b)

(Monoid w, Applicative m) => Applicative (WriterT w m)

(Functor m, Monad m) => Applicative (StateT s m)

(Functor m, Monad m) => Applicative (StateT s m)

(Applicative f, Applicative g) => Applicative (Compose f g)

(Monoid c, Monad m) => Applicative (Zooming m c)

Applicative (IKleeneStore b b')

Typeable ((* -> *) -> Constraint) Applicative

class Functor f => Phantom f

Minimal complete definition

coerce

Instances

Phantom (Const a)

Phantom f => Phantom (Backwards f)

Phantom (Constant a)

(Phantom f, Functor g) => Phantom (Compose f g)

Phantom f => Phantom (AlongsideRight f a)

Phantom f => Phantom (AlongsideLeft f a)

class Applicative f => Identical f

Minimal complete definition

extract

Instances

Identical Identity

Identical f => Identical (Backwards f)

(Identical f, Identical g) => Identical (Compose f g)