Safe Haskell	None
Language	GHC2024

Proarrow.Promonad.Cont

Description

The continuation promonad: Cont r a b is a continuation transformer (b ~> r) -> (a ~> r). It is strong for the tensor but only premonoidal, as the order of effects matters.

Synopsis

data Cont (r :: k) (a :: k) (b :: k) where
- Cont :: forall {k} (a :: k) (b :: k) (r :: k). (Ob a, Ob b) => {..} -> Cont r a b

Documentation

data Cont (r :: k) (a :: k) (b :: k) where Source Github #

An arrow from a to b is a mapping of continuations (b ~> r) -> (a ~> r).

Constructors

Cont
Fields :: forall {k} (a :: k) (b :: k) (r :: k). (Ob a, Ob b) => { runCont :: (b ~> r) -> a ~> r } -> Cont r a b

Instances

Instances details

Strong (Tensor :: Type -> (Type, Type) -> Type) (Cont r :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Cont Methods act :: Ob a => Cont r x y -> Cont r (Act (Tensor :: Type -> (Type, Type) -> Type) a x) (Act (Tensor :: Type -> (Type, Type) -> Type) a y) Source Github #
MonoidalProfunctor (Cont r :: Type -> Type -> Type) Source Github #	Only premonoidal not monoidal.
Instance details Defined in Proarrow.Promonad.Cont Methods one :: Cont r (Unit :: Type) (Unit :: Type) Source Github # () :: Cont r x1 x2 -> Cont r y1 y2 -> Cont r (x1 y1) (x2 ** y2) Source Github #
CategoryOf k => Profunctor (Cont r :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Cont Methods dimap :: forall (c :: k) (a :: k) (b :: k) (d :: k). (c ~> a) -> (b ~> d) -> Cont r a b -> Cont r c d Source Github # lmap :: forall (c :: k) (a :: k) (b :: k). (c ~> a) -> Cont r a b -> Cont r c b Source Github # rmap :: forall (b :: k) (d :: k) (a :: k). (b ~> d) -> Cont r a b -> Cont r a d Source Github # (\\) :: forall (a :: k) (b :: k) r0. ((Ob a, Ob b) => r0) -> Cont r a b -> r0 Source Github #
Representable (Cont r :: Type -> Type -> Type) Source Github #	At `Type` the continuation promonad is the continuation monad: `(b -> r) -> (a -> r)` is `a -> (b -> r) -> r` by flipping the arguments, so `Cont r % b` is the double-negation `(b -> r) -> r`. This gives `KLEISLI (Cont r)` its initial object and coproducts, which hold for the Kleisli category of a monad but not of an arbitrary promonad.
Instance details Defined in Proarrow.Promonad.Cont Methods index :: Cont r a b -> a ~> (Cont r % b) Source Github # tabulate :: Ob b => (a ~> (Cont r % b)) -> Cont r a b Source Github # repMap :: (a ~> b) -> (Cont r % a) ~> (Cont r % b) Source Github # repUniv :: Ob a => Cont r (Cont r % a) a Source Github #
CategoryOf k => Promonad (Cont r :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Cont Methods id :: forall (a :: k). Ob a => Cont r a a Source Github # (.) :: forall (b :: k) (c :: k) (a :: k). Cont r b c -> Cont r a b -> Cont r a c Source Github #
HasCoproducts k => MonoidalProfunctor (Coprod (Cont r) :: COPROD k -> COPROD k -> Type) Source Github #
Instance details Defined in Proarrow.Promonad.Cont Methods one :: Coprod (Cont r) (Unit :: COPROD k) (Unit :: COPROD k) Source Github # () :: forall (x1 :: COPROD k) (x2 :: COPROD k) (y1 :: COPROD k) (y2 :: COPROD k). Coprod (Cont r) x1 x2 -> Coprod (Cont r) y1 y2 -> Coprod (Cont r) (x1 y1) (x2 ** y2) Source Github #
Closed (KLEISLI (Cont r)) Source Github #
Instance details Defined in Proarrow.Promonad.Cont Methods withObExp :: forall (a :: KLEISLI (Cont r)) (b :: KLEISLI (Cont r)) r0. (Ob a, Ob b) => (Ob (a ~~> b) => r0) -> r0 Source Github # curry :: forall (a :: KLEISLI (Cont r)) (b :: KLEISLI (Cont r)) (c :: KLEISLI (Cont r)). (Ob a, Ob b) => ((a b) ~> c) -> a ~> (b ~~> c) Source Github # apply :: forall (a :: KLEISLI (Cont r)) (b :: KLEISLI (Cont r)). (Ob a, Ob b) => ((a ~~> b) a) ~> b Source Github # (^^^) :: forall (a :: KLEISLI (Cont r)) (b :: KLEISLI (Cont r)) (x :: KLEISLI (Cont r)) (y :: KLEISLI (Cont r)). (b ~> y) -> (x ~> a) -> (a ~~> b) ~> (x ~~> y) Source Github #
StarAutonomous (KLEISLI (Cont r)) Source Github #
Instance details Defined in Proarrow.Promonad.Cont Methods withObDual :: forall (a :: KLEISLI (Cont r)) r0. Ob a => (Ob (Dual a) => r0) -> r0 Source Github # dual :: forall (a :: KLEISLI (Cont r)) (b :: KLEISLI (Cont r)). (a ~> b) -> Dual b ~> Dual a Source Github # dualInv :: forall (a :: KLEISLI (Cont r)) (b :: KLEISLI (Cont r)). (Ob a, Ob b) => (Dual a ~> Dual b) -> b ~> a Source Github # linDist :: forall (a :: KLEISLI (Cont r)) (b :: KLEISLI (Cont r)) (c :: KLEISLI (Cont r)). (Ob a, Ob b, Ob c) => ((a b) ~> Dual c) -> a ~> Dual (b c) Source Github # linDistInv :: forall (a :: KLEISLI (Cont r)) (b :: KLEISLI (Cont r)) (c :: KLEISLI (Cont r)). (Ob a, Ob b, Ob c) => (a ~> Dual (b c)) -> (a b) ~> Dual c Source Github # doubleNeg :: forall (a :: KLEISLI (Cont r)). Ob a => Dual (Dual a) ~> a Source Github # doubleNegInv :: forall (a :: KLEISLI (Cont r)). Ob a => a ~> Dual (Dual a) Source Github #
type (Cont r :: Type -> Type -> Type) % (b :: Type) Source Github #
Instance details Defined in Proarrow.Promonad.Cont type (Cont r :: Type -> Type -> Type) % (b :: Type) = (b -> r) -> r
type (a :: KLEISLI (Cont r)) ~~> (b :: KLEISLI (Cont r)) Source Github #
Instance details Defined in Proarrow.Promonad.Cont type (a :: KLEISLI (Cont r)) ~~> (b :: KLEISLI (Cont r)) = ExpSA a b
type Dual ('KL a :: KLEISLI (Cont r)) Source Github #
Instance details Defined in Proarrow.Promonad.Cont type Dual ('KL a :: KLEISLI (Cont r)) = 'KL (a ~~> r) :: KLEISLI (Cont r)