Suggestion: shorthand for templated type to extend and default to the same type

Search Terms

default extends equals generics = template types is

Suggestion

Can we have a way to declare that a templated (generic) type both extends and is = a type value without repeating the type value?

declare function example<T extends Base = Base>(value: T): T;

A clean way to do this would be to allow the is keyword following a generic type:

declare function example<T is Base>(value: T): T;

Failing that, how about omitting the first type value?

declare function example<T extends = Base>(value: T): T;

Use Cases

Generic parameters with extended and default values set to the same are a reasonable pattern:

declare function querySelector<E extends Element = Element>(selectors: string): E | null;

In larger type definitions with many generics, these extends+= definitions can get a little cumbersome:

type BitAddThree<
    A extends Bit = Bit,
    B extends Bit = Bit,
    C extends Bit = Bit
> =
    [A, B, C] extends [0, 0, 0] ? [0, 0] :
    // etc. etc.
    [Bit, Bit, Bit];

Examples

declare function querySelector<E is Element>(selectors: string): E | null;
declare function querySelector<E extends = Element>(selectors: string): E | null;

type BitAddThree<A is Bit, B is Bit, C is Bit> = // ...
type BitAddThree<A extends = Bit, B extends = Bit, C extends = Bit> = // ...

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

Start with the proposed generic declaration examples and compare the is and extends = alternatives, then trace how the TypeScript type checker handles generic constraints and defaults. Done requires a settled syntax and semantics for equivalent constraint/default declarations, with the proposal's examples covered by tests.