Data.Functor.Contravariant.Divisible.Free

Provides free structures for the various typeclasses of the Divisible hierarchy.

Since: 0.3.0.0

Documentation

data Div :: (Type -> Type) -> Type -> Type where

The free Divisible. Used to sequence multiple contravariant consumers, splitting out the input across all consumers.

Note that Div f is essentially ListF (Coyoneda f), or just ListF f in the case that f is already contravariant. However, this is left in here because it can be more convenient to use if you are working with an intermediate f that isn't Contravariant.

Constructors

Conquer :: Div f a

Divide :: (a -> (b, c)) -> f b -> Div f c -> Div f a

Instances

Inject Div

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

inject :: f ~> Div f

FreeOf Divisible Div

Since: 0.3.0.0

Defined in Data.HFunctor.Final

Associated Types

type FreeFunctorBy Div :: (Type -> Type) -> Constraint

Methods

fromFree :: Div f ~> Final Divisible f

toFree :: FreeFunctorBy Div f => Final Divisible f ~> Div f

HFunctor Div

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

hmap :: (f ~> g) -> Div f ~> Div g

Divisible f => Interpret Div (f :: Type -> Type)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

retract :: Div f ~> f

interpret :: (g ~> f) -> Div g ~> f

Contravariant (Div f)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

contramap :: (a -> b) -> Div f b -> Div f a

(>$) :: b -> Div f b -> Div f a

Divisible (Div f)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

divide :: (a -> (b, c)) -> Div f b -> Div f c -> Div f a

conquer :: Div f a

Invariant (Div f)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

invmap :: (a -> b) -> (b -> a) -> Div f a -> Div f b

Divise (Div f)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

divise :: (a -> (b, c)) -> Div f b -> Div f c -> Div f a

type FreeFunctorBy Div

Defined in Data.HFunctor.Final

type FreeFunctorBy Div = (Unconstrained :: (Type -> Type) -> Constraint)

hoistDiv :: forall f g. (f ~> g) -> Div f ~> Div g

Map over the undering context in a Div.

liftDiv :: f ~> Div f

Inject a single action in f into a Div f.

runDiv :: forall f g. Divisible g => (f ~> g) -> Div f ~> g

Interpret a Div into a context g, provided g is Divisible.

divListF :: forall f. Contravariant f => Div f ~> ListF f

Div is isomorphic to ListF for contravariant f. This witnesses one way of that isomorphism.

Be aware that this is essentially O(n^2).

listFDiv :: ListF f ~> Div f

Div is isomorphic to ListF for contravariant f. This witnesses one way of that isomorphism.

This direction is O(n), unlike divListF.

data Div1 :: (Type -> Type) -> Type -> Type where

The free Divise: a non-empty version of Div.

Note that Div1 f is essentially NonEmptyF (Coyoneda f), or just NonEmptyF f in the case that f is already contravariant. However, it can be more convenient to use if you are working with an intermediate f that isn't Contravariant.

Constructors

Div1 :: (a -> (b, c)) -> f b -> Div f c -> Div1 f a

Instances

Inject Div1

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

inject :: f ~> Div1 f

FreeOf Divise Div1

Since: 0.3.0.0

Defined in Data.HFunctor.Final

Associated Types

type FreeFunctorBy Div1 :: (Type -> Type) -> Constraint

Methods

fromFree :: Div1 f ~> Final Divise f

toFree :: FreeFunctorBy Div1 f => Final Divise f ~> Div1 f

HFunctor Div1

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

hmap :: (f ~> g) -> Div1 f ~> Div1 g

Divise f => Interpret Div1 (f :: Type -> Type)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

retract :: Div1 f ~> f

interpret :: (g ~> f) -> Div1 g ~> f

Contravariant (Div1 f)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

contramap :: (a -> b) -> Div1 f b -> Div1 f a

(>$) :: b -> Div1 f b -> Div1 f a

Invariant (Div1 f)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

invmap :: (a -> b) -> (b -> a) -> Div1 f a -> Div1 f b

Divise (Div1 f)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

divise :: (a -> (b, c)) -> Div1 f b -> Div1 f c -> Div1 f a

type FreeFunctorBy Div1

Defined in Data.HFunctor.Final

type FreeFunctorBy Div1 = (Unconstrained :: (Type -> Type) -> Constraint)

hoistDiv1 :: (f ~> g) -> Div1 f ~> Div1 g

Map over the undering context in a Div1.

liftDiv1 :: f ~> Div1 f

Inject a single action in f into a Div f.

toDiv :: Div1 f a -> Div f a

A Div1 is a "non-empty" Div; this function "forgets" the non-empty property and turns it back into a normal Div.

