How many values of this type?

Background

The number of values for a given type is called the cardinality of that type, and that of type T is written as |T|.

Haskell and a few other languages have a certain set of enum types, each of which has a small finite number of values (the exact names vary, so this challenge uses some arbitrarily chosen names).

Name  | Cardinality
------+-------------
Never | 0
Unit  | 1
Bool  | 2 (true or false)
Order | 3 (LT, EQ, or GT)

And they also have some derived types which have one or more type parameters. Their cardinality depends on which types they get as parameters (written as T and U in the table below). Func(T,U) represents the function commonly written as T -> U, i.e. a function that takes a parameter of type T and returns a value of type U.

Name(Params) | Cardinality
-------------+-------------
Option(T)    | |T| + 1     (some value from T, or absence)
Either(T,U)  | |T| + |U|   (some value from T or some value from U)
Pair(T,U)    | |T| * |U|   (any combination of values from T and U)
Func(T,U)    | |U| ** |T|  (any combination of U for every value of T)

Note: A "function" here is to be understood as a mathematical concept rather than a programming one. A mathematical function Func(T,U) maps every possible value of T to some value of U, disregarding the "how". For programmers, it is OK to think of it as functions of the form of (in Haskell-like pseudocode):

Try it online!