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.
- class Functor f => Gettable f where
- coerce :: f a -> f b
- class (Monad m, Gettable f) => Effective m r f | f -> m r where
- effective :: Isomorphic k => k (m r) (f a)
- ineffective :: Effective m r f => Isomorphic k => k (f a) (m r)
- noEffect :: (Applicative f, Gettable f) => f a
- class Applicative f => Settable f where
- untainted :: f a -> a
- untainted# :: (a -> f b) -> a -> b
- tainted# :: (a -> b) -> a -> f b
- 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 EvilBazaar g a b s
Internal Classes
class Functor f => Gettable f whereSource
Generalizing Const
so we can apply simple Applicative
transformations to it and so we can get nicer error messages
A Gettable
Functor
ignores its argument, which it carries solely as a
phantom type parameter.
To ensure this, an instance of Gettable
is required to satisfy:
id
=fmap
f =coerce
Functor (Const r) => Gettable (Const r) | |
(Functor (Backwards f), Gettable f) => Gettable (Backwards f) | |
(Functor (ElementOf f), Gettable f) => Gettable (ElementOf f) | |
Functor (Accessor r) => Gettable (Accessor r) | |
(Functor (Indexing f), Gettable f) => Gettable (Indexing f) | |
(Functor (Compose f g), Functor f, Gettable g) => Gettable (Compose f g) | |
Functor (Effect m r) => Gettable (Effect m r) | |
(Functor (EvilBazaar g a b), Gettable g) => Gettable (EvilBazaar g a b) | |
Functor (EffectRWS w st m s) => Gettable (EffectRWS w st m s) |
class (Monad m, Gettable f) => Effective m r f | f -> m r whereSource
An Effective
Functor
ignores its argument and is isomorphic to a monad wrapped around a value.
That said, the monad is possibly rather unrelated to any Applicative
structure.
effective :: Isomorphic k => k (m r) (f a)Source
ineffective :: Effective m r f => Isomorphic k => k (f a) (m r)Source
A convenient antonym that is used internally.
noEffect :: (Applicative f, Gettable f) => f aSource
The mempty
equivalent for a Gettable
Applicative
Functor
.
class Applicative f => Settable f whereSource
untainted# :: (a -> f b) -> a -> bSource
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
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
Functor f => Functor (ElementOfResult f) |
ElementOf | |
|
Indexing | |
|
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.
Evil Internal Types
data EvilBazaar g a b s Source
EvilBazaar
is like Bazaar
, except that it has an evil Gettable
instance
where
.
coerce
= unsafeCoerce
This lets us write a suitably polymorphic and lazy taking
, but there *must* be a better way!.
This type isn't exported from the package in a way that allows anyone to
write unsafeCoerce
with it. It's only used in the implementation of
taking
.
g
is a phantom type used in the Gettable
instance.
Functor (EvilBazaar g a b) | |
Functor (EvilBazaar g a b) => Applicative (EvilBazaar g a b) | |
(Functor (EvilBazaar g a b), Gettable g) => Gettable (EvilBazaar g a b) |