| Portability | non-portable |
|---|---|
| Stability | experimental |
| Maintainer | Edward Kmett <ekmett@gmail.com> |
| Safe Haskell | Trustworthy |
Control.Lens.Internal.Bazaar
Description
- class Profunctor p => Bizarre p w | w -> p where
- bazaar :: Applicative f => p a (f b) -> w a b t -> f t
- newtype Bazaar p a b t = Bazaar {
- runBazaar :: forall f. Applicative f => p a (f b) -> f t
- type Bazaar' p a = Bazaar p a a
- newtype BazaarT p g a b t = BazaarT {
- runBazaarT :: forall f. Applicative f => p a (f b) -> f t
- type BazaarT' p g a = BazaarT p g a a
- class Profunctor p => Bizarre1 p w | w -> p where
- newtype Bazaar1 p a b t = Bazaar1 {
- runBazaar1 :: forall f. Apply f => p a (f b) -> f t
- type Bazaar1' p a = Bazaar1 p a a
- newtype BazaarT1 p g a b t = BazaarT1 {
- runBazaarT1 :: forall f. Apply f => p a (f b) -> f t
- type BazaarT1' p g a = BazaarT1 p g a a
Documentation
class Profunctor p => Bizarre p w | w -> p whereSource
This class is used to run the various Bazaar variants used in this
library.
Methods
bazaar :: Applicative f => p a (f b) -> w a b t -> f tSource
Instances
| Profunctor p => Bizarre p (Bazaar p) | |
| Profunctor p => Bizarre p (BazaarT p g) | |
| Corepresentable p => Bizarre p (TakingWhile p g) | |
| Bizarre (Indexed Int) Mafic | |
| Bizarre (Indexed i) (Molten i) |
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
A Bazaar is like a Traversal that has already been applied to some structure.
Where a Context a b ta and a function from b to
t, a Bazaar a b tN as and a function from N
bs to t, (where N might be infinite).
Mnemonically, a Bazaar holds many stores and you can easily add more.
This is a final encoding of Bazaar.
Constructors
| Bazaar | |
Fields
| |
Instances
| Corepresentable p => Sellable p (Bazaar p) | |
| Profunctor p => Bizarre p (Bazaar p) | |
| Conjoined p => IndexedComonad (Bazaar p) | |
| IndexedFunctor (Bazaar p) | |
| Functor (Bazaar p a b) | |
| Applicative (Bazaar p a b) | |
| (~ * a b, Conjoined p) => Comonad (Bazaar p a b) | |
| (~ * a b, Conjoined p) => ComonadApply (Bazaar p a b) | |
| Apply (Bazaar p a b) |
newtype BazaarT p g a b t Source
BazaarT is like Bazaar, except that it provides a questionable Contravariant instance
To protect this instance it relies on the soundness of another Contravariant type, and usage conventions.
For example. This lets us write a suitably polymorphic and lazy taking, but there
must be a better way!
Constructors
| BazaarT | |
Fields
| |
Instances
| Corepresentable p => Sellable p (BazaarT p g) | |
| Profunctor p => Bizarre p (BazaarT p g) | |
| Conjoined p => IndexedComonad (BazaarT p g) | |
| IndexedFunctor (BazaarT p g) | |
| Functor (BazaarT p g a b) | |
| Applicative (BazaarT p g a b) | |
| (~ * a b, Conjoined p) => Comonad (BazaarT p g a b) | |
| (~ * a b, Conjoined p) => ComonadApply (BazaarT p g a b) | |
| (Profunctor p, Contravariant g) => Contravariant (BazaarT p g a b) | |
| Apply (BazaarT p g a b) | |
| Contravariant g => Monoid (BazaarT p g a b t) | |
| Contravariant g => Semigroup (BazaarT p g a b t) |
class Profunctor p => Bizarre1 p w | w -> p whereSource
Instances
| Profunctor p => Bizarre1 p (Bazaar1 p) | |
| Profunctor p => Bizarre1 p (BazaarT1 p g) |
newtype Bazaar1 p a b t Source
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
A Bazaar1 is like a Traversal that has already been applied to some structure.
Where a Context a b ta and a function from b to
t, a Bazaar1 a b tN as and a function from N
bs to t, (where N might be infinite).
Mnemonically, a Bazaar1 holds many stores and you can easily add more.
This is a final encoding of Bazaar1.
Constructors
| Bazaar1 | |
Fields
| |
Instances
| Corepresentable p => Sellable p (Bazaar1 p) | |
| Profunctor p => Bizarre1 p (Bazaar1 p) | |
| Conjoined p => IndexedComonad (Bazaar1 p) | |
| IndexedFunctor (Bazaar1 p) | |
| Functor (Bazaar1 p a b) | |
| (~ * a b, Conjoined p) => Comonad (Bazaar1 p a b) | |
| (~ * a b, Conjoined p) => ComonadApply (Bazaar1 p a b) | |
| Apply (Bazaar1 p a b) |
newtype BazaarT1 p g a b t Source
BazaarT1 is like Bazaar1, except that it provides a questionable Contravariant instance
To protect this instance it relies on the soundness of another Contravariant type, and usage conventions.
For example. This lets us write a suitably polymorphic and lazy taking, but there
must be a better way!
Constructors
| BazaarT1 | |
Fields
| |
Instances
| Corepresentable p => Sellable p (BazaarT1 p g) | |
| Profunctor p => Bizarre1 p (BazaarT1 p g) | |
| Conjoined p => IndexedComonad (BazaarT1 p g) | |
| IndexedFunctor (BazaarT1 p g) | |
| Functor (BazaarT1 p g a b) | |
| (~ * a b, Conjoined p) => Comonad (BazaarT1 p g a b) | |
| (~ * a b, Conjoined p) => ComonadApply (BazaarT1 p g a b) | |
| (Profunctor p, Contravariant g) => Contravariant (BazaarT1 p g a b) | |
| Apply (BazaarT1 p g a b) | |
| Contravariant g => Semigroup (BazaarT1 p g a b t) |