Safe Haskell	None
Language	GHC2024

Proarrow.Category.Instance.Product

Contents

Orphan instances

Description

The product of two categories: the tuple kind (j, k) is the category whose arrows are pairs of arrows, p :**: q being the corresponding product of profunctors. The projections Fst/Snd and diagonal Diag are provided as representable profunctors.

Documentation

data ((c :: j1 +-> k1) :**: (d :: j2 +-> k2)) (a :: (k1, k2)) (b :: (j1, j2)) where Source Github #

Constructors

(:**:)
Fields :: forall {j1} {k1} {j2} {k2} (c :: j1 +-> k1) (a1 :: k1) (b1 :: j1) (d :: j2 +-> k2) (a2 :: k2) (b2 :: j2). { fstK :: c a1 b1 , sndK :: d a2 b2 } -> (c :**: d) '(a1, a2) '(b1, b2)

Instances

Instances details

(w1 p1 q1, w2 p2 q2, Profunctor p1, Profunctor p2, Profunctor q1, Profunctor q2) => ProdFl (w1 :: (j4 +-> j4) -> (j5 +-> j5) -> Constraint) (w2 :: (j6 +-> j6) -> (j7 +-> j7) -> Constraint) (p1 :: p2 :: (j4, j6) -> (j4, j6) -> Type) (q1 :: q2 :: (j5, j7) -> (j5, j7) -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Prod Methods withProdP :: forall (s :: (j4, j6)) (a :: (j4, j6)) (b :: (j5, j7)) (t :: (j5, j7)) r. (p1 :: p2) s a -> (q1 :: q2) b t -> (forall (p10 :: j4 +-> j4) (p20 :: j6 +-> j6) (q10 :: j5 +-> j5) (q20 :: j7 +-> j7). (w1 p10 q10, w2 p20 q20, Profunctor p10, Profunctor p20, Profunctor q10, Profunctor q20) => p10 ((Fst :: (j4, j6) +-> j4) @ s) ((Fst :: (j4, j6) +-> j4) @ a) -> p20 ((Snd :: (j4, j6) +-> j6) @ s) ((Snd :: (j4, j6) +-> j6) @ a) -> q10 ((Fst :: (j5, j7) +-> j5) @ b) ((Fst :: (j5, j7) +-> j5) @ t) -> q20 ((Snd :: (j5, j7) +-> j7) @ b) ((Snd :: (j5, j7) +-> j7) @ t) -> r) -> r Source Github #
(FoldFl p1 q1, FoldFl p2 q2, Monoidal k) => FoldFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods foldMapP :: forall (m :: k) (s :: k) (a :: k). Monoid m => Beside p1 p2 s a -> (a ~> m) -> s ~> m Source Github #
(FoldFl p1 q1, FoldFl p2 q2, HasBinaryCoproducts k) => FoldFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods foldMapP :: forall (m :: k) (s :: k) (a :: k). Monoid m => BesideSum p1 p2 s a -> (a ~> m) -> s ~> m Source Github #
(SetterFl p1 q1, SetterFl p2 q2, Monoidal k) => SetterFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods overP :: forall (s :: k) (a :: k) (b :: k) (t :: k). Beside p1 p2 s a -> CoBeside q1 q2 b t -> (a ~> b) -> s ~> t Source Github #
(SetterFl p1 q1, SetterFl p2 q2, HasBinaryCoproducts k) => SetterFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods overP :: forall (s :: k) (a :: k) (b :: k) (t :: k). BesideSum p1 p2 s a -> CoBesideSum q1 q2 b t -> (a ~> b) -> s ~> t Source Github #
(MonTravFl p1 q1, MonTravFl p2 q2, Monoidal k) => MonTravFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods monTravP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). StrongDistributiveProfunctor r => Beside p1 p2 s a -> CoBeside q1 q2 b t -> r a b -> r s t Source Github #
(MonTravFl p1 q1, MonTravFl p2 q2, HasBinaryCoproducts k) => MonTravFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods monTravP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). StrongDistributiveProfunctor r => BesideSum p1 p2 s a -> CoBesideSum q1 q2 b t -> r a b -> r s t Source Github #
(TravFl p1 q1, TravFl p2 q2, Monoidal k) => TravFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods travP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). (StrongDistributiveProfunctor r, Strong (ProdAction :: k -> (PROD k, k) -> Type) r) => Beside p1 p2 s a -> CoBeside q1 q2 b t -> r a b -> r s t Source Github #
(TravFl p1 q1, TravFl p2 q2, HasBinaryCoproducts k) => TravFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods travP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). (StrongDistributiveProfunctor r, Strong (ProdAction :: k -> (PROD k, k) -> Type) r) => BesideSum p1 p2 s a -> CoBesideSum q1 q2 b t -> r a b -> r s t Source Github #
(Finitary p, Finitary q) => Finitary (p :**: q :: (k1, k2) -> (j1, j2) -> Type) Source Github #	The product of two finitary profunctors on the product of their kinds, numbered as `:*:` is.
Instance details Defined in Proarrow.Category.Enriched.Finitary Methods size :: forall (a :: (k1, k2)) (b :: (j1, j2)). (Ob a, Ob b) => Natural Source Github # toIndex :: forall (a :: (k1, k2)) (b :: (j1, j2)). (Ob a, Ob b) => (p :: q) a b -> Natural Source Github # fromIndex :: forall (a :: (k1, k2)) (b :: (j1, j2)). (Ob a, Ob b) => Natural -> (p :: q) a b Source Github # elements :: forall (a :: (k1, k2)) (b :: (j1, j2)). (Ob a, Ob b) => [(p :**: q) a b] Source Github #
(DecidableProfunctor p, DecidableProfunctor q) => DecidableProfunctor (p :**: q :: (k1, k2) -> (j1, j2) -> Type) Source Github #	A product holds when both components do: the type-level `&&` is `BOOL`'s categorical product.
Instance details Defined in Proarrow.Limit.BinaryProduct Methods decide :: forall (a :: (k1, k2)) (b :: (j1, j2)). (Ob a, Ob b) => Decision (p :: q) a b (Holds (p :: q) a b) Source Github # toHolds :: forall (a :: (k1, k2)) (b :: (j1, j2)) r. (p :: q) a b -> ((Holds (p :: q) a b ~ 'TRU, Ob a, Ob b) => r) -> r Source Github #
(ThinProfunctor p, ThinProfunctor q) => ThinProfunctor (p :**: q :: (k1, k2) -> (j1, j2) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Product Methods arr :: forall (a :: (k1, k2)) (b :: (j1, j2)). (Ob a, Ob b, HasArrow (p :: q) a b) => (p :: q) a b Source Github # withArr :: forall (a :: (k1, k2)) (b :: (j1, j2)) r. (p :: q) a b -> ((HasArrow (p :: q) a b, Ob a, Ob b) => r) -> r Source Github #
(MonoidalProfunctor p, MonoidalProfunctor q) => MonoidalProfunctor (p :**: q :: (k1, k2) -> (j1, j2) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Monoidal Methods one :: (p :: q) (Unit :: (k1, k2)) (Unit :: (j1, j2)) Source Github # () :: forall (x1 :: (k1, k2)) (x2 :: (j1, j2)) (y1 :: (k1, k2)) (y2 :: (j1, j2)). (p :: q) x1 x2 -> (p :: q) y1 y2 -> (p :: q) (x1 y1) (x2 ** y2) Source Github #
(Profunctor p, Profunctor q) => Profunctor (p :**: q :: (k1, k2) -> (j1, j2) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Product Methods dimap :: forall (c :: (k1, k2)) (a :: (k1, k2)) (b :: (j1, j2)) (d :: (j1, j2)). (c ~> a) -> (b ~> d) -> (p :: q) a b -> (p :: q) c d Source Github # lmap :: forall (c :: (k1, k2)) (a :: (k1, k2)) (b :: (j1, j2)). (c ~> a) -> (p :: q) a b -> (p :: q) c b Source Github # rmap :: forall (b :: (j1, j2)) (d :: (j1, j2)) (a :: (k1, k2)). (b ~> d) -> (p :: q) a b -> (p :: q) a d Source Github # (\\) :: forall (a :: (k1, k2)) (b :: (j1, j2)) r. ((Ob a, Ob b) => r) -> (p :**: q) a b -> r Source Github #
(Representable p, Representable q) => Representable (p :**: q :: (k1, k2) -> (j1, j2) -> Type) Source Github #
Instance details Defined in Proarrow.Profunctor.Representable Methods index :: forall (a :: (k1, k2)) (b :: (j1, j2)). (p :: q) a b -> a ~> ((p :: q) % b) Source Github # tabulate :: forall (b :: (j1, j2)) (a :: (k1, k2)). Ob b => (a ~> ((p :: q) % b)) -> (p :: q) a b Source Github # repMap :: forall (a :: (j1, j2)) (b :: (j1, j2)). (a ~> b) -> ((p :: q) % a) ~> ((p :: q) % b) Source Github # repUniv :: forall (a :: (j1, j2)). Ob a => (p :: q) ((p :: q) % a) a Source Github #
(Proadjunction p1 q1, Proadjunction p2 q2) => Proadjunction (p1 :: p2 :: (j1, j2) -> (k1, k2) -> Type) (q1 :: q2 :: (k1, k2) -> (j1, j2) -> Type) Source Github #	Adjunctions pair up over the product category.
Instance details Defined in Proarrow.Adjunction Methods unit :: forall (a :: (k1, k2)). Ob a => ((q1 :: q2) :.: (p1 :: p2)) a a Source Github # counit :: ((p1 :: p2) :.: (q1 :: q2)) :~> ((~>) :: CAT (j1, j2)) Source Github #
(DaggerProfunctor p, DaggerProfunctor q) => DaggerProfunctor (p :**: q :: (j1, j2) -> (j1, j2) -> Type) Source Github #
Instance details Defined in Proarrow.Category.Instance.Product Methods dagger :: forall (a :: (j1, j2)) (b :: (j1, j2)). (p :: q) a b -> (p :: q) b a Source Github #
(Promonad p, Promonad q) => Promonad (p :**: q :: (j1, j2) -> (j1, j2) -> Type) Source Github #	The product promonad of promonads `p` and `q`.
Instance details Defined in Proarrow.Category.Instance.Product Methods id :: forall (a :: (j1, j2)). Ob a => (p :: q) a a Source Github # (.) :: forall (b :: (j1, j2)) (c :: (j1, j2)) (a :: (j1, j2)). (p :: q) b c -> (p :: q) a b -> (p :: q) a c Source Github #
type (p :**: q :: (k1, k2) -> (j1, j2) -> Type) % ('(a, b) :: (j1, j2)) Source Github #
Instance details Defined in Proarrow.Profunctor.Representable type (p :**: q :: (k1, k2) -> (j1, j2) -> Type) % ('(a, b) :: (j1, j2)) = '(p % a, q % b)
type HasArrow (p :**: q :: (k1, k2) -> (j1, j2) -> Type) ('(a1, a2) :: (k1, k2)) ('(b1, b2) :: (j1, j2)) Source Github #
Instance details Defined in Proarrow.Category.Instance.Product type HasArrow (p :**: q :: (k1, k2) -> (j1, j2) -> Type) ('(a1, a2) :: (k1, k2)) ('(b1, b2) :: (j1, j2)) = (HasArrow p a1 b1, HasArrow q a2 b2)
type Holds (p :**: q :: (k1, k2) -> (j1, j2) -> Type) ('(a1, a2) :: (k1, k2)) ('(b1, b2) :: (j1, j2)) Source Github #
Instance details Defined in Proarrow.Limit.BinaryProduct type Holds (p :**: q :: (k1, k2) -> (j1, j2) -> Type) ('(a1, a2) :: (k1, k2)) ('(b1, b2) :: (j1, j2)) = Holds p a1 b1 && Holds q a2 b2

data family Fst :: (j, k) +-> j Source Github #

Instances

Instances details

(CategoryOf j, CategoryOf k) => FunctorForRep (Fst :: (j, k) +-> j) Source Github #
Instance details Defined in Proarrow.Category.Instance.Product Methods fmap :: forall (a :: (j, k)) (b :: (j, k)). (a ~> b) -> ((Fst :: (j, k) +-> j) @ a) ~> ((Fst :: (j, k) +-> j) @ b) Source Github #
type (Fst :: (j, k) +-> j) @ ('(a, b) :: (j, k)) Source Github #
Instance details Defined in Proarrow.Category.Instance.Product type (Fst :: (j, k) +-> j) @ ('(a, b) :: (j, k)) = a

data family Snd :: (j, k) +-> k Source Github #

Instances

Instances details

(CategoryOf j, CategoryOf k) => FunctorForRep (Snd :: (j, k) +-> k) Source Github #
Instance details Defined in Proarrow.Category.Instance.Product Methods fmap :: forall (a :: (j, k)) (b :: (j, k)). (a ~> b) -> ((Snd :: (j, k) +-> k) @ a) ~> ((Snd :: (j, k) +-> k) @ b) Source Github #
type (Snd :: (j, k) +-> k) @ ('(a, b) :: (j, k)) Source Github #
Instance details Defined in Proarrow.Category.Instance.Product type (Snd :: (j, k) +-> k) @ ('(a, b) :: (j, k)) = b

data family Diag :: k +-> (k, k) Source Github #

Instances

Instances details

(FoldFl p1 q1, FoldFl p2 q2, Monoidal k) => FoldFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods foldMapP :: forall (m :: k) (s :: k) (a :: k). Monoid m => Beside p1 p2 s a -> (a ~> m) -> s ~> m Source Github #
(FoldFl p1 q1, FoldFl p2 q2, HasBinaryCoproducts k) => FoldFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods foldMapP :: forall (m :: k) (s :: k) (a :: k). Monoid m => BesideSum p1 p2 s a -> (a ~> m) -> s ~> m Source Github #
CategoryOf k => FunctorForRep (Diag :: k +-> (k, k)) Source Github #
Instance details Defined in Proarrow.Category.Instance.Product Methods fmap :: forall (a :: k) (b :: k). (a ~> b) -> ((Diag :: k +-> (k, k)) @ a) ~> ((Diag :: k +-> (k, k)) @ b) Source Github #
HasBinaryCoproducts k => Corepresentable (Rep (Diag :: k +-> (k, k)) :: (k, k) -> k -> Type) Source Github #	The left adjoint to the diagonal functor.
Instance details Defined in Proarrow.Colimit.BinaryCoproduct Methods coindex :: forall (a :: (k, k)) (b :: k). Rep (Diag :: k +-> (k, k)) a b -> (Rep (Diag :: k +-> (k, k)) %% a) ~> b Source Github # cotabulate :: forall (a :: (k, k)) (b :: k). Ob a => ((Rep (Diag :: k +-> (k, k)) %% a) ~> b) -> Rep (Diag :: k +-> (k, k)) a b Source Github # corepMap :: forall (a :: (k, k)) (b :: (k, k)). (a ~> b) -> (Rep (Diag :: k +-> (k, k)) %% a) ~> (Rep (Diag :: k +-> (k, k)) %% b) Source Github # corepUniv :: forall (a :: (k, k)). Ob a => Rep (Diag :: k +-> (k, k)) a (Rep (Diag :: k +-> (k, k)) %% a) Source Github #
(SetterFl p1 q1, SetterFl p2 q2, Monoidal k) => SetterFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods overP :: forall (s :: k) (a :: k) (b :: k) (t :: k). Beside p1 p2 s a -> CoBeside q1 q2 b t -> (a ~> b) -> s ~> t Source Github #
(SetterFl p1 q1, SetterFl p2 q2, HasBinaryCoproducts k) => SetterFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods overP :: forall (s :: k) (a :: k) (b :: k) (t :: k). BesideSum p1 p2 s a -> CoBesideSum q1 q2 b t -> (a ~> b) -> s ~> t Source Github #
(MonTravFl p1 q1, MonTravFl p2 q2, Monoidal k) => MonTravFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods monTravP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). StrongDistributiveProfunctor r => Beside p1 p2 s a -> CoBeside q1 q2 b t -> r a b -> r s t Source Github #
(MonTravFl p1 q1, MonTravFl p2 q2, HasBinaryCoproducts k) => MonTravFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods monTravP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). StrongDistributiveProfunctor r => BesideSum p1 p2 s a -> CoBesideSum q1 q2 b t -> r a b -> r s t Source Github #
(TravFl p1 q1, TravFl p2 q2, Monoidal k) => TravFl (Beside p1 p2 :: k -> k -> Type) (CoBeside q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods travP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). (StrongDistributiveProfunctor r, Strong (ProdAction :: k -> (PROD k, k) -> Type) r) => Beside p1 p2 s a -> CoBeside q1 q2 b t -> r a b -> r s t Source Github #
(TravFl p1 q1, TravFl p2 q2, HasBinaryCoproducts k) => TravFl (BesideSum p1 p2 :: k -> k -> Type) (CoBesideSum q1 q2 :: k -> k -> Type) Source Github #
Instance details Defined in Proarrow.Optic.Traversal Methods travP :: forall r (s :: k) (a :: k) (b :: k) (t :: k). (StrongDistributiveProfunctor r, Strong (ProdAction :: k -> (PROD k, k) -> Type) r) => BesideSum p1 p2 s a -> CoBesideSum q1 q2 b t -> r a b -> r s t Source Github #
HasBinaryProducts k => Representable (Corep (Diag :: k +-> (k, k)) :: k -> (k, k) -> Type) Source Github #	The right adjoint to the diagonal functor.
Instance details Defined in Proarrow.Limit.BinaryProduct Methods index :: forall (a :: k) (b :: (k, k)). Corep (Diag :: k +-> (k, k)) a b -> a ~> (Corep (Diag :: k +-> (k, k)) % b) Source Github # tabulate :: forall (b :: (k, k)) (a :: k). Ob b => (a ~> (Corep (Diag :: k +-> (k, k)) % b)) -> Corep (Diag :: k +-> (k, k)) a b Source Github # repMap :: forall (a :: (k, k)) (b :: (k, k)). (a ~> b) -> (Corep (Diag :: k +-> (k, k)) % a) ~> (Corep (Diag :: k +-> (k, k)) % b) Source Github # repUniv :: forall (a :: (k, k)). Ob a => Corep (Diag :: k +-> (k, k)) (Corep (Diag :: k +-> (k, k)) % a) a Source Github #
type (Diag :: k +-> (k, k)) @ (a :: k) Source Github #
Instance details Defined in Proarrow.Category.Instance.Product type (Diag :: k +-> (k, k)) @ (a :: k) = '(a, a)
type (Rep (Diag :: k +-> (k, k)) :: (k, k) -> k -> Type) %% ('(a, b) :: (k, k)) Source Github #
Instance details Defined in Proarrow.Colimit.BinaryCoproduct type (Rep (Diag :: k +-> (k, k)) :: (k, k) -> k -> Type) %% ('(a, b) :: (k, k)) = a \|\| b
type (Corep (Diag :: k +-> (k, k)) :: k -> (k, k) -> Type) % ('(a, b) :: (k, k)) Source Github #
Instance details Defined in Proarrow.Limit.BinaryProduct type (Corep (Diag :: k +-> (k, k)) :: k -> (k, k) -> Type) % ('(a, b) :: (k, k)) = a && b

checkDiscrete :: forall j k (a :: (j, k)) (b :: (j, k)) r. (Discrete j, Discrete k) => Hom (j, k) a b -> (a ~ b => r) -> r Source Github #

checkCodiscreteProfunctor :: forall {j1} {k1} {j2} {k2} (p :: j1 +-> k1) (q :: j2 +-> k2) (a :: (k1, k2)) (b :: (j1, j2)). (CodiscreteProfunctor p, CodiscreteProfunctor q, Ob a, Ob b) => (p :**: q) a b Source Github #

Orphan instances

Enumerable (BOOL, BOOL) Source Github #

Instance details

Methods

withIndex :: forall (a :: (BOOL, BOOL)) r. Ob a => (KnownIndex a => r) -> r Source Github #

withOb :: forall (a :: (BOOL, BOOL)) r. KnownIndex a => (Ob a => r) -> r Source Github #

atOb :: forall (i :: Nat). SNat i -> AtOb (BOOL, BOOL) (At (BOOL, BOOL) i) Source Github #

Finite (BOOL, BOOL) Source Github #

Instance details

Associated Types

type Objects (BOOL, BOOL)
Instance details Defined in Proarrow.Category.Instance.Product type Objects (BOOL, BOOL) = '['('FLS, 'FLS), '('FLS, 'TRU), '('TRU, 'FLS), '('TRU, 'TRU)]

Methods

finite :: IndexedList (Objects (BOOL, BOOL)) Source Github #

withAtLookup :: forall (i :: Nat) r. SNat i -> (Lookup (Objects (BOOL, BOOL)) i ~ At (BOOL, BOOL) i => r) -> r Source Github #

Indexed (BOOL, BOOL) Source Github #

The product of two enumerable kinds is enumerable, but numbering one in general needs type-level division to invert the pairing, which fin does not provide, so the one product needed so far is numbered by hand. The order matches the value-level pairIndex convention -- first component slowest -- so a generic instance could replace this without renumbering anything.

(Proarrow.Category.Sheaf uses this kind as the opens of a discrete two-point space: a pair of booleans is a subset of {x, y}.)

Instance details

Associated Types

type Index (a :: (BOOL, BOOL))
Instance details Defined in Proarrow.Category.Instance.Product type Index (a :: (BOOL, BOOL)) = IndexOf a (Objects (BOOL, BOOL))
type At (BOOL, BOOL) i
Instance details Defined in Proarrow.Category.Instance.Product type At (BOOL, BOOL) i = Lookup (Objects (BOOL, BOOL)) i

(CategoryOf k1, CategoryOf k2) => CategoryOf (k1, k2) Source Github #

The product of two categories.

Instance details

Associated Types

type (~>)
Instance details Defined in Proarrow.Category.Instance.Product type (~>) = ((~>) :: CAT k1) :**: ((~>) :: CAT k2)