Control.Lens.Internal

These are some of the explicit Functor instances that leak into the type signatures of Control.Lens. You shouldn't need to import this module directly, unless you are coming up with a whole new kind of "Family" and need to add instances.

Internal Types

newtype May a

Make a monoid out of Maybe for error handling

Constructors

May

Fields

getMay :: Maybe a

Instances

Monoid a => Monoid (May a)

newtype Folding f a

A Monoid for a Gettable Applicative.

Constructors

Folding

Fields

getFolding :: f a

Instances

(Gettable f, Applicative f) => Monoid (Folding f a)

newtype Effect m r a

Wrap a monadic effect with a phantom type argument.

Constructors

Effect

Fields

getEffect :: m r

Instances

(Gettable (Effect m r), Monad m) => Effective m r (Effect m r)

Functor (Effect m r)

(Functor (Effect m r), Monad m, Monoid r) => Applicative (Effect m r)

Trustworthy (Effect m r)

(Functor (Effect m r), Trustworthy (Effect m r)) => Gettable (Effect m r)

(MonadReader b (ReaderT b m), MonadReader a (ReaderT a m), Monad m) => Magnify (ReaderT b m) (ReaderT a m) (Effect m) b a

(Monad m, Monoid r) => Monoid (Effect m r a)

newtype EffectRWS w st m s a

Wrap a monadic effect with a phantom type argument. Used when magnifying RWST.

Constructors

EffectRWS

Fields

getEffectRWS :: st -> m (s, st, w)

Instances

Functor (EffectRWS w st m s)

(Functor (EffectRWS w st m s), Monoid s, Monoid w, Monad m) => Applicative (EffectRWS w st m s)

Trustworthy (EffectRWS w st m s)

(Functor (EffectRWS w st m s), Trustworthy (EffectRWS w st m s)) => Gettable (EffectRWS w st m s)

(MonadReader b (RWST b w s m), MonadReader a (RWST a w s m), Monad m, Monoid w) => Magnify (RWST b w s m) (RWST a w s m) (EffectRWS w s m) b a

(MonadReader b (RWST b w s m), MonadReader a (RWST a w s m), Monad m, Monoid w) => Magnify (RWST b w s m) (RWST a w s m) (EffectRWS w s m) b a

newtype Accessor r a

Used instead of Const to report

No instance of (Settable Accessor)

when the user attempts to misuse a Setter as a Getter, rather than a monolithic unification error.

Constructors

Accessor

Fields

runAccessor :: r

Instances

(Monad Identity, Gettable (Accessor r)) => Effective Identity r (Accessor r)

Functor (Accessor r)

(Functor (Accessor r), Monoid r) => Applicative (Accessor r)

Trustworthy (Accessor r)

(Functor (Accessor r), Trustworthy (Accessor r)) => Gettable (Accessor r)

(MonadReader b ((->) b), MonadReader a ((->) a)) => Magnify ((->) b) ((->) a) Accessor b a

magnify = views

newtype Err e a

Make a monoid out of Either for error handling

Constructors

Err

Fields

getErr :: Either e a

Instances

Monoid a => Monoid (Err e a)

newtype Traversed f

Used internally by traverseOf_ and the like.

Constructors

Traversed

Fields

getTraversed :: f ()

Instances

Applicative f => Monoid (Traversed f)

newtype Sequenced m

Used internally by mapM_ and the like.

Constructors

Sequenced

Fields

getSequenced :: m ()

Instances

Monad m => Monoid (Sequenced m)

newtype Focusing m s a

Used by Zoom to zoom into StateT

Constructors

Focusing

Fields

unfocusing :: m (s, a)

Instances

Monad m => Functor (Focusing m s)

(Functor (Focusing m s), Monad m, Monoid s) => Applicative (Focusing m s)

(MonadState s (StateT s z), MonadState t (StateT t z), Monad z) => Zoom (StateT s z) (StateT t z) (Focusing z) s t

(MonadState s (StateT s z), MonadState t (StateT t z), Monad z) => Zoom (StateT s z) (StateT t z) (Focusing z) s t

newtype FocusingWith w m s a

Used by Zoom to zoom into RWST

Constructors

FocusingWith

Fields

unfocusingWith :: m (s, a, w)

Instances

Monad m => Functor (FocusingWith w m s)

(Functor (FocusingWith w m s), Monad m, Monoid s, Monoid w) => Applicative (FocusingWith w m s)

