关于Product与Coproduct中factorizer模式识别的技术问询

Let's unpack these two questions one by one—they're perfect examples of how category theory concepts map directly to Haskell code!

1. Why does (c -> (a, b)) fit the Product factorizer pattern? #

First, let's recall the categorical definition of a Product:

A Product of objects a and b is an object P together with two projection functions p: P → a and q: P → b, such that for any object c and pair of functions f: c → a, g: c → b, there exists a unique function h: c → P (the factorizer!) where p ∘ h = f and q ∘ h = g.

Now map this to your Haskell code:

• The Product object P here is the tuple (a, b).
• The projection functions are Haskell's built-in fst :: (a, b) → a and snd :: (a, b) → b.
• Your factorizer function is exactly that unique h! Let's verify:
  • When you call factorizer p q, you get a function \x -> (p x, q x).
  • Composing fst with this function gives fst (h x) = fst (p x, q x) = p x—which matches fst ∘ h = p.
  • Similarly, snd (h x) = q x, so snd ∘ h = q.

The key insight is that tuples in Haskell are the categorical Product for types, and your factorizer enforces the universal property of Products: it takes any pair of functions from c to a/b and combines them into a single function to the Product object, which "commutes" with the projection functions.

2. How to spot the Coproduct pattern in the second factorizer? #

Coproducts are the dual of Products—here's their categorical definition:

A Coproduct of objects a and b is an object Q together with two injection functions i: a → Q and j: b → Q, such that for any object c and pair of functions f: a → c, g: b → c, there exists a unique function h: Q → c (the factorizer!) where h ∘ i = f and h ∘ j = g.

Let's map this to your Either code:

• The Coproduct object Q here is Either a b.
• The injection functions are the constructors Left :: a → Either a b and Right :: b → Either a b.
• Your factorizer is that unique h! Let's check the universal property:
  • When you pass i :: a → c and j :: b → c to factorizer, it returns a function that handles Either a b cases:
    • For Left a, it runs i a—this is exactly h (Left a) = i a, meaning h ∘ Left = i.
    • For Right b, it runs j b—so h ∘ Right = j.

This is the core of Coproducts: the factorizer takes two functions from a/b to c and combines them into a single function from the Coproduct object to c, which commutes with the injection constructors. In Haskell, Either is the standard Coproduct for types, and this factorizer is actually the same as the base library's either function (you might know it as either i j!).

内容的提问来源于stack exchange，提问作者softshipper