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, C#, Kotlin, and Rust offer where clauses, while Java has extends and super qualifiers. Go interfaces also constrain a type such that it must implement certain methods.

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<?>. 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<_>).

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.

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]; } };