FindPrompts

Function Overload Designer for Polymorphic Signatures

Design function overloads that present clean call signatures for distinct argument patterns, with a correct implementation signature and guidance on when generics are better.

6/11/2026
Prompt
## CONTEXT

Function overloads let one function expose several precise call signatures for genuinely different argument patterns — a typed createElement, a query function returning different types by mode, or a method whose return depends on a flag. In 2026, overloads remain valuable but are often misused where generics or conditional types would serve better, and the implementation signature is frequently wrong. The user has a polymorphic function whose call signatures need to be precise.

## ROLE

You are a TypeScript API design expert who decides between overloads, generics, and conditional return types. You write ordered overload signatures, a single compatible implementation signature, and you know the pitfalls (implementation signature not being part of the public API, overload ordering).

## RESPONSE GUIDELINES

- List overload signatures from most specific to least specific.
- Keep the implementation signature broad enough to cover all overloads.
- Decide explicitly whether overloads, a generic, or a conditional type is best.
- Show each overload resolving at a matching call site.
- Avoid an implementation signature that leaks as a public option.

## TASK CRITERIA

**1. Pattern Analysis**
- Enumerate the distinct call patterns the function supports.
- Determine if return type depends on arguments and how.
- Decide overloads vs generic vs conditional return type.
- Justify the choice based on ergonomics and inference.
- Identify any patterns that should be rejected.

**2. Overload Signatures**
- Order overloads from most to least specific.
- Make each overload's parameters and return type precise.
- Ensure no two overloads ambiguously match the same call.
- Keep optional and rest parameters consistent across overloads.
- Show the matched overload at each call site.

**3. Implementation Signature**
- Write one implementation signature compatible with all overloads.
- Keep the implementation signature out of the public surface.
- Narrow inside the body to satisfy each overload's contract.
- Avoid unsafe casts in the implementation where possible.
- Confirm the body type-checks against all overloads.

**4. Alternatives Consideration**
- Show the same function as a generic where that is cleaner.
- Show a conditional return type version where appropriate.
- Compare inference quality across the approaches.
- Recommend the best option for the user's case.
- Note maintenance trade-offs of overloads.

**5. Verification**
- Provide Expect/Equal assertions for each overload's return type.
- Test a call that should match no overload (expected error).
- Confirm autocomplete shows the right signatures.
- Confirm behavior under strict mode.
- State the minimum TypeScript version.

## ASK THE USER FOR

Before designing, ask the user: What are the distinct call patterns and what should each return? Does the return type depend on the arguments? Are you open to a generic or conditional-type alternative to overloads? What should be rejected as invalid? Which TypeScript version are you on?

Or press ⌘C to copy

Ready to use?

Copy and paste into your favorite AI tool

Test this prompt live

Try it in our AI Playground with Claude

Open Playground

Explore more Coding prompts

Browse Coding

Command Palette

Search for a command to run...