(MonadState s (RWST r w s z), MonadState t (RWST r w t z), Monoid w, Monad z) => Zoom (RWST r w s z) (RWST r w t z) (FocusingWith w z) s t

(MonadState s (RWST r w s z), MonadState t (RWST r w t z), Monoid w, Monad z) => Zoom (RWST r w s z) (RWST r w t z) (FocusingWith w z) s t

newtype FocusingPlus w k s a

Used by Zoom to zoom into WriterT.

Constructors

FocusingPlus

Fields

unfocusingPlus :: k (s, w) a

Instances

(MonadState s (WriterT w m), MonadState t (WriterT w n), Monoid w, Zoom m n k s t) => Zoom (WriterT w m) (WriterT w n) (FocusingPlus w k) s t

(MonadState s (WriterT w m), MonadState t (WriterT w n), Monoid w, Zoom m n k s t) => Zoom (WriterT w m) (WriterT w n) (FocusingPlus w k) s t

Functor (k (s, w)) => Functor (FocusingPlus w k s)

(Functor (FocusingPlus w k s), Monoid w, Applicative (k (s, w))) => Applicative (FocusingPlus w k s)

newtype FocusingOn f k s a

Used by Zoom to zoom into MaybeT or ListT

Constructors

FocusingOn

Fields

unfocusingOn :: k (f s) a

Instances

(MonadState s (ListT m), MonadState t (ListT n), Zoom m n k s t) => Zoom (ListT m) (ListT n) (FocusingOn [] k) s t

Functor (k (f s)) => Functor (FocusingOn f k s)

(Functor (FocusingOn f k s), Applicative (k (f s))) => Applicative (FocusingOn f k s)

newtype FocusingMay k s a

Used by Zoom to zoom into ErrorT

Constructors

FocusingMay

Fields

unfocusingMay :: k (May s) a

Instances

(MonadState s (MaybeT m), MonadState t (MaybeT n), Zoom m n k s t) => Zoom (MaybeT m) (MaybeT n) (FocusingMay k) s t

Functor (k (May s)) => Functor (FocusingMay k s)

(Functor (FocusingMay k s), Applicative (k (May s))) => Applicative (FocusingMay k s)

newtype FocusingErr e k s a

Used by Zoom to zoom into ErrorT

Constructors

FocusingErr

Fields

unfocusingErr :: k (Err e s) a

Instances

(MonadState s (ErrorT e m), MonadState t (ErrorT e n), Error e, Zoom m n k s t) => Zoom (ErrorT e m) (ErrorT e n) (FocusingErr e k) s t

Functor (k (Err e s)) => Functor (FocusingErr e k s)

(Functor (FocusingErr e k s), Applicative (k (Err e s))) => Applicative (FocusingErr e k s)

newtype Mutator a

Mutator is just a renamed Identity functor to give better error messages when someone attempts to use a getter as a setter.

Most user code will never need to see this type.

Constructors

Mutator

Fields

runMutator :: a

Instances

Functor Mutator

Applicative Mutator

Settable Mutator

newtype Bazaar a b t

This is used to characterize a Traversal.

a.k.a. indexed Cartesian store comonad, indexed Kleene store comonad, or an indexed FunList.

http://twanvl.nl/blog/haskell/non-regular1

Bazaar a b t is isomorphic to data Bazaar a b t = Buy t | Trade (Bazaar a b (b -> t)) a, and to exists s. (s, Traversal s t a b).

A Bazaar is like a Traversal that has already been applied to some structure.

Where a Context a b t holds an a and a function from b to t, a Bazaar a b t holds N as and a function from N bs to t.

Mnemonically, a Bazaar holds many stores and you can easily add more.

This is a final encoding of Bazaar.

Constructors

Bazaar

Fields

runBazaar :: forall f. Applicative f => (a -> f b) -> f t

Instances

Functor (Bazaar a b)

Functor (Bazaar a b) => Applicative (Bazaar a b)

(Functor (Bazaar a b), ~ * a b) => Comonad (Bazaar a b)

(Comonad (Bazaar a b), ~ * a b) => ComonadApply (Bazaar a b)

bazaar :: Applicative f => (a -> f b) -> Bazaar a b t -> f t

Given an action to run for each matched pair, traverse a bazaar.

bazaar :: Traversal (Bazaar a b t) t a b

