Typescript strange behavior

Question

function foo(a: number, b: number) {
  return a + b;
}

type Foo1 = typeof foo extends (...args: unknown[]) => unknown ? true : false; // false
type Foo2 = typeof foo extends (...args: any[]) => unknown ? true : false; // true

Why does it works with any[], but does not with unknown[]?

It works with tuples and ReturnTypes, but not with rest parameters.

type Foo = ['bar', 'baz'] extends unknown[] ? true : false; // true

Function parameters are contravariant. While `[number, number]` does extend `unknown[]`, the opposite has to be true for function parameters. So this fails because `unknown[]` does not extend `[number, number]`. Check out [this answer](https://stackoverflow.com/questions/66410115/difference-between-variance-covariance-contravariance-and-bivariance-in-typesc) — Tobias S., Jul 10 '22 at 19:05

jh316 · Answer 1 · 2022-07-10T19:47:06.753

0

Edit: Read comment on original post, the following is a mistaken answer based on incorrect knowledge I had of Typescript.

This is because of the type restrictions on using a value assigned to a unknown type. For example, variables of the number type can be assigned values from variables of the any type, but cannot be assigned values from variables of the unknown type.

E.g.

let value:any = 5;
let value2:unknown = 6;

let b:number = value;
let c:number = value2;

Will let b compile, but not c, giving an error "Type 'unknown' is not assignable to type 'number'."

edited Jul 10 '22 at 19:47

answered Jul 10 '22 at 18:43

jh316

901
7
9

But it works with `ReturnType`. And with tuples. `type Foo = ['bar', 'baz'] extends unknown[] ? true : false; // true` – Alexey Perestoronin Jul 10 '22 at 18:52

score 0 · Answer 2 · answered Jul 10 '22 at 20:28

Function comparison in TS is, perhaps, unexpectedly complicated (or at least unintuitive), and the handbook has a section specifically about this.

In the example code you've shown, you've run into the issue of function parameter bivariance. To work around this: instead of comparing the entire function, you can compare its parameters and return type in isolation to those of the other function in question. Consider the following:

In a comment to your question, Tobias S. mentioned another answer which explains different types of variance in more detail.

TS Playground

type Fn<Params extends readonly any[] = readonly any[], Result = any> =
  (...params: Params) => Result;

type FnAExtendsFnB<FnA extends Fn, FnB extends Fn> =
  Parameters<FnA> extends Parameters<FnB>
    ? ReturnType<FnA> extends ReturnType<FnB>
      ? true
      : false
    : false;

type AExtendsB<A, B> = A extends B ? true : false;

// The function from your question:
type Foo = Fn<[a: number, b: number], number>;

type UnknownParamsUnknownResult = Fn<unknown[], unknown>;
type AnyParamsUnknownResult = Fn<any[], unknown>;

declare const T1: AExtendsB<Foo, UnknownParamsUnknownResult>; // false

declare const T2: AExtendsB<Foo, AnyParamsUnknownResult>; // true

declare const T3: FnAExtendsFnB<Foo, UnknownParamsUnknownResult>; // true

declare const T4: FnAExtendsFnB<Foo, UnknownParamsUnknownResult>; // true

Typescript strange behavior

2 Answers2