Never Type
Never
Programming language design does have a concept of bottom type that is a natural outcome as soon as you do code flow analysis. TypeScript does code flow analysis (😎) and so it needs to reliably represent stuff that might never happen.
The never
type is used in TypeScript to denote this bottom type. Cases when it occurs naturally:
A function never returns (e.g. if the function body has
while(true){}
)A function always throws (e.g. in
function foo(){throw new Error('Not Implemented')}
the return type offoo
isnever
)
Of course you can use this annotation yourself as well
However, only never
can be assigned to another never. e.g.
Great. Now let's just jump into its key use case :)
Use case: Exhaustive Checks
You can call never functions in a never context.
And because never
is only assignable to another never
you can use it for compile time exhaustive checks as well. This is covered in the discriminated union section.
Confusion with void
void
As soon as someone tells you that never
is returned when a function never exits gracefully you intuitively want to think of it as the same as void
. However, void
is a Unit. never
is a falsum.
A function that returns nothing returns a Unit void
. However, a function that never returns (or always throws) returns never
. void
is something that can be assigned (without strictNullChecking
) but never
can never be assigned to anything other than never
.
Type inference in never returning functions
For function declarations TypeScript infers void
by default as shown below:
Of course you can fix it by an explict annotation:
Key reason is backword compatability with real world JavaScript code:
If Base.overrideMe
.
Real world TypeScript can overcome this with
abstract
functions but this inferrence is maintained for compatability.
Last updated