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'
• 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, and cloneFold provides similar functionality for traversals, getters and folds respectively. Setters are already monomorphic, so do not need to be cloned.

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.

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 = ALens a a b 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 = ALens a a b 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 = AGetter a a b 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 = AFold a a b 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 FoldLike r a a' b b' = LensLike (Getting r) 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 and (<*>) = ap (which implies that pure and <*> satisfy the applicative functor laws).

Instances

Applicative []

Applicative IO

Applicative ZipList

Applicative STM

Applicative ReadPrec

Applicative ReadP

Applicative Maybe

Applicative Identity

Applicative Setting

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 f => Applicative (Backwards f)

Apply f-actions in the reverse order.

Monoid a => Applicative (Constant a)

Monoid c => Applicative (Getting c)

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')

class Functor f => Phantom f

Instances

Phantom (Const a)

Phantom f => Phantom (Backwards f)

Phantom (Constant a)

Phantom (Getting c)

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

Phantom f => Phantom (AlongsideRight f a)

Phantom f => Phantom (AlongsideLeft f a)