GeezerVison

In type theory and programming languages, a type variable is a mathematical variable ranging over types. Even in programming languages that allow mutable variables, a type variable remains an abstraction, in the sense that it does not correspond to some memory locations.

Programming languages that support parametric polymorphism make use of universally quantified type variables. Languages that support existential types make use of existentially quantified type variables. For example, the following OCaml code defines a polymorphic identity function that has a universally quantified type, which is printed by the interpreter on the second line:

# let id x = x;;
val id : 'a -> 'a = <fun>

In mathematical notation, the type of the function id is $\forall a.a\to a$, where $a$ is a type variable.

In generic programming, a type parameter or template parameter is used to denote the type(s) that may be consumed. These type parameters are placeholders for types to be specified later, allowing for code to work with different types while remaining type-safe. Type parameters are typically written as a single capital letter.

interface List<E> {
    void add(E x);
    Iterator<E> iterator();
}

interface Map<K, V> {
    V put(K key, V value);
    V get(Object key);
}

In C++, template parameters must be declared with the typename (or class) keyword.

In some languages, these can be specified to have default type parameters. For example, in C++:

template <typename T = int>
class Box {
private:
    T value;
public:
    explicit Box(T value):
        value{value} {}

    // ...
};

Box<double> b1(13.5);
Box<> b2(5); // This is Box<int>

Some languages additionally offer a form of constraining these type parameters, called type classes. C++ offers concepts and requires clauses,^[1] C#, Kotlin, and Rust offer where clauses,^[2][3] while Java has extends and super qualifiers. Go interfaces also constrain a type such that it must implement certain methods.^[4]

using System;

public class MyGenericClass<T, U> 
    where T : IComparable<T>, allows ref struct
    where U : class, notnull, new()
{
    // ...
}

Additionally, Java offers wildcard type parameters to allow for variances of any parametrisations of a generic type. These are denoted ?, for example List<?>.^[5] This exists in Kotlin as well, but denoted with * instead. In Rust, a generic type parameter can be left unspecified for the compiler to interpret using _, called an "inferred type" (for example Vec<_>).^[6]

In languages with dynamic typing, although type annotations may not be a core part of the language, some features may be provided to emulate them. For example, in Python, type variables can still be represented and specified using the class typing.TypeVar.^[7]

from typing import TypeVar

T: TypeVar = TypeVar('T')

def first_item(items: list[T]) -> T:
    return items[0]

In C++ and Rust and others with intricate template metaprogramming, template parameters may be non-types as well.

using std::array;

template <typename T, size_t M, size_t N>
class Matrix {
private:
    array<array<T, N>, M> data;
public:
    Matrix() = default;

    template <typename Self>
    constexpr auto&& operator[](this Self&& self, size_t row, size_t col) {
        return std::forward<Self>(self).data[row][col];
    }   
};

• Type class
• Generic programming
• Template (C++)
• Generics in Java
• Template metaprogramming
• System F