Почему Parameters‹Func› не расширяет unknown[] (Array‹unknown›) в строгом режиме ts

С параметром --strictFunctionTypes компилятора< /a>, параметры типа функции проверяются контравариантно. «Контравариант» означает, что отношение подтипа функции изменяется в направлении, противоположном отношению параметров функции. Так что если A extends B, то (x: B)=>void extends (x: A)=>void а не наоборот.

Это проблема безопасности типов из-за природы «заменяемости» в TypeScript, также известной как поведенческий подтип. Если A extends B истинно, вы сможете использовать A как B. Если не можете, то A extends B неверно.

Если вы отключите --strict, компилятор будет использовать поведение до TS-2.6 для проверки параметров функции бивариантно, что небезопасно, но разрешено из соображений производительности. Это может быть не по теме здесь, но вы можете прочитать больше об этом в разделе FAQ по TypeScript для "Почему параметры функции бивариантны?"

В любом случае, если вам нужен тип функции, который принимает любое количество параметров unknown, вы не можете безопасно использовать функцию, которая имеет только определенный подтип unknown. Наблюдать:

const t: testArgsF = (b, s) => (b ? s.trim() : s).length
const u: unknownArgsF = t; // error!

u(1, 2, 3); // explosion at runtime! s.trim is not a function

Если бы testArgsF extends unknownArgsF было истинным, то вы могли бы присвоить t указанному выше u без ошибок, что немедленно привело бы к ошибкам времени выполнения, когда u счастливо принимает аргумент, отличный от string секунды.

Вы видите, что единственный безопасный способ создать подтип/реализовать тип функции — это принять аргументы, которые являются такими же или более широкими, чем те, которые ожидаются супертипом/сигнатурой вызова. Вот почему --strictFunctionTypes был введен в язык.

Если вы измените unknown на any (используя anyArgsF вместо unknownArgsF), то компилятор не будет жаловаться, потому что any намеренно неправильный в TypeScript. Тип any считается назначаемым как в, так и из любого другого типа; это небезопасно, потому что, например, string extends any и any extends number оба истинны, а string extends number ложны. Таким образом, описанный выше принцип замещения не применяется, когда используется any. Аннотирование значения как типа any эквивалентно ослаблению или отключению проверки типа для этого значения. Это не спасет вас от ошибки времени выполнения; он просто заглушает ошибку компилятора:

const a: anyArgsF = t; // okay, type checking with any is disabled/loosened
a(1, 2, 3); // same explosion at runtime!

В случае, когда testNoArgsF extends unknownArgsF истинно, это также является следствием взаимозаменяемости. Вы можете использовать функцию, которая не принимает аргументов, как если бы это была функция любого типа, поскольку она (обычно) в конечном итоге игнорирует любые переданные ей аргументы:

const n: testNoArgsF = () => 1;
const u2: unknownArgsF = n; // okay
u2(1, 2, 3); // okay at runtime, since `n` ignores its arguments

Это объясняется в записи FAQ по TypeScript "Почему функции с меньшим количеством параметров можно назначать функциям, которые принимают больше параметров?".

Хорошо, надеюсь, это поможет; удачи!

Playground link to code

Я постараюсь выразиться проще: «расширяет» -> «совместимо» -> «можно использовать вместо»

Можно ли использовать (arg1: boolean, arg2: string) => number;
вместо (...args: unknown[]) => number?

Нет, потому что последний может обрабатывать вызов без аргументов, но первый может дать сбой во время выполнения (например, попытается получить доступ к свойствам аргументов).

Подробнее о совместимости функций здесь

type testIV = testArgsF extends unknownArgsF ? true : false; // false 
type testIVa = unknownArgsF extends testArgsF  ? true : false; // true!

// because
type testIII = Parameters<testArgsF> extends Parameters<unknownArgsF>
    ? true
    : false; // true

Расширяется на самом деле означает «назначается». И f(p:A)=> присваивается f(p:B)=>, если B присваивается A. Я думаю, это называется «контравариантным».

// Imagine your function expects callback that has some type as a paramter:

var f = (cb: ({ a, b }: { a: number, b: number }) => void) => { cb({ a:1, b: 1}); };

// you can safely call it giving it the function that accepts parameter 
// that the original parameter is assignable to but not the other way around
// because that's the way to guarantee that when our function f calls the callback
// it will provide sufficient amount of data
f(({ a }: { a: number }) => { })


var x = { a: 1, b: 1 };
var y = { a: 1 }

x = y; // error because x would have no b property after that assignment
y = x; // works because y has all it needs after that assignment and it doesn't matter it has property b too

// in other words:
type F = { a: number } extends { a: number, b: number } ? true : false; // false
type T = { a: number, b: number } extends { a: number } ? true : false; // true

// read 'extends' as 'is assignable to'