Generic Defaults & Inference

Generic defaults give a type parameter a fallback ( <T = string> ) when none is provided, while type inference lets TypeScript figure out a generic's type from the arguments you pass — so you rarely write the angle brackets yourself.

Learn Generic Defaults & Inference in our free TypeScript course — an interactive lesson with runnable examples, a practice exercise and a quick reference.

Part of the free TypeScript course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

What You'll Learn

💡 Real-World Analogy

Think of a coffee order. Inference is the barista guessing your milk from what you usually get — you don't say it, they just know. A default is the house standard when you don't specify ("regular oat milk unless you say otherwise"). And a const type parameter is the barista writing down your exact order word-for-word ("extra-hot, half-shot") instead of rounding it to "a coffee" — the precise details are kept.

1. Default Type Parameters

You can give a generic a default with <T = SomeType> . If the caller neither supplies T nor gives the compiler something to infer it from, T falls back to that default. Defaults shine on generic interfaces and classes — like ApiResponse<TData = unknown> — so simple callers don't have to spell out a type argument.

2. How Inference Works (and When to Annotate)

Most of the time you never write <...> — TypeScript infers the type argument from the value you pass. identity("hi") infers T = string ; first([true, false]) infers the element type. You must annotate only when there's nothing to infer from — for example a function that returns T[] but takes no T argument.

3. const Type Parameters & Widening

By default, inference widens literals: pass ["red", "green"] and you get string[] , losing the exact values. A const type parameter ( <const T> , TypeScript 5.0) tells the compiler to keep the narrowest literal type — the precise tuple — without scattering as const across every call.

🎯 Your Turn

Mirror a generic default using a default parameter : greet() with no argument should fall back to "guest" . Fill in the two blanks marked ___ , then run it.

Common Errors (and the fix)

• ❌ "Type 'unknown' is not assignable..." — a generic had no argument to infer from. ✅ Annotate the call: make<number>() , or restructure so T can be inferred.
• ❌ Inferred type is too wide ( string instead of "red" ) — inference widened literals. ✅ Use a <const T> type parameter, or as const at the call site.
• ❌ "Type parameter 'T' has a circular default" — a default referenced itself. ✅ Make the default a concrete type, not one that depends on T in a loop.
• ❌ Default placed before a non-default parameter — <T = string, U> is invalid. ✅ Defaulted type parameters must come after required ones, just like function args.

Pro Tips

• 💡 Let inference do the work. Writing explicit type arguments everywhere is usually a sign the API could be designed to infer them.
• 💡 Add a sensible default (often unknown ) to generic interfaces so simple consumers can skip the type argument.
• 💡 Reach for <const T> in builder/config helpers where you want literal keys and values preserved.
• 💡 Constrain and default together : <T extends object = {}> gives both a bound and a fallback.

📚 Keep Learning

• 📖 TypeScript Handbook — Generics
• 📖 TS 5.0 Release Notes — const Type Parameters
• 📖 Handbook — Type Inference

Frequently Asked Questions

Mini-Challenge: A wrap() Helper

No blanks this time — just a brief and a starting outline. Build the helper yourself, run it, and check your output against the example in the comments.

🎉 Lesson Complete

• ✅ <T = string> gives a type parameter a default fallback
• ✅ TypeScript infers type arguments from the values you pass
• ✅ You only annotate when there's nothing to infer from
• ✅ Inference widens literals to general types by default
• ✅ <const T> (TS 5.0) keeps the narrow literal types without as const
• ✅ Next lesson: Function Types, this , Parameters & ReturnType

Practice quiz

Continue this course

• Previous: DOM & Event Types
• Next: Function Types & this

Related lessons

• Generics
• Literal Types & const Assertions