duplicateBazaar :: Bazaar a c t -> Bazaar a b (Bazaar b c t)

Bazaar is an indexed Comonad.

sell :: a -> Bazaar a b b

A trivial Bazaar.

data Context a b t

The indexed store can be used to characterize a Lens and is used by clone

Context a b t is isomorphic to newtype Context a b t = Context { runContext :: forall f. Functor f => (a -> f b) -> f t }, and to exists s. (s, Lens s t a b).

A Context is like a Lens that has already been applied to a some structure.

Constructors

Context (b -> t) a

Instances

(Comonad (Context a b), ~ * a b) => ComonadStore a (Context a b)

Functor (Context a b)

(Functor (Context a b), ~ * a b) => Comonad (Context a b)

data Max a

Used for maximumOf

Constructors

NoMax

Max a

Instances

Ord a => Monoid (Max a)

getMax :: Max a -> Maybe a

Obtain the maximum

data Min a

Used for minimumOf

Constructors

NoMin

Min a

Instances

Ord a => Monoid (Min a)

getMin :: Min a -> Maybe a

Obtain the minimum.

data ElementOfResult f a

The result of searching for a particular element in a Traversal.

Constructors

Searching Int a (Maybe (f a))

Instances

Functor f => Functor (ElementOfResult f)

newtype ElementOf f a

Searches for a particular element in a Traversal.

Constructors

ElementOf

Fields

getElementOf :: Int -> ElementOfResult f a

Instances

Functor f => Functor (ElementOf f)

(Functor (ElementOf f), Functor f) => Applicative (ElementOf f)

Trustworthy f => Trustworthy (ElementOf f)

(Functor (ElementOf f), Trustworthy (ElementOf f), Gettable f) => Gettable (ElementOf f)

newtype Indexing f a

Applicative composition of State Int with a Functor, used by indexed

Constructors

Indexing

Fields

runIndexing :: Int -> (f a, Int)

Instances

Functor f => Functor (Indexing f)

(Functor (Indexing f), Applicative f) => Applicative (Indexing f)

Trustworthy f => Trustworthy (Indexing f)

(Functor (Indexing f), Trustworthy (Indexing f), Gettable f) => Gettable (Indexing f)

data Level a

A basic non-empty list zipper

All combinators assume the invariant that the length stored matches the number of elements in list of items to the left, and the list of items to the left is stored reversed.

Constructors

Level !Int [a] a [a]

Instances

Functor Level

Foldable Level

Traversable Level

Comonad Level

ComonadStore Int Level

levelWidth :: Level a -> Int

How many entries are there in this level?

leftLevel :: Level a -> Maybe (Level a)

Pull the non-emtpy list zipper left one entry

left1Level :: Level a -> Level a

Pull the non-empty list zipper left one entry, stopping at the first entry.

leftmostLevel :: Level a -> Level a

Pull the non-empty list zipper all the way to the left.

rightmostLevel :: Level a -> Level a

Pul the non-empty list zipper all the way to the right. NB:, when given an infinite list this may not terminate.

rightLevel :: Level a -> Maybe (Level a)

Pull the non-empty list zipper right one entry.

right1Level :: Level a -> Level a

Pull the non-empty list zipper right one entry, stopping at the last entry.

focusLevel :: Functor f => (a -> f a) -> Level a -> f (Level a)

This is a Lens targeting the value that we would extract from the non-empty list zipper.

view focusLevel ≡ extract

focusLevel :: Simple Lens (Level a) a

rezipLevel :: Level a -> NonEmpty a

Zip a non-empty list zipper back up, and return the result.

Hidden implementations

data BazaarT a b g s

BazaarT is like Bazaar, except that it provides a questionable Gettable instance where coerce = unsafeCoerce. To protect this instance it relies on a combination of the fact that we do not export the tools for working with this type, beyond its type signature to user code, and the fact that it borrows a proof obligation that the Gettable instance is sound from another Getter.

For example. This lets us write a suitably polymorphic and lazy taking, but there must be a better way!

g is a phantom type used in the Gettable instance.

Instances

Functor (BazaarT a b g)

Functor (BazaarT a b g) => Applicative (BazaarT a b g)

Trustworthy g => Trustworthy (BazaarT a b g)

(Functor (BazaarT a b g), Trustworthy (BazaarT a b g), Gettable g) => Gettable (BazaarT a b g)