Type Systems and Generics Across Programming Languages Cheat Sheet

Updated 2026-05-16

🧠Study flashcards on this topic70 cards · spaced repetition→

Type systems define the rules that govern how values of different types can be used in a programming language, ranging from dynamic runtime checks to static compile-time guarantees. They encompass static vs dynamic typing, structural vs nominal typing, generics and parametric polymorphism, and advanced features like covariance/contravariance, algebraic data types, and type inference. Understanding type systems helps developers write safer, more maintainable code by catching errors early, enabling powerful abstraction patterns, and choosing the right type system trade-offs for their specific problem domain—whether that's the flexibility of gradual typing, the safety of dependent types, or the performance of compile-time type erasure.

What This Cheat Sheet Covers

This topic spans 13 focused tables and 74 indexed concepts, 70 flashcards. Below is a complete table-by-table outline of this topic, spanning foundational concepts through advanced details.

Table 1: Static vs Dynamic Typing FundamentalsTable 2: Structural vs Nominal TypingTable 3: Generics and Parametric PolymorphismTable 4: Type Inference MechanismsTable 5: Union and Intersection TypesTable 6: Type Narrowing and GuardsTable 7: Covariance and Contravariance in DepthTable 8: Generics Implementation StrategiesTable 9: Advanced Type FeaturesTable 10: Type Aliases and Nominal AbstractionsTable 11: TypeScript-Specific Type FeaturesTable 12: Runtime Type InformationTable 13: Practical Type System Patterns

Quick IndexSubscribe to unlock

A jump-to index of every table row in this cheat sheet.

Mind MapSubscribe to unlock

An interactive map of every table and concept in this topic.

Table 1: Static vs Dynamic Typing Fundamentals

The vocabulary in this table is the bedrock of every type-system debate—and the words are easy to confuse. Static versus dynamic is about when types are checked (compile time or runtime), while strong versus weak is about how strictly the rules are enforced; the two axes are independent, which is why Python is dynamic-but-strong and C is static-but-weak. Gradual typing and soundness round out the picture.

Classification	Example	Description
Static typing	`int x = 42;` `String s = "hello";`	• Types are checked at compile time before execution • the compiler catches type-related errors early, leading to more reliable code
Dynamic typing	`x = 42` `x = "hello"`	• Types are checked at runtime during execution • variables can hold values of different types at different times, offering flexibility but detecting errors later
Type annotations	`let age: number = 25;` `def greet(name: str) -> str:`	• Explicit type declarations added to code • required in some statically-typed languages, optional in gradually-typed languages like TypeScript and Python (mypy).
Type inference	`let x = 42;` `val y = "text"`	• Compiler automatically deduces types from context without explicit annotations • common in ML, Haskell, Scala, Rust, and TypeScript
Gradual typing	`function f(x: any): number` `def process(data): ...`	• Combines static and dynamic typing, allowing mixed type checking • enables incremental adoption of static types in dynamic languages (TypeScript, Python with mypy).
Strong typing	Python: `"5" + 3` → error Java: `int + String` → error	• Strict enforcement of type rules with minimal implicit conversions • type mismatches are caught and reported as errors
Weak typing	JS: `"5" + 3` → `"53"` C: `int* p = 0; *p;`	• Permissive type system allowing implicit conversions between types • can lead to unexpected behavior but offers flexibility
Type soundness	Rust: no null pointer dereferences Haskell: no runtime type errors	• A sound type system guarantees that well-typed programs cannot cause certain runtime errors • "well-typed programs don't go wrong."

Table 2: Structural vs Nominal Typing

