How TypeScript Types Mirror Set Theory: A Deep Dive into Type Assignability

“In TypeScript, it’s better to think of a type as a set of values that share something in common. Because types are just sets, a particular value can belong to many sets at the same time.” – TypeScript official documentation

Introduction

Different data types have different operations. For example, a number can be used in arithmetic, while an object can be indexed. To prevent runtime errors, programming languages need a type system that performs checks and conversions at compile‑time or run‑time.

JavaScript is a weak, dynamic language with eight primitive types: number, boolean, string, object, bigint, symbol, undefined, and null. Variables are not bound to a specific type until execution.

TypeScript (TS) is a superset of JavaScript that adds static type checking. It includes all JavaScript types and adds tuples, interfaces, enums, generics, and advanced type operations, making its type system far more complex.

Set Theory in High‑School Mathematics

A set is a collection of distinct elements. Common notations include listing elements with {}, describing them with a predicate, or drawing Venn diagrams.

Typical sets: the set of all real numbers R, natural numbers N, rational numbers Q, and the empty set ∅.

Relations between sets include subset ( A ⊆ B), superset, equality, intersection, union, and complement. These operations obey familiar laws such as idempotent, commutative, associative, and distributive laws.

Mapping TS Concepts to Sets

In set theory, a type is a set of possible values. For example, the number type is the set of all numeric values, string is the set of all strings, and boolean contains only true and false. The undefined and null types each contain a single element.

Assignments can be interpreted as subset relations: a value belonging to the source set can be assigned to a variable whose type is a superset of that set.

const name: string = "Alice"; // OK
const age: number = "Alice"; // Error: Type 'string' is not assignable to type 'number'

When assigning variables, the source variable’s type may be a broader set (e.g., a literal type 1 is a subset of number), while an {} type is a minimal object type that cannot be assigned to number.

const num = 1;
const num1: number = num; // OK
const num2: {} = num1; // OK ({} is a supertype of number literals)
const num3: number = num2; // Error: '{}' is not assignable to type 'number'

Understanding never and unknown

never

represents the empty set—values that cannot exist. It is a subset of every type, so it can be assigned to any type but no type can be assigned to never.

type A = A & never; // never
type B = A | never; // A
type C = Exclude<0, 0>; // never
type D = 0 & 1; // never

unknown

is the universal set of all possible values. Every type can be assigned to unknown, but only any can be assigned from unknown.

Understanding any

any

can be assigned to and from any type, effectively disabling static checking. It behaves like a mixture of never (assignable to everything) and unknown (assignable from everything), allowing TypeScript to fall back to plain JavaScript semantics.

Understanding void

void

is the type of functions that do not return a useful value. Its only inhabitant is undefined. Unlike undefined, void is not interchangeable with other types, which is why a function returning void cannot be used in arithmetic expressions.

function noop() {
  return;
}
console.log(noop() + 'aaa'); // "undefinedaaa"

Structural Type Matching

TypeScript uses structural typing: two types are compatible if they share the same shape. An object with extra properties can be assigned to a type that requires only a subset of those properties, but missing required properties causes an error.

interface IPerson { name: string; age: number; }
const morePerson = { name: '1', age: 1, gender: 'male' };
const p1: IPerson = morePerson; // OK (extra property ignored)
const lessPerson = { name: '1' };
const p2: IPerson = lessPerson; // Error: Property 'age' is missing

Understanding TS Type Operations

Union ( |) creates the set‑theoretic union of two types, while intersection ( &) creates the intersection. For primitive types, the union expands the admissible values, and the intersection may become never when the sets are disjoint.

type StringOrNumber = string | number; // values can be string or number
type StringAndNumber = string & number; // never (no value is both)

Understanding Conditional Types

Conditional types use the extends keyword to test subset relationships: A extends B ? C : D yields C if A is a subset of B, otherwise D. When the checked type is a union, the condition distributes over each member.

type IsTwo<T> = T extends 2 ? true : false;
type R = 'a' extends string ? true : false; // true
type S = ('a' | 'b') extends number ? true : false; // false
type Res = IsTwo<1 | 2>; // boolean (distributed)

Understanding Type Assertions

Type assertions tell the compiler to treat a value as a different type without runtime checks. Asserting a value to never makes it impossible to assign any other value to that variable.

let v1 = 1 as never; // v1 has type never
// v1 = true; // Error

TS Type Gymnastics

Utility types such as Exclude and custom conditional types can be expressed with set operations. Exclude<T, U> removes the intersection of T and U from T.

type ExcludeExample = Exclude<'a' | 'b' | 'c', 'a' | 'b'>; // 'c'

Detecting never can be done by wrapping the type in a tuple and testing for subset of [never]:

type IsNever<T> = [T] extends [never] ? true : false;

Conclusion

By viewing TypeScript’s type system through the lens of set theory, we see a clear correspondence between mathematical concepts—sets, subsets, unions, intersections, complements—and TypeScript’s type operations. This perspective not only clarifies why certain assignments succeed or fail but also reveals the deep connections between programming languages, mathematics, and logic.

Final Note

Follow the “Goodme Frontend Team” public account for more practical front‑end knowledge.