TypesScript 1.8 introduced the concept of type parameters as constraints, also known as F-Bounded Polymorphism.
But what does type parameters as constraints really mean? To answer that question we first need to understand what a type parameter is.
What is a Type Parameter?
A Type Parameter is a placeholder for a type. They're used with generics and allow you to defer the decision of choosing a type. The actual type is provided when the generic type is used.
Consider the following custom type that uses a type parameter:
type myType<T> = T;
Here we've defined a new type called
myType that uses a type parameter called
T. When we use this type we will define what the type parameter
let count: myType<number>;
count = 1; // This is OK.
count = ''; // Error, number expected
In the above code we create a new
count variable of type
myType<number>. Comparing the usage of
myType to it's definition, we can see that we've specified that the generic type
number. This means the type of
count is number, because that's exactly what our
type myType<T> = T;
When we passed
number we basically wrote:
type myType<number> = number
Which basically boils down to:
type myType = number
which is the same as using the
number type directly.
Type Parameters as Constraints
Now we know what a type parameter is we can use this knowledge to help us understand what type parameters as constraints actually means.
From my understanding, this simply means that the type parameter can be used a type parameter constraint, that is, it can be used to constrain the type passed in as a parameter to the same type as the type parameter. This is easier to understand with a code snippet:
type funcType<T> = (a: T) => T;
The above snippet defines a new function type called
funcType. This type utilises the type parameters as constraints feature - it constrains the type of the argument
a to the type of
T is a number, then argument
a must be a number too.
const myFunc: funcType<number> = a => a;
myFunc(1) // This is OK.
myFunc(true) // Error, expected number.
The term type parameters as constraints wasn't intuitive to me. I wrote this article to help me understand what this term actually means. As we discovered, type parameters as constraints basically means we can constrain the type of a function argument to the same type as the provided type parameter. As long as you understand that a type parameter is used to defer the decision of a type for generics, the description previously provided should make sense.