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
- newtype BazaarT a b g t = BazaarT {
- runBazaarT :: forall f. Applicative f => (a -> f b) -> f t
- bazaarT :: Applicative f => (a -> f b) -> BazaarT a b g t -> f t
- duplicateBazaarT :: BazaarT a c f t -> BazaarT a b f (BazaarT b c f t)
- sellT :: a -> BazaarT a b f 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
- newtype Indexing f a = Indexing {
- runIndexing :: Int -> (f a, Int)
- data Prismoid ab st where
- data Isoid ab st where
- newtype Indexed i a b = Indexed {
- withIndex :: (i -> a) -> b
- type family CoA x :: *
- type family CoB x :: *
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) | |
Functor (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) | |
Functor (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) | |
Functor (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
newtype BazaarT a b g t Source
BazaarT
is like Bazaar
, except that it provides a questionable Gettable
instance
To protect this instance it relies on the soundness of another Gettable
type, and usage conventions.
For example. This lets us write a suitably polymorphic and lazy taking
, but there
must be a better way!
BazaarT | |
|
bazaarT :: Applicative f => (a -> f b) -> BazaarT a b g t -> f tSource
Extract from a BazaarT
.
bazaarT
=flip
runBazaarT
duplicateBazaarT :: BazaarT a c f t -> BazaarT a b f (BazaarT b c f t)Source
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 |
Indexing | |
|
Overloadings
data Prismoid ab st whereSource
This data type is used to capture all of the information provided by the
Prismatic
class, so you can turn a Prism
around into a Getter
or
otherwise muck around with its internals.
If you see a function that expects a Prismoid
or APrism
, it is probably
just expecting a Prism
.
Reify all of the information given to you by being Isomorphic
.
A function with access to a index. This constructor may be useful when you need to store
a Indexable
in a container to avoid ImpredicativeTypes
.