Inline Generics OR Expressing polymorphic relationships in interfaces with conditional types

Search Terms

inferring generics in interfaces like in functions, inferring generics in interfaces

Suggestion

Functions in TypeScript can properly infer the type of generics without explicitly stating them.

Given the types

type Foo = "foo"
type Bar = "bar"
type FooBar = Foo | Bar;
type IfFooThenBar<T extends FooBar> = T extends Foo ? Bar :
  T extends Bar ? Foo : never;

The function

ifFooThenBar<T extends FooBar>(fooOrBar: T, barOrFoo: IfFooThenBar<T>): void

will: a) properly autosuggest available values, b) fail with if called with ifFooThenBar("foo", "foo")

I think it would be beneficial if interfaces would support this behavior, too. Given an interface

interface IIfFooThenBar<T extends FooBar> {
  fooOrBar: T
  barOrFoo: IfFooThenBar<T>
}

which would support inferring. you could implement it as

const fooConfig: IIfFooThenBar = {
  fooOrBar: "foo"  // this value would be checked
  barOrFoo: "foo" // and this would break
}

Use Cases

• Interfaces where you don’t want propagate a Generic to you topmost implementer
• Interfaces where you want to model a polymorphic relationship between keys

Examples

type Foo = "foo"
type Bar = "bar"
type FooBar = Foo | Bar;
type IfFooThenBar<T extends FooBar> = T extends Foo ? Bar :
  T extends Bar ? Foo : never;

// As inline type
interface IfFooThenBar {
  fooOrBar: T extends FooBar 
  barOrFoo: IfFooThenBar<T>
}

// As multiple inline types
interface IfFooThenBar {
  fooOrBar1: A extends FooBar 
  barOrFoo1: IfFooThenBar<A>
  fooOrBar2: B extends FooBar
  barOrFoo2 : IfFooThenBar<B>
}

// As inline type with "global" Generic
interface IfFooThenBar<A extends FooBar> {
  fooOrBar: T extends FooBar 
  barOrFoo : IfFooThenBar<T>
  globalFooOrBar: A
}

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.

[AnyhowStep]

type Concrete = Distribute<FooBar>;

//Becomes
type Concrete = IIfFooThenBar<Foo> | IIfFooThenBar<Bar>;

//Becomes
type Concrete = { fooOrBar : Foo, barOrFoo : Bar } | { fooOrBar : Bar, barOrFoo : Foo };

//Becomes
type Concrete = { fooOrBar : "foo", barOrFoo : "bar" } | { fooOrBar : "bar", barOrFoo : "foo" };

[RyanCavanaugh]

This is too complex for something you can already do:

type Foo = "foo"
type Bar = "bar"
type FooBar = Foo | Bar;
type IfFooThenBar<T extends FooBar> = T extends Foo ? Bar :
	T extends Bar ? Foo : never;
  
interface IIfFooThenBar<T extends FooBar> {
  fooOrBar: T
  barOrFoo: IfFooThenBar<T>
}

type Distribute<T extends FooBar> = T extends T ? IIfFooThenBar<T> : never;
type Concrete = Distribute<FooBar>;

// OK
const fooConfig: Concrete = {
  fooOrBar: "foo",
  barOrFoo: "bar"
}

// Error
const barConfig: Concrete = {
  fooOrBar: "bar",  // this value would be checked
  barOrFoo: "bar" // and this would break
}