至少，将一个没有Assert函数签名的函数分配给一个Assert函数类型的变量应该被拒绝。
原始笔记在#32695中没有提到这一点，但据我所知，这种逻辑的动机是我们希望与Assert函数类型绑定的绑定可以通过“普通”函数进行初始化，即：

const assertNumber: (x: unknown) => asserts x is number = x => {
  if (typeof x !== 'number') {
    throw Error("not a number")
  }
}

在这里，函数表达式的返回类型仅仅是void,因此根据这个规则，初始化是非法的，除非我们添加了新的逻辑来例如上下文地修改函数表达式的返回类型。
将具有两种不同Assert类型的东西分配给是非常草率的。我们可能会标记这个问题，但我认为过去三年的生活经验是，任何类型的Assert函数的别名非常罕见，因为它们没有任何有意义的替代或多态性。

别名Assert函数...没有任何有意义的替代或多态性。
我不同意，并认为这是一个合法的正确性问题！考虑以下内容，其中包括定义泛型数组Assert函数的一些其他内容：

type AssertFn<T> = (val: unknown) => asserts val is T;
const num: AssertFn<number> = (val) => {
  if (!Number.isFinite(val)) {
    throw new Error('num assertion failed');
  }
}
const array: <T>(assert: AssertFn<T>) => AssertFn<T[]> =
  (assert) => (val) => {
    if (!Array.isArray(val)) {
      throw new Error('assertIsArray failed');
    }
    val.forEach(assert);
  };
const assertStringArray: AssertFn<string[]> = array(num);

链接到Playground
请注意，我明确地将 assertStringArray 标记为 AssertFn<string[]> ,但实际上通过 array(num) 提供了一个 AssertFn<number[]> ,编译器对此没有问题。如果我删除了显式类型注解，它会正确地推断出类型为 AssertFn<number> 。

一个可能的原因是，它要求指定Assert类型以确保它们影响CFA。

type TypePredicate<T> = (v: unknown) => v is T;
type TypeAssertion<T> = (v: unknown) => asserts v is T;
declare function makeAssertion<T>(predicate: TypePredicate<T>): TypeAssertion<T>;
declare function isString(v: unknown): v is string;

const assertIsString = makeAssertion(isString);
declare let x: unknown;
assertIsString(x); // TS error! Assertions require every name in the call target to be declared with an explicit type annotation

- const assertIsString = makeAssertion(isString);
+ const assertIsString: TypeAssertion<string> = makeAssertion(isString);
declare let x: unknown;
assertIsString(x);
x; // good, x is string

但是如果我们放入错误的类型...

- const assertIsString = makeAssertion(isString);
+ const assertIsString: TypeAssertion<number> = makeAssertion(isString);
declare let x: unknown;
assertIsString(x);
x; // bad, x is number

我本以为 const assertIsString: TypeAssertion<number> = makeAssertion(isString); 会产生类型错误。
还有一个例子：

type TypeAssertion<T> = (v: unknown) => asserts v is T;
declare function sendRequest<ExpectedReponse>(
    path: string,
    assertion: TypeAssertion<ExpectedReponse>
): Promise<ExpectedReponse>;
interface Person { name: string };
type People = Array<Person>;
declare function assertPerson(v: unknown): asserts v is Person;
// @ts-expect-error
sendRequest<People>("/db", assertPerson);

playground

这种行为对我来说非常令人惊讶。我一直在做一个项目，该项目使用Assert函数验证传递给API端点的JSON数据。我震惊地意识到代码实际上没有类型安全。项目中的其他人也没有意识到这一点，包括编写原始代码的人。有关问题的非常简化的代码版本如下：

$x_1a^0b^1^x$