Portability | Rank2Types |
---|---|
Stability | provisional |
Maintainer | Edward Kmett <ekmett@gmail.com> |
Safe Haskell | Trustworthy |
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.
- newtype May a = May {}
- newtype Folding f a = Folding {
- getFolding :: f a
- newtype Effect m r a = Effect {
- getEffect :: m r
- newtype EffectRWS w st m s a = EffectRWS {
- getEffectRWS :: st -> m (s, st, w)
- newtype Accessor r a = Accessor {
- runAccessor :: r
- newtype Err e a = Err {}
- newtype Traversed f = Traversed {
- getTraversed :: f ()
- newtype Sequenced m = Sequenced {
- getSequenced :: m ()
- newtype Focusing m s a = Focusing {
- unfocusing :: m (s, a)
- newtype FocusingWith w m s a = FocusingWith {
- unfocusingWith :: m (s, a, w)
- newtype FocusingPlus w k s a = FocusingPlus {
- unfocusingPlus :: k (s, w) a
- newtype FocusingOn f k s a = FocusingOn {
- unfocusingOn :: k (f s) a
- newtype FocusingMay k s a = FocusingMay {
- unfocusingMay :: k (May s) a
- newtype FocusingErr e k s a = FocusingErr {
- unfocusingErr :: k (Err e s) a
- newtype Mutator a = Mutator {
- runMutator :: a
- newtype Bazaar a b t = Bazaar {
- runBazaar :: forall f. Applicative f => (a -> f b) -> f t
- bazaar :: Applicative f => (a -> f b) -> Bazaar a b t -> f t
- duplicateBazaar :: Bazaar a c t -> Bazaar a b (Bazaar b c t)
- sell :: a -> Bazaar a b b
- data Context a b t = Context (b -> t) a
- data Max a
- getMax :: Max a -> Maybe a
- data Min a
- getMin :: Min a -> Maybe a
- data ElementOfResult f a = Searching Int a (Maybe (f a))
- newtype ElementOf f a = ElementOf {
- getElementOf :: Int -> ElementOfResult f a
- newtype Indexing f a = Indexing {
- runIndexing :: Int -> (f a, Int)
- data Level a = Level !Int [a] a [a]
- levelWidth :: Level a -> Int
- leftLevel :: Level a -> Maybe (Level a)
- left1Level :: Level a -> Level a
- leftmostLevel :: Level a -> Level a
- rightmostLevel :: Level a -> Level a
- rightLevel :: Level a -> Maybe (Level a)
- right1Level :: Level a -> Level a
- focusLevel :: Functor f => (a -> f a) -> Level a -> f (Level a)
- rezipLevel :: Level a -> NonEmpty a
- data BazaarT a b g s
Internal Types
Make a monoid out of Maybe
for error handling
A Monoid
for a Gettable
Applicative
.
Folding | |
|
(Gettable f, Applicative f) => Monoid (Folding f a) |
Wrap a monadic effect with a phantom type argument.
(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 Source
Wrap a monadic effect with a phantom type argument. Used when magnifying RWST.
EffectRWS | |
|
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 |
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.
Accessor | |
|
(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 |
|
Make a monoid out of Either
for error handling
Used internally by traverseOf_
and the like.
Traversed | |
|
Applicative f => Monoid (Traversed f) |
Used internally by mapM_
and the like.
Sequenced | |
|
Focusing | |
|
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 Source
FocusingWith | |
|
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 Source
FocusingPlus | |
|
(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 Source
FocusingOn | |
|
(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 Source
FocusingMay | |
|
(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 Source
FocusingErr | |
|
(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) |
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.
Mutator | |
|
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
is isomorphic to Bazaar
a b tdata 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
holds an Context
a b ta
and a function from b
to
t
, a
holds N Bazaar
a b ta
s and a function from N
b
s to t
.
Mnemonically, a Bazaar
holds many stores and you can easily add more.
This is a final encoding of Bazaar
.
Bazaar | |
|
bazaar :: Applicative f => (a -> f b) -> Bazaar a b t -> f tSource
The indexed store can be used to characterize a Lens
and is used by clone
is isomorphic to
Context
a b tnewtype 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.
Context (b -> t) a |
data ElementOfResult f a Source
The result of searching for a particular element in a Traversal.
Functor f => Functor (ElementOfResult f) |
Searches for a particular element in a Traversal.
ElementOf | |
|
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) |
Indexing | |
|
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) |
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.
levelWidth :: Level a -> IntSource
How many entries are there in this level?
left1Level :: Level a -> Level aSource
Pull the non-empty list zipper left one entry, stopping at the first entry.
leftmostLevel :: Level a -> Level aSource
Pull the non-empty list zipper all the way to the left.
rightmostLevel :: Level a -> Level aSource
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)Source
Pull the non-empty list zipper right one entry.
right1Level :: Level a -> Level aSource
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)Source
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 aSource
Zip a non-empty list zipper back up, and return the result.
Hidden implementations
BazaarT
is like Bazaar
, except that it provides a questionable Gettable
instance
where
. 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 coerce
= unsafeCoerce
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.
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) |