When are two types "the same"? Structural typing says yes if their shapes match (TypeScript, Go), nominal typing demands the same declared name or explicit relationship (Java, C#, Swift), and duck typing pushes that shape check all the way to runtime. Branded types are the clever escape hatch for getting nominal safety inside a structural language.

Approach	Example	Description
Structural typing	`type Point = { x: number; y: number }` `let p: Point = { x: 1, y: 2 }`	• Types are compatible based on their structure or shape • if two types have the same properties, they're interchangeable (TypeScript, Go, OCaml).

The rest of this section is part of the full cheat sheet

Table 3: Generics and Parametric Polymorphism

Generics let you write a container or function once and reuse it across types without sacrificing type safety—the List<T> you reach for daily. The harder half of this table is variance: the rules deciding whether a List<Dog> can stand in for a List<Animal>. The producer-consumer mental model (covariance for things you read out, contravariance for things you write in) is the key that makes Java's wildcards and Kotlin's in/out finally click.

Concept	Example	Description
Generics (type parameters)	`List<T>` `function identity<T>(x: T): T`	• Allow types to be parameterized by other types, enabling code reuse while maintaining type safety • also called parametric polymorphism

The rest of this section is part of the full cheat sheet

Table 4: Type Inference Mechanisms

Type inference is what lets you write let x = 42 and still get full static checking—the compiler figures out the types you didn't spell. These entries are the theory underneath that convenience: Hindley-Milner's complete inference for the ML family, the unification algorithm at its core, and the more pragmatic local and bidirectional schemes that mainstream languages use to balance power against decidability.

Mechanism	Example	Description
Hindley-Milner (Algorithm W)	OCaml: `let f x = x + 1` Haskell: `map :: (a -> b) -> [a] -> [b]`	• Complete type inference for parametric polymorphism without annotations • produces the most general (principal) type for expressions (ML family, Haskell).

The rest of this section is part of the full cheat sheet

Table 1: Static vs Dynamic Typing Fundamentals

Classification	Example	Description
Static typing	`int x = 42;` `String s = "hello";`	• Types are checked at compile time before execution • the compiler catches type-related errors early, leading to more reliable code
Dynamic typing	`x = 42` `x = "hello"`	• Types are checked at runtime during execution • variables can hold values of different types at different times, offering flexibility but detecting errors later
Type annotations	`let age: number = 25;` `def greet(name: str) -> str:`	• Explicit type declarations added to code • required in some statically-typed languages, optional in gradually-typed languages like TypeScript and Python (mypy).
Type inference	`let x = 42;` `val y = "text"`	• Compiler automatically deduces types from context without explicit annotations • common in ML, Haskell, Scala, Rust, and TypeScript
Gradual typing	`function f(x: any): number` `def process(data): ...`	• Combines static and dynamic typing, allowing mixed type checking • enables incremental adoption of static types in dynamic languages (TypeScript, Python with mypy).
Strong typing	Python: `"5" + 3` → error Java: `int + String` → error	• Strict enforcement of type rules with minimal implicit conversions • type mismatches are caught and reported as errors
Weak typing	JS: `"5" + 3` → `"53"` C: `int* p = 0; *p;`	• Permissive type system allowing implicit conversions between types • can lead to unexpected behavior but offers flexibility
Type soundness	Rust: no null pointer dereferences Haskell: no runtime type errors	• A sound type system guarantees that well-typed programs cannot cause certain runtime errors • "well-typed programs don't go wrong."

Table 2: Structural vs Nominal Typing

Approach	Example	Description
Structural typing	`type Point = { x: number; y: number }` `let p: Point = { x: 1, y: 2 }`	• Types are compatible based on their structure or shape • if two types have the same properties, they're interchangeable (TypeScript, Go, OCaml).

Table 3: Generics and Parametric Polymorphism

Concept	Example	Description
Generics (type parameters)	`List<T>` `function identity<T>(x: T): T`	• Allow types to be parameterized by other types, enabling code reuse while maintaining type safety • also called parametric polymorphism

Table 4: Type Inference Mechanisms

Mechanism	Example	Description
Hindley-Milner (Algorithm W)	OCaml: `let f x = x + 1` Haskell: `map :: (a -> b) -> [a] -> [b]`	• Complete type inference for parametric polymorphism without annotations • produces the most general (principal) type for expressions (ML family, Haskell).