Type Systems and Generics Across Programming Languages Cheat Sheet

Updated 2026-05-16

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. 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

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

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