Note that there is only one function from the empty set to any other set (ProofWiki 2018) that makes the empty set the Initial object in Set category.

Terminal object in Set category is a set with one element i.e Singleton.

In our toy example Programming languages examples the type String is Initial object and type Bool is the Terminal object.

Cartesian product: \(C = A \times B = \{(a,b)| a \in A, b \in B\}\) is the Product of two sets \(A\) and \(B\) in Set category. We have only one option for \(\pi_{1,2}\): \[\begin{aligned} \pi_1 : (a,b) \to a \in A, \nonumber \\ \pi_2 : (a,b) \to b \in B. \nonumber \end{aligned}\] Assume that \(A\) and \(B\) are non-empty and at least one of them has more than one element. Consider also another candidate: \(C' = A \times A \times B \times B = \{(a_1,a_2,b_1, b_2)| a_{1,2} \in A, b_{1,2} \in B\}\). There are different options for \(\pi'_1\) and \(\pi'_2\). Lets choose the following ones: \[\begin{aligned} \pi'_1 : (a_1,a_2,b_1, b_2) \to a_1 \in A, \nonumber \\ \pi'_2 : (a_1,a_2,b_1, b_2) \to b_2 \in B. \nonumber \end{aligned}\] We have only one morphism \(h\) that satisfied conditions (Product): \[h: (a_1,a_2,b_1, b_2) \to (a_1, b_2) \in A \times B\] that is accordingly with the Product definition for \(C = A \times B\).

If \(C'\) had been the Product then it would have satisfied the following factorization conditions: \[\begin{aligned} \pi_1 = \pi'_1 \circ h', \nonumber \\ \pi_2 = \pi'_2 \circ h', \end{aligned}\] where \(h'\) would have been an unique morphism. From other side there are a lot of morphisms \(h'\) which factorize \(\pi_{1,2}\) accordingly (Product): \[h' : (a,b) \to (a, \bar{a}, \bar{b}, b),\] where \(\bar{a}\) can be replaced with any element from \(A\) and \(\bar{b}\) can be replaced with any element of \(B\). Therefore \(C'\) can not be considered as the Product of \(A\) and \(B\).

Disjoint union is the Sum of two sets \(A\) and \(B\) in Set category.

Monoid concept is widely spread in math. Especially integer numbers form a monoid under summation operation. They also form another monoid under multiplication operation. The element 0 is used as identity in summation and 1 is used as the identity in multiplication.

There is a declaration of Monoid in modern \(\mathbf{Hask}\):

class Semigroup m => Monoid m where
    mempty :: m
    mappend :: m -> m -> m
    mappend = (<>)
    mconcat :: [m] -> m
    mconcat = foldr mappend mempty

The binary operation is inherited from Semigroup and written as (<>), while mappend is the compatibility name for the same operation. The identity is mempty. As it was mentioned in the Monoid definition (see Monoid), the binary operation should satisfy the associativity (Monoid) and identity element (Monoid) properties. This is a responsibility of a particular implementation to satisfy the properties. For instance the standard list implementation satisfies them:

instance Monoid [a] where
    mappend = (++)
    mempty = []

Set category is an example (Wikipedia contributors 2018) of Distributive category

From other hand not all categories which have both product and sum are distributive. One of such example is a category of all groups \(\mathbf{Grp}\) (Wikipedia contributors 2018) where groups are considered as objects and group homomorphisms as morphisms.

Consider 2 sets \(A\) and \(B\) then the set of functions between the 2 sets forms a new set that is called as Homset and denoted as \(\mathrm{hom}\left(A, B\right)\). Thus if \(A,B \in \mathrm{ob}(\mathbf{Set})\) then \(\mathrm{hom}\left(A, B\right) \in \mathrm{ob}(\mathbf{Set})\).

Lets look at the Exponential in \(\mathbf{Set}\). We want to show that the object corresponds to the function. Really if we want to define a function \(f: X \to Y\) then we should look at the Homset \(F = \mathrm{hom}\left(X, Y\right)\). \(f \in F\) - is an element of the Homset. For the function application we have to take the argument \(x \in X\) and the function we want to apply \(f \in F\). Then we construct the pair \((f,x) \in F \times X\). For the function application we have to call a Morphism \(e: F \times X \to Y\). ³ I.e. the application \(e(f, x)\) gives us \(e(f, x) = y \in Y\) - the function value.

If we avoid lazy evaluations in Haskell (see Haskell lazy evaluation) then we can found several types as candidates for initial and terminal object in Haskell. Initial object in Hask category is a type without values

data Void

i.e. you cannot construct a object of the type.

There is only one function from the initial object:

absurd :: Void -> a

The function is called absurd because it does absurd action. Nobody can proof that it does not exist. For the existence proof the following absurd argument can be used: “Just provide me an object type Void and I will provide you the result of evaluation”.

There is no function in opposite direction because it would had been used for the Void object creation.

Terminal object (unit) in Hask category keeps only one element

data () = ()

i.e. you can create only one element of the type. You can use the following function for the creation:

unit :: a -> ()
unit _ = ()

The Product in Hask category keeps a pair and the constructor defined as follows

(,) :: a -> b -> (a, b)
(,) x y = (x, y)

There are 2 projectors:

fst :: (a, b) -> a
fst (x, _) = x
snd :: (a, b) -> b
snd (_, y) = y

The Sum in Hask category defined as follows

data Either a b = Left a | Right b

The typical usage is via pattern matching for instance

factor :: (a -> c) -> (b -> c) -> Either a b -> c
factor f _ (Left x) = f x
factor _ g (Right y) = g y

As soon as \(\mathbf{Hask}\) is a Cartesian closed category then by Cartesian closed category it is a Distributive category i.e. one can conclude that

(a,Either b c)

is the same to

Either (a, b) (a, c)

It’s not surprisingly that the Exponential in \(\mathbf{Hask}\) is a function object i.e. \(b^a\) can be written as a -> b.

Exponential gives interesting results with types manipulations. For instance the type \(a^{b+c}\) can be written as

Either b c -> a

for the function we should have both functions b -> a and c -> a. I.e. the code is equivalent to the following one

(b -> a, c -> a)

These transformations correspond to the following simple algebraic equation \[a^{b+c} = a^b a^c.\] This is also called as type algebra.

C++ does not provide a clean standard type that plays the role of an Initial object in our simplified category of types and functions. The type void is close to the idea of an empty type, but it cannot be used as an ordinary function argument type, so it does not provide morphisms void -> A in the same way as Void does in Hask category.

If we work in a restricted fragment, we can introduce an uninhabited wrapper type and use it as an approximation:

struct Void {
  Void() = delete;
};

Since no value of Void can be constructed, every pure total function from Void to another type is extensionally the same.

C++ 17 introduced a special type that keeps only one value - std::monostate:

namespace std {
  struct monostate {};
}

The Product in C++ category keeps a pair and the constructor defined as follows

namespace std {
  template< class A, class B > struct pair {
    A first;
    B second;
  };
}

There is a simple usage example

  std::pair<int, bool> p(0, false);

  std::cout << "First projector: " << p.first << std::endl;
  std::cout << "Second projector: " << p.second << std::endl;

Really any struct or class can be considered as a product.

If we consider Objects as types then Sum is an object that can be either one or another type. The corresponding C/C++ construction that provides an ability to keep one of two types is union.

C++17 suggests std::variant as a safe replacement for union. The example of the factor function is below

    template <typename A, typename B, typename C, typename D>
    auto factor(A f, B g, const std::variant<C, D>& either) {
      try {
        return f(std::get<C>(either));               
      }
      catch(...) {
        return g(std::get<D>(either));                              
      }
    };

The simple usage as follows:

    auto stringLength = [](std::string s) {
      return static_cast<int>(s.size()); };
    auto id = [](auto x) { return x; };

    std::variant<std::string, int> var = std::string("abc");
    std::cout << "String length:" <<
    factor<>(stringLength, id, var) << std::endl;
    var = 4;
    std::cout << "id(int):" <<
    factor<>(stringLength, id, var) << std::endl;    

We used a same trick as for Initial object in Hask category and define Initial object in Scala category as a type without values:

Nothing

i.e. you cannot construct a value of the type. There is only one function from the initial object:

def absurd[A](value: Nothing): A = value

We used a same trick as for Terminal object in Hask category and define Terminal object in Scala category as a type with only one value

abstract final class Unit extends AnyVal

The only value of the type is written as follows:

val unit: Unit = ()

i.e. you can create only one element of the type.

The Product in Scala category keeps a pair. Scala has a built-in product type as follows:

val pair: (Int, Boolean) = (1, true)
val first: Int = pair._1
val second: Boolean = pair._2

The values pair._1 and pair._2 are the two projectors.

The Sum in Scala category is represented by Either. It keeps a value of the left type or a value of the right type:

val left: Either[String, Int] = Left("abc")
val right: Either[String, Int] = Right(4)

The universal property of the sum can be written as the following factor function:

def factor[A, B, C](f: A => C, g: B => C)
                   (either: Either[A, B]): C =
  either match {
    case Left(a) => f(a)
    case Right(b) => g(b)
  }

If we have functions from both alternatives to the same result type, then factor gives us a unique function from Either[A, B] to that result type.

we shall use a Hilbert space of dimension 0 as the Initial object. For every finite dimensional Hilbert space \(\mathcal{A}\) there is exactly one linear map \(\mathcal{H}_0 \to \mathcal{A}\). It sends the only vector of \(\mathcal{H}_0\) to the zero vector of \(\mathcal{A}\).

we shall use a Hilbert space of dimension 0 as the Terminal object. For every finite dimensional Hilbert space \(\mathcal{A}\) there is exactly one linear map \(\mathcal{A} \to \mathcal{H}_0\). It maps every vector from \(\mathcal{A}\) to the zero vector of \(\mathcal{H}_0\).

The Product in FdHilb category is a Direct sum of Hilbert spaces.

The Sum in FdHilb category is a Direct sum of Hilbert spaces.

Let \(\mathcal{A}\) and \(\mathcal{B}\) be finite dimensional Hilbert spaces. The same object \(\mathcal{A} \oplus \mathcal{B}\) is both the Product and the Sum in FdHilb category.

For the product structure we use the projections \[\pi_{\mathcal{A}}(a \oplus b) = a\] and \[\pi_{\mathcal{B}}(a \oplus b) = b.\] For the sum structure we use the injections \[i_{\mathcal{A}}(a) = a \oplus 0_{\mathcal{B}}\] and \[i_{\mathcal{B}}(b) = 0_{\mathcal{A}} \oplus b.\] The projections satisfy the universal property of the product, and the injections satisfy the universal property of the sum. Thus in \(\mathbf{FdHilb}\) the categorical product and the categorical sum coincide up to canonical isomorphism.

It is worth noting that the tensor product is the usual construction for compound quantum systems, but it is not the categorical product in FdHilb category. The categorical product is the direct sum above.