Control.Lens.Internal.Bazaar

Documentation

class Profunctor p => Bizarre p w | w -> p where

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 t

Instances

Profunctor p => Bizarre p (Bazaar p)

Methods

bazaar :: Applicative f => p a (f b) -> Bazaar p a b t -> f t

Profunctor p => Bizarre p (BazaarT p g)

Methods

bazaar :: Applicative f => p a (f b) -> BazaarT p g a b t -> f t

Corepresentable p => Bizarre p (TakingWhile p g)

Methods

bazaar :: Applicative f => p a (f b) -> TakingWhile p g a b t -> f t

Bizarre (Indexed Int) Mafic

Methods

bazaar :: Applicative f => Indexed Int a (f b) -> Mafic a b t -> f t

Bizarre (Indexed i) (Molten i)

Methods

bazaar :: Applicative f => Indexed i a (f b) -> Molten i a b t -> f t

newtype Bazaar p a b 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 Context a b t holds an a and a function from b to t, a Bazaar a b t holds N 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

• runBazaar :: forall f. Applicative f => p a (f b) -> f t

Instances

Corepresentable p => Sellable p (Bazaar p)

Methods

sell :: p a (Bazaar p a b b)

Profunctor p => Bizarre p (Bazaar p)

Methods

bazaar :: Applicative f => p a (f b) -> Bazaar p a b t -> f t

Conjoined p => IndexedComonad (Bazaar p)

Methods

iextract :: Bazaar p a a t -> t

iduplicate :: Bazaar p a c t -> Bazaar p a b (Bazaar p b c t)

iextend :: (Bazaar p b c t -> r) -> Bazaar p a c t -> Bazaar p a b r

IndexedFunctor (Bazaar p)

Methods

ifmap :: (s -> t) -> Bazaar p a b s -> Bazaar p a b t

Functor (Bazaar p a b)

Methods

fmap :: (c -> d) -> Bazaar p a b c -> Bazaar p a b d

(<$) :: c -> Bazaar p a b d -> Bazaar p a b c

Applicative (Bazaar p a b)

Methods

pure :: c -> Bazaar p a b c

(<*>) :: Bazaar p a b (c -> d) -> Bazaar p a b c -> Bazaar p a b d

(*>) :: Bazaar p a b c -> Bazaar p a b d -> Bazaar p a b d

(<*) :: Bazaar p a b c -> Bazaar p a b d -> Bazaar p a b c

((~) * a b, Conjoined p) => Comonad (Bazaar p a b)

Methods

extract :: Bazaar p a b c -> c

duplicate :: Bazaar p a b c -> Bazaar p a b (Bazaar p a b c)

extend :: (Bazaar p a b c -> d) -> Bazaar p a b c -> Bazaar p a b d

((~) * a b, Conjoined p) => ComonadApply (Bazaar p a b)

Methods

(<@>) :: Bazaar p a b (c -> d) -> Bazaar p a b c -> Bazaar p a b d

(@>) :: Bazaar p a b c -> Bazaar p a b d -> Bazaar p a b d

(<@) :: Bazaar p a b c -> Bazaar p a b d -> Bazaar p a b c

Apply (Bazaar p a b)

Methods

(<.>) :: Bazaar p a b (c -> d) -> Bazaar p a b c -> Bazaar p a b d

(.>) :: Bazaar p a b c -> Bazaar p a b d -> Bazaar p a b d

(<.) :: Bazaar p a b c -> Bazaar p a b d -> Bazaar p a b c

type Bazaar' p a = Bazaar p a a

This alias is helpful when it comes to reducing repetition in type signatures.

type Bazaar' p a t = Bazaar p a a t

newtype BazaarT p g a b t

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

• runBazaarT :: forall f. Applicative f => p a (f b) -> f t

Instances

Corepresentable p => Sellable p (BazaarT p g)

Methods

sell :: p a (BazaarT p g a b b)

Profunctor p => Bizarre p (BazaarT p g)

Methods

bazaar :: Applicative f => p a (f b) -> BazaarT p g a b t -> f t

Conjoined p => IndexedComonad (BazaarT p g)

Methods

iextract :: BazaarT p g a a t -> t

iduplicate :: BazaarT p g a c t -> BazaarT p g a b (BazaarT p g b c t)

iextend :: (BazaarT p g b c t -> r) -> BazaarT p g a c t -> BazaarT p g a b r

IndexedFunctor (BazaarT p g)

Methods

ifmap :: (s -> t) -> BazaarT p g a b s -> BazaarT p g a b t

Functor (BazaarT p g a b)

Methods

fmap :: (c -> d) -> BazaarT p g a b c -> BazaarT p g a b d