runDiv1 :: Divise g => (f ~> g) -> Div1 f ~> g

Interpret a Div1 into a context g, provided g is Divise.

div1NonEmptyF :: Contravariant f => Div1 f ~> NonEmptyF f

Div1 is isomorphic to NonEmptyF for contravariant f. This witnesses one way of that isomorphism.

Be aware that this is essentially O(n^2).

nonEmptyFDiv1 :: NonEmptyF f ~> Div1 f

Div1 is isomorphic to NonEmptyF for contravariant f. This witnesses one way of that isomorphism.

This direction is O(n), unlike div1NonEmptyF.

data Dec :: (Type -> Type) -> Type -> Type where

The free Decide. Used to aggregate multiple possible consumers, directing the input into an appropriate consumer.

Constructors

Lose :: (a -> Void) -> Dec f a

Choose :: (a -> Either b c) -> f b -> Dec f c -> Dec f a

Instances

Inject Dec

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

inject :: f ~> Dec f

FreeOf Conclude Dec

Since: 0.3.0.0

Defined in Data.HFunctor.Final

Associated Types

type FreeFunctorBy Dec :: (Type -> Type) -> Constraint

Methods

fromFree :: Dec f ~> Final Conclude f

toFree :: FreeFunctorBy Dec f => Final Conclude f ~> Dec f

HFunctor Dec

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

hmap :: (f ~> g) -> Dec f ~> Dec g

Conclude f => Interpret Dec (f :: Type -> Type)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

retract :: Dec f ~> f

interpret :: (g ~> f) -> Dec g ~> f

Contravariant (Dec f)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

contramap :: (a -> b) -> Dec f b -> Dec f a

(>$) :: b -> Dec f b -> Dec f a

Invariant (Dec f)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

invmap :: (a -> b) -> (b -> a) -> Dec f a -> Dec f b

Decide (Dec f)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

decide :: (a -> Either b c) -> Dec f b -> Dec f c -> Dec f a

Conclude (Dec f)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

conclude :: (a -> Void) -> Dec f a

type FreeFunctorBy Dec

Defined in Data.HFunctor.Final

type FreeFunctorBy Dec = (Unconstrained :: (Type -> Type) -> Constraint)

hoistDec :: forall f g. (f ~> g) -> Dec f ~> Dec g

Map over the undering context in a Dec.

liftDec :: f ~> Dec f

Inject a single action in f into a Dec f.

runDec :: forall f g. Conclude g => (f ~> g) -> Dec f ~> g

Interpret a Dec into a context g, provided g is Conclude.

data Dec1 :: (Type -> Type) -> Type -> Type where

The free Decide: a non-empty version of Dec.

Constructors

Dec1 :: (a -> Either b c) -> f b -> Dec f c -> Dec1 f a

Instances

Inject Dec1

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

inject :: f ~> Dec1 f

FreeOf Decide Dec1

Since: 0.3.0.0

Defined in Data.HFunctor.Final

Associated Types

type FreeFunctorBy Dec1 :: (Type -> Type) -> Constraint

Methods

fromFree :: Dec1 f ~> Final Decide f

toFree :: FreeFunctorBy Dec1 f => Final Decide f ~> Dec1 f

HFunctor Dec1

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

hmap :: (f ~> g) -> Dec1 f ~> Dec1 g

Decide f => Interpret Dec1 (f :: Type -> Type)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

retract :: Dec1 f ~> f

interpret :: (g ~> f) -> Dec1 g ~> f

Contravariant (Dec1 f)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

contramap :: (a -> b) -> Dec1 f b -> Dec1 f a

(>$) :: b -> Dec1 f b -> Dec1 f a

Invariant (Dec1 f)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

invmap :: (a -> b) -> (b -> a) -> Dec1 f a -> Dec1 f b

Decide (Dec1 f)

Defined in Data.Functor.Contravariant.Divisible.Free

Methods

decide :: (a -> Either b c) -> Dec1 f b -> Dec1 f c -> Dec1 f a

type FreeFunctorBy Dec1

Defined in Data.HFunctor.Final

type FreeFunctorBy Dec1 = (Unconstrained :: (Type -> Type) -> Constraint)

hoistDec1 :: forall f g. (f ~> g) -> Dec1 f ~> Dec1 g

Map over the undering context in a Dec1.

liftDec1 :: f ~> Dec1 f

Inject a single action in f into a Dec1 f.

toDec :: Dec1 f a -> Dec f a

A Dec1 is a "non-empty" Dec; this function "forgets" the non-empty property and turns it back into a normal Dec.

runDec1 :: Decide g => (f ~> g) -> Dec1 f ~> g

Interpret a Dec1 into a context g, provided g is Decide.