Genericity on OOFP 2025-26

Type variable

Mon, 01 Jan 0001 00:00:00 +0000

Type variable #

A type variable stands for an underspecified type.

Example. Consider a function half that maps a list to its first half (say rounded down if the list has odd length).

The implementation of this function is identical for:

a list of strings,

a list of integers,

a list of Boolean values,

etc.

A type variable lets us declare such a function

in Haskell:
half :: [a] -> [a]    -- `a` is a type variable here
or in Java:
/* will be revealed later */

In Haskell #

Syntax. In Haskell, a type variable starts with a lowercase letter (like a regular variable).

Bound

Mon, 01 Jan 0001 00:00:00 +0000

Bound #

In some scenarios, a regular type variable may be too generic.

Example. We may want to write an algorithm where the input can have any numeric type (integer, float, etc.).

A type variable in this case is too generic, because it can also stand for a non-numeric type (e.g. string, Boolean value, a function type, etc.).

In Haskell #

Example. The following function does not compile, because the operation + is not defined for arbitrary types.

Generic type

Mon, 01 Jan 0001 00:00:00 +0000

Generic type #

In Haskell #

Syntax #

We have already seen how to define a product type or a sum type.

Example. As we have seen earlier, the type of lists of integers can be defined as follows:
data IntList = Nil | Cons Int IntList
Similarly, the type of lists of Booleans can be defined as
data BoolList = Nil | Cons Bool BoolList
To make this more generic, we can use a type variable instead of the concrete type (Int or Bool here).

Option type

Mon, 01 Jan 0001 00:00:00 +0000

Option type #

We introduce an important generic sum type, available in many languages, under a variety of names (Maybe, Option, optional, Optional, Nullable, etc.)

We will see in the dedicated sections that such a type can also be made a functor, and (perhaps most importantly) a monad. For now, we will use it without these extra features.

Motivation #

Problem. A programming language may not have a type that exactly fits the domain of a function that we want to implement.