(<$) :: c -> BazaarT p g a b d -> BazaarT p g a b c

Applicative (BazaarT p g a b)

Methods

pure :: c -> BazaarT p g a b c

(<*>) :: BazaarT p g a b (c -> d) -> BazaarT p g a b c -> BazaarT p g a b d

(*>) :: BazaarT p g a b c -> BazaarT p g a b d -> BazaarT p g a b d

(<*) :: BazaarT p g a b c -> BazaarT p g a b d -> BazaarT p g a b c

(Profunctor p, Contravariant g) => Contravariant (BazaarT p g a b)

Methods

contramap :: (c -> d) -> BazaarT p g a b d -> BazaarT p g a b c

(>$) :: c -> BazaarT p g a b c -> BazaarT p g a b d

((~) * a b, Conjoined p) => Comonad (BazaarT p g a b)

Methods

extract :: BazaarT p g a b c -> c

duplicate :: BazaarT p g a b c -> BazaarT p g a b (BazaarT p g a b c)

extend :: (BazaarT p g a b c -> d) -> BazaarT p g a b c -> BazaarT p g a b d

((~) * a b, Conjoined p) => ComonadApply (BazaarT p g a b)

Methods

(<@>) :: BazaarT p g a b (c -> d) -> BazaarT p g a b c -> BazaarT p g a b d

(@>) :: BazaarT p g a b c -> BazaarT p g a b d -> BazaarT p g a b d

(<@) :: BazaarT p g a b c -> BazaarT p g a b d -> BazaarT p g a b c

Apply (BazaarT p g a b)

Methods

(<.>) :: BazaarT p g a b (c -> d) -> BazaarT p g a b c -> BazaarT p g a b d

(.>) :: BazaarT p g a b c -> BazaarT p g a b d -> BazaarT p g a b d

(<.) :: BazaarT p g a b c -> BazaarT p g a b d -> BazaarT p g a b c

Contravariant g => Monoid (BazaarT p g a b t)

Methods

mempty :: BazaarT p g a b t

mappend :: BazaarT p g a b t -> BazaarT p g a b t -> BazaarT p g a b t

mconcat :: [BazaarT p g a b t] -> BazaarT p g a b t

Contravariant g => Semigroup (BazaarT p g a b t)

Methods

(<>) :: BazaarT p g a b t -> BazaarT p g a b t -> BazaarT p g a b t

sconcat :: NonEmpty (BazaarT p g a b t) -> BazaarT p g a b t

times1p :: Natural -> BazaarT p g a b t -> BazaarT p g a b t

type BazaarT' p g a = BazaarT p g a a

This alias is helpful when it comes to reducing repetition in type signatures.

type BazaarT' p g a t = BazaarT p g a a t

class Profunctor p => Bizarre1 p w | w -> p where

Methods

bazaar1 :: Apply f => p a (f b) -> w a b t -> f t

Instances

Profunctor p => Bizarre1 p (Bazaar1 p)

Methods

bazaar1 :: Apply f => p a (f b) -> Bazaar1 p a b t -> f t

Profunctor p => Bizarre1 p (BazaarT1 p g)

Methods

bazaar1 :: Apply f => p a (f b) -> BazaarT1 p g a b t -> f t

newtype Bazaar1 p a b 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 Bazaar1 is like a Traversal that has already been applied to some structure.

Where a Context a b t holds an a and a function from b to t, a Bazaar1 a b t holds N 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

• runBazaar1 :: forall f. Apply f => p a (f b) -> f t

Instances

Corepresentable p => Sellable p (Bazaar1 p)

Methods

sell :: p a (Bazaar1 p a b b)

Profunctor p => Bizarre1 p (Bazaar1 p)

Methods

bazaar1 :: Apply f => p a (f b) -> Bazaar1 p a b t -> f t

Conjoined p => IndexedComonad (Bazaar1 p)

Methods

iextract :: Bazaar1 p a a t -> t

iduplicate :: Bazaar1 p a c t -> Bazaar1 p a b (Bazaar1 p b c t)

iextend :: (Bazaar1 p b c t -> r) -> Bazaar1 p a c t -> Bazaar1 p a b r

IndexedFunctor (Bazaar1 p)

Methods

ifmap :: (s -> t) -> Bazaar1 p a b s -> Bazaar1 p a b t

Functor (Bazaar1 p a b)

Methods

fmap :: (c -> d) -> Bazaar1 p a b c -> Bazaar1 p a b d

(<$) :: c -> Bazaar1 p a b d -> Bazaar1 p a b c

((~) * a b, Conjoined p) => Comonad (Bazaar1 p a b)

Methods

