Copyright | (C) 2012-2016 Edward Kmett |
---|---|
License | BSD-style (see the file LICENSE) |
Maintainer | Edward Kmett <ekmett@gmail.com> |
Stability | experimental |
Portability | non-portable |
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 #
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 #
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
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) # | |
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) # | |
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) # | |
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) # | |
(Profunctor p, Contravariant g) => Contravariant (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) # | |
Apply (BazaarT p g a b) # | |
Contravariant g => Semigroup (BazaarT p g a b t) # | |
Contravariant g => Monoid (BazaarT p g a b t) # | |
class Profunctor p => Bizarre1 p w | w -> p where #
Profunctor p => Bizarre1 p (Bazaar1 p) # | |
Profunctor p => Bizarre1 p (BazaarT1 p g) # | |
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
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) # | |
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) # | |
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) # | |
Profunctor p => Bizarre1 p (BazaarT1 p g) # | |
Conjoined p => IndexedComonad (BazaarT1 p g) # | |
IndexedFunctor (BazaarT1 p g) # | |
Functor (BazaarT1 p g a b) # | |
(Profunctor p, Contravariant g) => Contravariant (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) # | |
Apply (BazaarT1 p g a b) # | |
Contravariant g => Semigroup (BazaarT1 p g a b t) # | |