Suggestion: Upper-bound generic type constraints

This is a proposal for generic structural supertype constraints.

I’ll first detail the proposal, and then get into a discussion about use-cases.

Proposal

A supertype constraint is a constraint on a generic type parameter to be the structural supertype of another type. It’s like a subtype/inheritance constraint, but from the other direction. For example, let’s say we have a square:

interface Square {width : number; height : number}

In this suggested syntax, you could write:

performAction<T extended by Square>(partialSquare : T) {}

This means the type T must be a structural supertype of square. So the potential candidates for T are:

{width : number}, {height : number}, Square, {}

It’s an established kind of type constraint, not something I just made up. Although it’s not exactly common, some languages do implement this feature, such as Scala. In Scala, you can write:

def performAction[T >: Square](obj : T) = { ... }

To express a supertype/upper bound constraint. In this case, of course, the constraint isn’t structural – T must declare that it implements Square.

Utility

In most languages, including Scala, this kind of constraint isn’t very useful. It only comes up in certain specific situations.

However, Javascript libraries often have this kind of API, where you’re allowed to specify the partial properties of an object to modify it (the rest remain at their previous value).

In many cases, you can support this by having optional interface members, but isn’t always possible or correct.

An important example is React, which defines a method called setState:

class Component {
    var state;

    setState(partialState) {
        //merges the properties of partialState with the current state.
    }
}

The right signature for this method should be:

class Component<Props, State> {
    setState<PartialState extended by State>(partialState : PartialState) {
        //merges the properties of partialState with the current state.
    }
}

Currently,the definition files state that it is:

setState(fullState : State) {
    //merges the properties of partialState with the current state.
}

Which doesn’t fully capture the functionality of the method.

Notes

The suggested syntax doesn’t give us a nice way of combining both subtype and supertype constraints. One possibility is:

exampleMethod<T extends LowerBound and extended by UpperBound>

[timsuchanek]

@GregRos this is an interesting idea and I also think the language would benefit from such a keyword.

As a workaround you can set an upper boundary in the param using a helper type:

type Full = {
  a: string
  b?: string
}

/**
 * Subset
 * @desc From `T` pick properties that exist in `U`
 */
type Subset<T, U> = { [key in keyof T]: key extends keyof U ? T[key] : never }

function acceptFullAndMore<T extends Full>(param: T): T {
  return param
}

acceptFullAndMore({a: '', c: 1}) // Compiler allows `c`, even if it's not part of `Full`

function acceptFull<T extends Full>(param: Subset<T, Full>): T {
  return param
}

acceptFull({a: '', c: 1}) // Compiler throws here 🙏

[mhegazy]

this should be covered by https://github.com/Microsoft/TypeScript/issues/11233 (and #4889).