Copyright  (C) 20122016 Edward Kmett 

License  BSDstyle (see the file LICENSE) 
Maintainer  Edward Kmett <ekmett@gmail.com> 
Stability  experimental 
Portability  nonportable 
Safe Haskell  Safe 
Language  Haskell98 
 class Profunctor p => Bizarre p w  w > p where
 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 where Source #
This class is used to run the various Bazaar
variants used in this
library.
bazaar :: Applicative f => p a (f b) > w a b t > f t Source #
newtype Bazaar 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/nonregular1
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 Bazaar
a b tN
a
s and a function from N
b
s 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
.
Bazaar  

Corepresentable p => Sellable p (Bazaar p) Source #  
Profunctor p => Bizarre p (Bazaar p) Source #  
Conjoined p => IndexedComonad (Bazaar p) Source #  
IndexedFunctor (Bazaar p) Source #  
Functor (Bazaar p a b) Source #  
Applicative (Bazaar p a b) Source #  
((~) * a b, Conjoined p) => Comonad (Bazaar p a b) Source #  
((~) * a b, Conjoined p) => ComonadApply (Bazaar p a b) Source #  
Apply (Bazaar p a b) Source #  
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!
BazaarT  

Corepresentable p => Sellable p (BazaarT p g) Source #  
Profunctor p => Bizarre p (BazaarT p g) Source #  
Conjoined p => IndexedComonad (BazaarT p g) Source #  
IndexedFunctor (BazaarT p g) Source #  
Functor (BazaarT p g a b) Source #  
Applicative (BazaarT p g a b) Source #  
(Profunctor p, Contravariant g) => Contravariant (BazaarT p g a b) Source #  
((~) * a b, Conjoined p) => Comonad (BazaarT p g a b) Source #  
((~) * a b, Conjoined p) => ComonadApply (BazaarT p g a b) Source #  
Apply (BazaarT p g a b) Source #  
Contravariant g => Semigroup (BazaarT p g a b t) Source #  
Contravariant g => Monoid (BazaarT p g a b t) Source #  
class Profunctor p => Bizarre1 p w  w > p where Source #
Profunctor p => Bizarre1 p (Bazaar1 p) Source #  
Profunctor p => Bizarre1 p (BazaarT1 p g) Source #  
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/nonregular1
A Bazaar1
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 Bazaar1
a b tN
a
s and a function from N
b
s 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
.
Bazaar1  

Corepresentable p => Sellable p (Bazaar1 p) Source #  
Profunctor p => Bizarre1 p (Bazaar1 p) Source #  
Conjoined p => IndexedComonad (Bazaar1 p) Source #  
IndexedFunctor (Bazaar1 p) Source #  
Functor (Bazaar1 p a b) Source #  
((~) * a b, Conjoined p) => Comonad (Bazaar1 p a b) Source #  
((~) * a b, Conjoined p) => ComonadApply (Bazaar1 p a b) Source #  
Apply (Bazaar1 p a b) Source #  
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!
BazaarT1  

Corepresentable p => Sellable p (BazaarT1 p g) Source #  
Profunctor p => Bizarre1 p (BazaarT1 p g) Source #  
Conjoined p => IndexedComonad (BazaarT1 p g) Source #  
IndexedFunctor (BazaarT1 p g) Source #  
Functor (BazaarT1 p g a b) Source #  
(Profunctor p, Contravariant g) => Contravariant (BazaarT1 p g a b) Source #  
((~) * a b, Conjoined p) => Comonad (BazaarT1 p g a b) Source #  
((~) * a b, Conjoined p) => ComonadApply (BazaarT1 p g a b) Source #  
Apply (BazaarT1 p g a b) Source #  
Contravariant g => Semigroup (BazaarT1 p g a b t) Source #  