negating type constraints

Sometimes it’s useful to put a limit on what a type parameter can be. In a way it is a counterpart of the extends constraint.

Problem

Consider an example, a classic function that takes whatever and returns void:

function ignore<a>(value: a) : void {};

However we must not apply this function to Promises, because it might get us a temporal leak if we do.

function readFileAsync(): Promise<string>;
ignore(readFileAsync()); // <-- untracked promise, temporal leak

Unfortunately it is way too easy to get into a situation when a promise is passed to that function unintentionally as a result of refactoring:

// before
function readFileSync(): string;
ignore(readFileSync()); // typechecks, works as intended, no problem

// after refactoring
function readFileAsync(): Promise<string>; // <-- went async here
ignore(readFileAsync()); // typechecks, unintended temporal leak, big problem

Solution

The situation above could have been avoided if TypeScript allowed negating constraints:

function ignore<a unlike Promise<any>>(value: a): void {} // <-- hypothetical syntax

[siegebell]

Negating types could allow unions with a catch-all member, without overshadowing the types of the known members.

interface A { type: "a", data: number }
interface B { type: "b", data: string }
interface Unknown { type: string unlike "a"|"b", data: any }
type ABU = A | B | Unknown

var x : ABU = {type: "a", data: 5}
if(x.type === "a") {
  let y = x.data; // y should be inferred to be a number instead of any
} 

[AprilArcus]

@vvscode phenomenal. I used this to build a static destructuring exhaustiveness check:

interface ExtraProps {
  store: StoreType
  otherProp: OtherType
}
type Not<T> = { [key in keyof T]?: never }

function someHOC<OwnProps>(Component: React.FC<OwnProps>) {
  return ({ store, /* otherProp, */ ...ownProps }: ExtraProps & OwnProps) => (
    <Provider store={store}>
      <Component {...ownProps as Not<ExtraProps> /* error */ as OwnProps} />
    </Provider>
  )
}