extract :: Bazaar1 p a b c -> c

duplicate :: Bazaar1 p a b c -> Bazaar1 p a b (Bazaar1 p a b c)

extend :: (Bazaar1 p a b c -> d) -> Bazaar1 p a b c -> Bazaar1 p a b d

((~) * a b, Conjoined p) => ComonadApply (Bazaar1 p a b)

Methods

(<@>) :: Bazaar1 p a b (c -> d) -> Bazaar1 p a b c -> Bazaar1 p a b d

(@>) :: Bazaar1 p a b c -> Bazaar1 p a b d -> Bazaar1 p a b d

(<@) :: Bazaar1 p a b c -> Bazaar1 p a b d -> Bazaar1 p a b c

Apply (Bazaar1 p a b)

Methods

(<.>) :: Bazaar1 p a b (c -> d) -> Bazaar1 p a b c -> Bazaar1 p a b d

(.>) :: Bazaar1 p a b c -> Bazaar1 p a b d -> Bazaar1 p a b d

(<.) :: Bazaar1 p a b c -> Bazaar1 p a b d -> Bazaar1 p a b c

type Bazaar1' p a = Bazaar1 p a a

This alias is helpful when it comes to reducing repetition in type signatures.

type Bazaar1' p a t = Bazaar1 p a a t

newtype BazaarT1 p g a b t

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

• runBazaarT1 :: forall f. Apply f => p a (f b) -> f t

Instances

Corepresentable p => Sellable p (BazaarT1 p g)

Methods

sell :: p a (BazaarT1 p g a b b)

Profunctor p => Bizarre1 p (BazaarT1 p g)

Methods

bazaar1 :: Apply f => p a (f b) -> BazaarT1 p g a b t -> f t

Conjoined p => IndexedComonad (BazaarT1 p g)

Methods

iextract :: BazaarT1 p g a a t -> t

iduplicate :: BazaarT1 p g a c t -> BazaarT1 p g a b (BazaarT1 p g b c t)

iextend :: (BazaarT1 p g b c t -> r) -> BazaarT1 p g a c t -> BazaarT1 p g a b r

IndexedFunctor (BazaarT1 p g)

Methods

ifmap :: (s -> t) -> BazaarT1 p g a b s -> BazaarT1 p g a b t

Functor (BazaarT1 p g a b)

Methods

fmap :: (c -> d) -> BazaarT1 p g a b c -> BazaarT1 p g a b d

(<$) :: c -> BazaarT1 p g a b d -> BazaarT1 p g a b c

(Profunctor p, Contravariant g) => Contravariant (BazaarT1 p g a b)

Methods

contramap :: (c -> d) -> BazaarT1 p g a b d -> BazaarT1 p g a b c

(>$) :: c -> BazaarT1 p g a b c -> BazaarT1 p g a b d

((~) * a b, Conjoined p) => Comonad (BazaarT1 p g a b)

Methods

extract :: BazaarT1 p g a b c -> c

duplicate :: BazaarT1 p g a b c -> BazaarT1 p g a b (BazaarT1 p g a b c)

extend :: (BazaarT1 p g a b c -> d) -> BazaarT1 p g a b c -> BazaarT1 p g a b d

((~) * a b, Conjoined p) => ComonadApply (BazaarT1 p g a b)

Methods

(<@>) :: BazaarT1 p g a b (c -> d) -> BazaarT1 p g a b c -> BazaarT1 p g a b d

(@>) :: BazaarT1 p g a b c -> BazaarT1 p g a b d -> BazaarT1 p g a b d

(<@) :: BazaarT1 p g a b c -> BazaarT1 p g a b d -> BazaarT1 p g a b c

Apply (BazaarT1 p g a b)

Methods

(<.>) :: BazaarT1 p g a b (c -> d) -> BazaarT1 p g a b c -> BazaarT1 p g a b d

(.>) :: BazaarT1 p g a b c -> BazaarT1 p g a b d -> BazaarT1 p g a b d

(<.) :: BazaarT1 p g a b c -> BazaarT1 p g a b d -> BazaarT1 p g a b c

Contravariant g => Semigroup (BazaarT1 p g a b t)

Methods

(<>) :: BazaarT1 p g a b t -> BazaarT1 p g a b t -> BazaarT1 p g a b t

sconcat :: NonEmpty (BazaarT1 p g a b t) -> BazaarT1 p g a b t

times1p :: Natural -> BazaarT1 p g a b t -> BazaarT1 p g a b t

type BazaarT1' p g a = BazaarT1 p g a a

This alias is helpful when it comes to reducing repetition in type signatures.

type BazaarT1' p g a t = BazaarT1 p g a a t