Course contentsShow
← Computer Science
Lesson 2007 of 2,87245. Type Systems and SemanticsFree lesson

What is Type Inference?

Understanding automatic type determination by the compiler without explicit annotations.

What is Type Inference?

You'll learn: How compilers can deduce types automatically, saving you from writing explicit type annotations everywhere.

The Core Idea

Type inference is a compiler feature that figures out the types of expressions and variables without requiring you to write them down explicitly. Instead of forcing you to annotate every variable with : int or : string, the compiler analyzes your code and determines types automatically based on context and usage.

Think of it like this: if you hand someone a pencil, they don't need you to say "this is a pencil." The object's properties make it obvious. Similarly, if you write x = 5 + 3, the compiler can infer that x must be an integer without you declaring int x.

How It Works

The compiler examines how values flow through your program:

  • From literals: y = "hello" — clearly a string
  • From operations: z = x + y — if x and y are integers, z must be too
  • From function signatures: if a function returns bool, any variable assigned that result is also bool

The type checker propagates this information throughout your code, building a complete picture of all types.

Benefits

Type inference gives you the safety of static typing (catching errors at compile time) without the verbosity of writing type annotations everywhere. Your code stays clean and readable while maintaining type soundness.

Languages like Haskell, OCaml, and modern versions of C++ and Java use type inference extensively to reduce boilerplate while preserving compile-time type checking.

Key Takeaway: Type inference allows compilers to automatically determine types from context, combining the safety of static typing with cleaner, less verbose code.