Safe Haskell	None
Language	GHC2024

Proarrow.Category.Instance.Nat

Contents

Orphan instances

Documentation

data Nat (f :: j -> k) (g :: j -> k) where Source Github #

Constructors

Nat
Fields :: forall {j} {k} (f :: j -> k) (g :: j -> k). (Functor f, Functor g) => { unNat :: f .~> g } -> Nat f g

Instances

Instances details

Promonad (Nat :: (j -> Type) -> (j -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods id :: forall (a :: j -> Type). Ob a => Nat a a Source Github # (.) :: forall (b :: j -> Type) (c :: j -> Type) (a :: j -> Type). Nat b c -> Nat a b -> Nat a c Source Github #
Promonad (Nat :: (k1 -> k2 -> k3 -> k4 -> Type) -> (k1 -> k2 -> k3 -> k4 -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods id :: forall (a :: k1 -> k2 -> k3 -> k4 -> Type). Ob a => Nat a a Source Github # (.) :: forall (b :: k1 -> k2 -> k3 -> k4 -> Type) (c :: k1 -> k2 -> k3 -> k4 -> Type) (a :: k1 -> k2 -> k3 -> k4 -> Type). Nat b c -> Nat a b -> Nat a c Source Github #
Promonad (Nat :: (k1 -> k2 -> k3 -> Type) -> (k1 -> k2 -> k3 -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods id :: forall (a :: k1 -> k2 -> k3 -> Type). Ob a => Nat a a Source Github # (.) :: forall (b :: k1 -> k2 -> k3 -> Type) (c :: k1 -> k2 -> k3 -> Type) (a :: k1 -> k2 -> k3 -> Type). Nat b c -> Nat a b -> Nat a c Source Github #
MonoidalProfunctor (Nat :: (Type -> Type) -> (Type -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods par0 :: Nat (Unit :: Type -> Type) (Unit :: Type -> Type) Source Github # par :: forall (x1 :: Type -> Type) (x2 :: Type -> Type) (y1 :: Type -> Type) (y2 :: Type -> Type). Nat x1 x2 -> Nat y1 y2 -> Nat (x1 y1) (x2 y2) Source Github #
Profunctor (Nat :: (k1 -> k2 -> k3 -> k4 -> Type) -> (k1 -> k2 -> k3 -> k4 -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods dimap :: forall (c :: k1 -> k2 -> k3 -> k4 -> Type) (a :: k1 -> k2 -> k3 -> k4 -> Type) (b :: k1 -> k2 -> k3 -> k4 -> Type) (d :: k1 -> k2 -> k3 -> k4 -> Type). (c ~> a) -> (b ~> d) -> Nat a b -> Nat c d Source Github # (\\) :: forall (a :: k1 -> k2 -> k3 -> k4 -> Type) (b :: k1 -> k2 -> k3 -> k4 -> Type) r. ((Ob a, Ob b) => r) -> Nat a b -> r Source Github #
Profunctor (Nat :: (k1 -> k2 -> k3 -> Type) -> (k1 -> k2 -> k3 -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods dimap :: forall (c :: k1 -> k2 -> k3 -> Type) (a :: k1 -> k2 -> k3 -> Type) (b :: k1 -> k2 -> k3 -> Type) (d :: k1 -> k2 -> k3 -> Type). (c ~> a) -> (b ~> d) -> Nat a b -> Nat c d Source Github # (\\) :: forall (a :: k1 -> k2 -> k3 -> Type) (b :: k1 -> k2 -> k3 -> Type) r. ((Ob a, Ob b) => r) -> Nat a b -> r Source Github #
Profunctor (Nat :: (k1 -> Type) -> (k1 -> Type) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods dimap :: forall (c :: k1 -> Type) (a :: k1 -> Type) (b :: k1 -> Type) (d :: k1 -> Type). (c ~> a) -> (b ~> d) -> Nat a b -> Nat c d Source Github # (\\) :: forall (a :: k1 -> Type) (b :: k1 -> Type) r. ((Ob a, Ob b) => r) -> Nat a b -> r Source Github #

(!) :: forall {j} {k} (f :: j -> k) (g :: j -> k) (a :: j) (b :: j). Nat f g -> (a ~> b) -> f a ~> g b Source Github #

data ((f :: k -> Type) :~>: (g :: k -> Type)) (a :: k) where Source Github #

Constructors

Exp :: forall {k} (a :: k) (f :: k -> Type) (g :: k -> Type). Ob a => (forall (b :: k). (a ~> b) -> f b -> g b) -> (f :~>: g) a

Instances

Instances details

(Functor f, Functor g) => Functor (f :~>: g :: k1 -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods map :: forall (a :: k1) (b :: k1). (a ~> b) -> (f :~>: g) a ~> (f :~>: g) b Source Github #

newtype Ran (j1 :: j -> k) (h :: j -> Type) (a :: k) Source Github #

Constructors

Ran
Fields runRan :: forall (b :: j). (a ~> j1 b) -> h b

Instances

Instances details

CategoryOf k => Functor (Ran j2 h :: k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods map :: forall (a :: k) (b :: k). (a ~> b) -> Ran j2 h a ~> Ran j2 h b Source Github #

data Lan (j1 :: j -> k) (f :: j -> Type) (a :: k) where Source Github #

Constructors

Lan :: forall {j} {k} (j1 :: j -> k) (b :: j) (a :: k) (f :: j -> Type). (j1 b ~> a) -> f b -> Lan j1 f a

Instances

Instances details

CategoryOf k => Functor (Lan j2 f :: k -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods map :: forall (a :: k) (b :: k). (a ~> b) -> Lan j2 f a ~> Lan j2 f b Source Github #

data ((f :: k -> Type) :^: n) (a :: k) where Source Github #

Constructors

Power
Fields :: forall {k} (a :: k) n (f :: k -> Type). Ob a => { unPower :: n -> f a } -> (f :^: n) a

Instances

Instances details

Functor f => Functor (f :^: n :: k1 -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods map :: forall (a :: k1) (b :: k1). (a ~> b) -> (f :^: n) a ~> (f :^: n) b Source Github #

data (n :*.: (f :: k -> Type)) (a :: k) where Source Github #

Constructors

Copower
Fields :: forall {k} (a :: k) n (f :: k -> Type). Ob a => { unCopower :: (n, f a) } -> (n :*.: f) a

Instances

Instances details

Functor f => Functor (n :*.: f :: k1 -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods map :: forall (a :: k1) (b :: k1). (a ~> b) -> (n :.: f) a ~> (n :.: f) b Source Github #

data CatAsComonoid k a where Source Github #

Constructors

CatAsComonoid :: forall {k} (c :: k) a. Ob c => (forall (c' :: k). (c ~> c') -> a) -> CatAsComonoid k a

Instances

Instances details

Functor (CatAsComonoid k :: Type -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods map :: (a ~> b) -> CatAsComonoid k a ~> CatAsComonoid k b Source Github #
CategoryOf k => Comonoid (CatAsComonoid k :: Type -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods counit :: CatAsComonoid k ~> (Unit :: Type -> Type) Source Github # comult :: CatAsComonoid k ~> (CatAsComonoid k ** CatAsComonoid k) Source Github #

data ComonoidAsCat (w :: Type -> Type) a b where Source Github #

Constructors

ComonoidAsCat :: forall (w :: Type -> Type) a b. (w a -> b) -> ComonoidAsCat w a b

Instances

Instances details

Functor w => Profunctor (ComonoidAsCat w :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods dimap :: (c ~> a) -> (b ~> d) -> ComonoidAsCat w a b -> ComonoidAsCat w c d Source Github # (\\) :: ((Ob a, Ob b) => r) -> ComonoidAsCat w a b -> r Source Github #
Comonoid w => Promonad (ComonoidAsCat w :: Type -> Type -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods id :: Ob a => ComonoidAsCat w a a Source Github # (.) :: ComonoidAsCat w b c -> ComonoidAsCat w a b -> ComonoidAsCat w a c Source Github #

newtype j .-> k Source Github #

Constructors

NT (j -> k)

Instances

Instances details

(Functor f, Discrete j, Thin k) => ThinProfunctor (Costar f :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Costar

Methods

arr :: forall (a :: k) (b :: j). (Ob a, Ob b, HasArrow (Costar f) a b) => Costar f a b Source Github #

withArr :: forall (a :: k) (b :: j) r. Costar f a b -> (HasArrow (Costar f) a b => r) -> r Source Github #

(Cartesian j, Cartesian k, Functor f) => MonoidalProfunctor (Costar f :: j -> k -> Type) Source Github #

Every functor between cartesian categories is a colax monoidal functor.

Instance details

Defined in Proarrow.Profunctor.Costar

Methods

par0 :: Costar f (Unit :: j) (Unit :: k) Source Github #

par :: forall (x1 :: j) (x2 :: k) (y1 :: j) (y2 :: k). Costar f x1 x2 -> Costar f y1 y2 -> Costar f (x1 ** y1) (x2 ** y2) Source Github #

Functor f => Profunctor (Costar f :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Costar

Methods

dimap :: forall (c :: k) (a :: k) (b :: j) (d :: j). (c ~> a) -> (b ~> d) -> Costar f a b -> Costar f c d Source Github #

(\\) :: forall (a :: k) (b :: j) r. ((Ob a, Ob b) => r) -> Costar f a b -> r Source Github #

Functor f => Corepresentable (Costar f :: k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Costar

Methods

coindex :: forall (a :: k) (b :: j). Costar f a b -> (Costar f %% a) ~> b Source Github #

cotabulate :: forall (a :: k) (b :: j). Ob a => ((Costar f %% a) ~> b) -> Costar f a b Source Github #

corepMap :: forall (a :: k) (b :: k). (a ~> b) -> (Costar f %% a) ~> (Costar f %% b) Source Github #

Representable (Costar ((,) a) :: Type -> Type -> Type) Source Github #

The right adjoint of (,) a is ((->) a).

Instance details

Defined in Proarrow.Adjunction

Methods

index :: Costar ((,) a) a0 b -> a0 ~> (Costar ((,) a) % b) Source Github #

tabulate :: Ob b => (a0 ~> (Costar ((,) a) % b)) -> Costar ((,) a) a0 b Source Github #

repMap :: (a0 ~> b) -> (Costar ((,) a) % a0) ~> (Costar ((,) a) % b) Source Github #

Functor f => Proadjunction (Star f :: k -> j -> Type) (Costar f :: j -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Adjunction

Methods

unit :: forall (a :: j). Ob a => (Costar f :.: Star f) a a Source Github #

counit :: (Star f :.: Costar f) :~> ((~>) :: CAT k) Source Github #

(Functor t, Traversable (Star t)) => Cotraversable (Costar t :: k -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Costar

Methods

cotraverse :: forall (p :: k +-> k). (DistributiveProfunctor p, Strong k p, SelfAction k) => (p :.: Costar t) :~> (Costar t :.: p) Source Github #

Monad m => Procomonad (Costar (Prelude m) :: Type -> Type -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Costar

Methods

extract :: Costar (Prelude m) :~> ((~>) :: CAT Type) Source Github #

duplicate :: Costar (Prelude m) :~> (Costar (Prelude m) :.: Costar (Prelude m)) Source Github #

Functor (Costar' :: OPPOSITE (j .-> k) -> j -> k -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Costar

Methods

map :: forall (a :: OPPOSITE (j .-> k)) (b :: OPPOSITE (j .-> k)). (a ~> b) -> Costar' a ~> Costar' b Source Github #

CategoryOf (j .-> k) Source Github #

The category of functors and natural transformations.

Instance details

Defined in Proarrow.Category.Instance.Nat

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Nat type (~>) = Nat' :: (j .-> k) -> (j .-> k) -> Type

Promonad (Nat' :: (j .-> k) -> (j .-> k) -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Nat

Methods

id :: forall (a :: j .-> k). Ob a => Nat' a a Source Github #

(.) :: forall (b :: j .-> k) (c :: j .-> k) (a :: j .-> k). Nat' b c -> Nat' a b -> Nat' a c Source Github #

Profunctor (Nat' :: (j .-> k) -> (j .-> k) -> Type) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Nat

Methods

dimap :: forall (c :: j .-> k) (a :: j .-> k) (b :: j .-> k) (d :: j .-> k). (c ~> a) -> (b ~> d) -> Nat' a b -> Nat' c d Source Github #

(\\) :: forall (a :: j .-> k) (b :: j .-> k) r. ((Ob a, Ob b) => r) -> Nat' a b -> r Source Github #

(CategoryOf j, CategoryOf k) => Functor (Star' :: (j .-> k) -> k -> j -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Star

Methods

map :: forall (a :: j .-> k) (b :: j .-> k). (a ~> b) -> Star' a ~> Star' b Source Github #

Promonad (Costar (Coyoneda :: (j +-> k) -> k -> j -> Type) :: (j +-> k) -> (k -> j -> Type) -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Coyoneda

Methods

id :: forall (a :: j +-> k). Ob a => Costar (Coyoneda :: (j +-> k) -> k -> j -> Type) a a Source Github #

(.) :: forall (b :: j +-> k) (c :: j +-> k) (a :: j +-> k). Costar (Coyoneda :: (j +-> k) -> k -> j -> Type) b c -> Costar (Coyoneda :: (j +-> k) -> k -> j -> Type) a b -> Costar (Coyoneda :: (j +-> k) -> k -> j -> Type) a c Source Github #

Profunctor p => Promonad (Costar ((:*:) p) :: (j +-> k) -> (k -> j -> Type) -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Costar

Methods

id :: forall (a :: j +-> k). Ob a => Costar ((:*:) p) a a Source Github #

(.) :: forall (b :: j +-> k) (c :: j +-> k) (a :: j +-> k). Costar ((:*:) p) b c -> Costar ((:*:) p) a b -> Costar ((:*:) p) a c Source Github #

Promonad (Costar (Yoneda :: (j +-> k) -> k -> j -> Type) :: (j +-> k) -> (k -> j -> Type) -> Type) Source Github #

Instance details

Defined in Proarrow.Profunctor.Yoneda

Methods

id :: forall (a :: j +-> k). Ob a => Costar (Yoneda :: (j +-> k) -> k -> j -> Type) a a Source Github #

(.) :: forall (b :: j +-> k) (c :: j +-> k) (a :: j +-> k). Costar (Yoneda :: (j +-> k) -> k -> j -> Type) b c -> Costar (Yoneda :: (j +-> k) -> k -> j -> Type) a b -> Costar (Yoneda :: (j +-> k) -> k -> j -> Type) a c Source Github #

type (Costar f :: k -> j -> Type) %% (a :: k) Source Github #

Instance details

Defined in Proarrow.Profunctor.Costar

type (Costar f :: k -> j -> Type) %% (a :: k) = f a

type (Costar ((,) a) :: Type -> Type -> Type) % (b :: Type) Source Github #

Instance details

Defined in Proarrow.Adjunction

type (Costar ((,) a) :: Type -> Type -> Type) % (b :: Type) = a -> b

type HasArrow (Costar f :: k -> j -> Type) (a :: k) (b :: j) Source Github #

Instance details

Defined in Proarrow.Profunctor.Costar

type HasArrow (Costar f :: k -> j -> Type) (a :: k) (b :: j) = f a ~ b

type (~>) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Nat

type (~>) = Nat' :: (j .-> k) -> (j .-> k) -> Type

type Ob (f :: j .-> k) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Nat

type Ob (f :: j .-> k) = (Is ('NT :: (j -> k) -> j .-> k) f, Functor (UN ('NT :: (j -> k) -> j .-> k) f))

type UN ('NT :: (j -> k) -> j .-> k) ('NT f :: j .-> k) Source Github #

Instance details

Defined in Proarrow.Category.Instance.Nat

type UN ('NT :: (j -> k) -> j .-> k) ('NT f :: j .-> k) = f

data Nat' (f :: k .-> k1) (g :: k .-> k1) where Source Github #

Constructors

Nat'
Fields :: forall {k} {k1} (f1 :: k -> k1) (g1 :: k -> k1). (Functor f1, Functor g1) => { unNat' :: f1 .~> g1 } -> Nat' ('NT f1) ('NT g1)

Instances

Instances details

Promonad (Nat' :: (j .-> k) -> (j .-> k) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods id :: forall (a :: j .-> k). Ob a => Nat' a a Source Github # (.) :: forall (b :: j .-> k) (c :: j .-> k) (a :: j .-> k). Nat' b c -> Nat' a b -> Nat' a c Source Github #
Profunctor (Nat' :: (j .-> k) -> (j .-> k) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Nat Methods dimap :: forall (c :: j .-> k) (a :: j .-> k) (b :: j .-> k) (d :: j .-> k). (c ~> a) -> (b ~> d) -> Nat' a b -> Nat' c d Source Github # (\\) :: forall (a :: j .-> k) (b :: j .-> k) r. ((Ob a, Ob b) => r) -> Nat' a b -> r Source Github #

first :: forall i j k (f :: i -> j -> k) (c :: j) (a :: i) (b :: i). (Functor f, ((~>) :: CAT (j -> k)) ~ (Nat :: (j -> k) -> (j -> k) -> Type), Ob c) => (a ~> b) -> f a c ~> f b c Source Github #

bimap :: forall i j k (f :: i -> j -> k) (a :: i) (c :: i) (b :: j) (d :: j). (Functor f, ((~>) :: CAT (j -> k)) ~ (Nat :: (j -> k) -> (j -> k) -> Type), Functor (f a)) => (a ~> c) -> (b ~> d) -> f a b ~> f c d Source Github #

Orphan instances

(ob Identity, forall (a :: Type -> Type) (b :: Type -> Type). (ob a, ob b) => ob (Compose a b)) => Strong (SUBCAT ob) (->) Source Github #

Instance details

Methods

act :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) x y. (a ~> b) -> (x -> y) -> Act a x -> Act b y Source Github #

Strong (Type -> Type) (->) Source Github #

Instance details

Methods

act :: forall (a :: Type -> Type) (b :: Type -> Type) x y. (a ~> b) -> (x -> y) -> Act a x -> Act b y Source Github #

(Functor f, Functor g) => Functor (Product f g :: k1 -> Type) Source Github #

Instance details

Methods

map :: forall (a :: k1) (b :: k1). (a ~> b) -> Product f g a ~> Product f g b Source Github #

(Functor f, Functor g) => Functor (Sum f g :: k1 -> Type) Source Github #

Instance details

Methods

map :: forall (a :: k1) (b :: k1). (a ~> b) -> Sum f g a ~> Sum f g b Source Github #

Copowered Type (k -> Type) Source Github #

Instance details

Methods

withObCopower :: forall (a :: k -> Type) n r. (Ob a, Ob n) => (Ob (n *. a) => r) -> r Source Github #

copower :: forall (a :: k -> Type) (b :: k -> Type) n. (Ob a, Ob b) => (n ~> HomObj Type a b) -> (n *. a) ~> b Source Github #

uncopower :: forall (a :: k -> Type) n (b :: k -> Type). (Ob a, Ob n) => ((n *. a) ~> b) -> n ~> HomObj Type a b Source Github #

Powered Type (k -> Type) Source Github #

Instance details

Methods

withObPower :: forall (a :: k -> Type) n r. (Ob a, Ob n) => (Ob (a ^ n) => r) -> r Source Github #

power :: forall (a :: k -> Type) (b :: k -> Type) n. (Ob a, Ob b) => (n ~> HomObj Type a b) -> a ~> (b ^ n) Source Github #

unpower :: forall (b :: k -> Type) n (a :: k -> Type). (Ob b, Ob n) => (a ~> (b ^ n)) -> n ~> HomObj Type a b Source Github #

Functor Either Source Github #

Instance details

Methods

map :: (a ~> b) -> Either a ~> Either b Source Github #

Functor (,) Source Github #

Instance details

Methods

map :: (a ~> b) -> (,) a ~> (,) b Source Github #

CategoryOf k1 => Closed (PROD (k1 -> Type)) Source Github #

Instance details

Methods

withObExp :: forall (a :: PROD (k1 -> Type)) (b :: PROD (k1 -> Type)) r. (Ob a, Ob b) => (Ob (a ~~> b) => r) -> r Source Github #

curry :: forall (a :: PROD (k1 -> Type)) (b :: PROD (k1 -> Type)) (c :: PROD (k1 -> Type)). (Ob a, Ob b) => ((a ** b) ~> c) -> a ~> (b ~~> c) Source Github #

apply :: forall (a :: PROD (k1 -> Type)) (b :: PROD (k1 -> Type)). (Ob a, Ob b) => ((a ~~> b) ** a) ~> b Source Github #

(^^^) :: forall (a :: PROD (k1 -> Type)) (b :: PROD (k1 -> Type)) (x :: PROD (k1 -> Type)) (y :: PROD (k1 -> Type)). (b ~> y) -> (x ~> a) -> (a ~~> b) ~> (x ~~> y) Source Github #

Monoidal (Type -> Type) Source Github #

Composition as monoidal tensor.

Instance details

Associated Types

type Unit
Instance details Defined in Proarrow.Category.Instance.Nat type Unit = Identity
type (f :: Type -> Type) ** (g :: Type -> Type)
Instance details Defined in Proarrow.Category.Instance.Nat type (f :: Type -> Type) ** (g :: Type -> Type) = Compose f g

Methods

withOb2 :: forall (a :: Type -> Type) (b :: Type -> Type) r. (Ob a, Ob b) => (Ob (a ** b) => r) -> r Source Github #

leftUnitor :: forall (a :: Type -> Type). Ob a => ((Unit :: Type -> Type) ** a) ~> a Source Github #

leftUnitorInv :: forall (a :: Type -> Type). Ob a => a ~> ((Unit :: Type -> Type) ** a) Source Github #

rightUnitor :: forall (a :: Type -> Type). Ob a => (a ** (Unit :: Type -> Type)) ~> a Source Github #

rightUnitorInv :: forall (a :: Type -> Type). Ob a => a ~> (a ** (Unit :: Type -> Type)) Source Github #

associator :: forall (a :: Type -> Type) (b :: Type -> Type) (c :: Type -> Type). (Ob a, Ob b, Ob c) => ((a ** b) ** c) ~> (a ** (b ** c)) Source Github #

associatorInv :: forall (a :: Type -> Type) (b :: Type -> Type) (c :: Type -> Type). (Ob a, Ob b, Ob c) => (a ** (b ** c)) ~> ((a ** b) ** c) Source Github #

CategoryOf (k1 -> k2 -> k3 -> k4 -> Type) Source Github #

The category of functors with target category k2 -> k3 -> k4 -> Type.

Instance details

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Nat type (~>) = Nat :: (k1 -> k2 -> k3 -> k4 -> Type) -> (k1 -> k2 -> k3 -> k4 -> Type) -> Type

CategoryOf (k1 -> k2 -> k3 -> Type) Source Github #

The category of functors with target category k2 -> k3 -> Type. Note that CategoryOf (k1 -> k2 -> Type) is reserved for profunctors.

Instance details

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Nat type (~>) = Nat :: (k1 -> k2 -> k3 -> Type) -> (k1 -> k2 -> k3 -> Type) -> Type

CategoryOf (k1 -> Type) Source Github #

The category of functors with target category Hask.

Instance details

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Nat type (~>) = Nat :: (k1 -> Type) -> (k1 -> Type) -> Type

HasBinaryCoproducts (k1 -> Type) Source Github #

Instance details

Methods

withObCoprod :: forall (a :: k1 -> Type) (b :: k1 -> Type) r. (Ob a, Ob b) => (Ob (a || b) => r) -> r Source Github #

lft :: forall (a :: k1 -> Type) (b :: k1 -> Type). (Ob a, Ob b) => a ~> (a || b) Source Github #

rgt :: forall (a :: k1 -> Type) (b :: k1 -> Type). (Ob a, Ob b) => b ~> (a || b) Source Github #

(|||) :: forall (x :: k1 -> Type) (a :: k1 -> Type) (y :: k1 -> Type). (x ~> a) -> (y ~> a) -> (x || y) ~> a Source Github #

(+++) :: forall (a :: k1 -> Type) (b :: k1 -> Type) (x :: k1 -> Type) (y :: k1 -> Type). (a ~> x) -> (b ~> y) -> (a || b) ~> (x || y) Source Github #

HasBinaryProducts (k1 -> Type) Source Github #

Instance details

Methods

withObProd :: forall (a :: k1 -> Type) (b :: k1 -> Type) r. (Ob a, Ob b) => (Ob (a && b) => r) -> r Source Github #

fst :: forall (a :: k1 -> Type) (b :: k1 -> Type). (Ob a, Ob b) => (a && b) ~> a Source Github #

snd :: forall (a :: k1 -> Type) (b :: k1 -> Type). (Ob a, Ob b) => (a && b) ~> b Source Github #

(&&&) :: forall (a :: k1 -> Type) (x :: k1 -> Type) (y :: k1 -> Type). (a ~> x) -> (a ~> y) -> a ~> (x && y) Source Github #

(***) :: forall (a :: k1 -> Type) (b :: k1 -> Type) (x :: k1 -> Type) (y :: k1 -> Type). (a ~> x) -> (b ~> y) -> (a && b) ~> (x && y) Source Github #

Coclosed (Type -> Type) Source Github #

Instance details

Associated Types

type (f :: Type -> Type) <~~ (j :: Type -> Type)
Instance details Defined in Proarrow.Category.Instance.Nat type (f :: Type -> Type) <~~ (j :: Type -> Type) = Lan j f

Methods

withObCoExp :: forall (a :: Type -> Type) (b :: Type -> Type) r. (Ob a, Ob b) => (Ob (a <~~ b) => r) -> r Source Github #

coeval :: forall (a :: Type -> Type) (b :: Type -> Type). (Ob a, Ob b) => a ~> ((a <~~ b) ** b) Source Github #

coevalUniv :: forall (b :: Type -> Type) (c :: Type -> Type) (a :: Type -> Type). (Ob b, Ob c) => (a ~> (c ** b)) -> (a <~~ b) ~> c Source Github #

Closed (Type -> Type) Source Github #

Instance details

Associated Types

type (j :: Type -> Type) ~~> (h :: Type -> Type)
Instance details Defined in Proarrow.Category.Instance.Nat type (j :: Type -> Type) ~~> (h :: Type -> Type) = Ran j h

Methods

withObExp :: forall (a :: Type -> Type) (b :: Type -> Type) r. (Ob a, Ob b) => (Ob (a ~~> b) => r) -> r Source Github #

curry :: forall (a :: Type -> Type) (b :: Type -> Type) (c :: Type -> Type). (Ob a, Ob b) => ((a ** b) ~> c) -> a ~> (b ~~> c) Source Github #

apply :: forall (a :: Type -> Type) (b :: Type -> Type). (Ob a, Ob b) => ((a ~~> b) ** a) ~> b Source Github #

(^^^) :: forall (a :: Type -> Type) (b :: Type -> Type) (x :: Type -> Type) (y :: Type -> Type). (b ~> y) -> (x ~> a) -> (a ~~> b) ~> (x ~~> y) Source Github #

CategoryOf k1 => HasInitialObject (k1 -> Type) Source Github #

Instance details

Associated Types

type InitialObject
Instance details Defined in Proarrow.Category.Instance.Nat type InitialObject = Const Void :: k1 -> Type

Methods

initiate :: forall (a :: k1 -> Type). Ob a => (InitialObject :: k1 -> Type) ~> a Source Github #

CategoryOf k1 => HasTerminalObject (k1 -> Type) Source Github #

Instance details

Associated Types

type TerminalObject
Instance details Defined in Proarrow.Category.Instance.Nat type TerminalObject = Const () :: k1 -> Type

Methods

terminate :: forall (a :: k1 -> Type). Ob a => a ~> (TerminalObject :: k1 -> Type) Source Github #

(Monoidal (SUBCAT ob), Strong (SUBCAT ob) ((~>) :: CAT Type)) => MonoidalAction (SUBCAT ob) Type Source Github #

Instance details

Methods

withObAct :: forall (a :: SUBCAT ob) x r. (Ob a, Ob x) => (Ob (Act a x) => r) -> r Source Github #

unitor :: Ob x => Act (Unit :: SUBCAT ob) x ~> x Source Github #

unitorInv :: Ob x => x ~> Act (Unit :: SUBCAT ob) x Source Github #

multiplicator :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) x. (Ob a, Ob b, Ob x) => Act (a ** b) x ~> Act a (Act b x) Source Github #

multiplicatorInv :: forall (a :: SUBCAT ob) (b :: SUBCAT ob) x. (Ob a, Ob b, Ob x) => Act a (Act b x) ~> Act (a ** b) x Source Github #

MonoidalAction (Type -> Type) Type Source Github #

Instance details

Associated Types

type Act (p :: Type -> Type) (x :: Type)
Instance details Defined in Proarrow.Category.Instance.Nat type Act (p :: Type -> Type) (x :: Type) = p x

Methods

withObAct :: forall (a :: Type -> Type) x r. (Ob a, Ob x) => (Ob (Act a x) => r) -> r Source Github #

unitor :: Ob x => Act (Unit :: Type -> Type) x ~> x Source Github #

unitorInv :: Ob x => x ~> Act (Unit :: Type -> Type) x Source Github #

multiplicator :: forall (a :: Type -> Type) (b :: Type -> Type) x. (Ob a, Ob b, Ob x) => Act (a ** b) x ~> Act a (Act b x) Source Github #

multiplicatorInv :: forall (a :: Type -> Type) (b :: Type -> Type) x. (Ob a, Ob b, Ob x) => Act a (Act b x) ~> Act (a ** b) x Source Github #

Functor ((:.:) :: (j +-> k) -> (i +-> j) -> k -> i -> Type) Source Github #

Instance details

Methods

map :: forall (a :: j +-> k) (b :: j +-> k). (a ~> b) -> ((:.:) a :: (i +-> j) -> k -> i -> Type) ~> ((:.:) b :: (i +-> j) -> k -> i -> Type) Source Github #