Considering the code for Option ADT as below (pretty similar to fp-ts Option):

选项adt的代码如下(与fp-ts选项非常相似)：

export type Option<A> = Some<A> | None

export interface Some<A> {
  _tag: 'Some'
  value: A
}

export interface None {
  _tag: 'None'
}

export const some = <A>(x: A): Option<A> => 
  ({ _tag: 'Some', value: x })

export const none: Option<never> = 
  { _tag: 'None' }

export const isNone = <A>(x: Option<A>): x is None => 
  x._tag === 'None'

type Match = <A, B>(onNone: () => B, onSome: (a: A) => B)
  => (x: Option<A>) => B
  
const match: Match = (onNone, onSome) => x =>
  isNone(x) ? onNone() : onSome(x.value)

I'm trying to write the Option map Functor mapOption, but it cannot refer the types correctly. You can also see the error in this typescript playground.

我正在尝试编写选项映射函数mapOption，但它无法正确引用类型。你也可以在这个打字操场上看到错误。

type MapOption = <A, B>(f: (x: A) => B) => (fa: Option<A>) => Option<B>
const mapOption: MapOption = f => fa => match(
  () => none,
  (value) => f(value))(fa)

For some reason it is inferring the types incorrectly. How can I fix the typing error?

出于某种原因，它错误地推断了类型。我怎样才能改正打字错误呢？

One problem with your code was that it was not correct, so really there's no hope at all of the compiler inferring the types properly. The proper implementation looks like this:

您的代码的一个问题是它不正确，所以实际上编译器完全没有希望正确地推断类型。正确的实现如下所示：

const mapOption: MapOption = f => fa => (
  match(
    () => none,
    value => some(f(value)) // error!
    // -----------> ~~~~~
    // Argument of type 'unknown' is not assignable to parameter of type 'A'.
  )
)(fa);

But, as you can see, the inference issue remains. The compiler fails to infer the type of value from context, and thus it falls back to the unknown type.

但是，正如你所看到的，推理问题仍然存在。编译器无法从上下文中推断出值的类型，因此它会退回到未知类型。

This sort of thing is ultimately a design limitation of TypeScript. The language can't always infer generic type arguments and simultaneously infer types from context. The currently open issue about the general problem is microsoft/TypeScript#47599.

这类事情归根结底是打印脚本的设计局限性。该语言并不总是能在推断泛型类型参数的同时从上下文中推断类型。目前关于该一般问题的未决问题是MICROSOFT/TypeScrip#47599。

While there have been improvements here over the years, it's probably always going to be there in some form. TypeScript does not use a full unificiation algorithm for type inference, as in some other functional programming languages, and as requested in microsoft/TypeScript#30134.

虽然多年来这里已经有了改进，但它可能永远会以某种形式存在。与其他函数式编程语言和微软/TypeScrip#30134中的要求不同，TypeScrip不使用完整的统一算法进行类型推理。

And it probably never will use such an algorithm, since (according to this comment on microsoft/TypeScript#17520), the current inference algorithm "has the distinct advantage of being able to make partial inferences in incomplete code which is hugely beneficial to statement completion in IDEs."

而且它可能永远不会使用这样的算法，因为(根据微软/TypeScrip#17520上的这条评论)，当前的推理算法“具有独特的优势，能够在不完整的代码中进行部分推断，这对IDE中的语句完成非常有益。”

We have to work around this if you want your code to compile. One way is to do the thing you don't want to do: "inline" the types. Maybe like this:

如果您想要编译代码，我们必须解决这个问题。一种方法是做你不想做的事情：“内联”类型。也许是这样的：

const mapOption: MapOption = f => fa => (
  match(
    () => none,
    (value: Parameters<typeof f>[0]) => some(f(value))
  )
)(fa);

Here I'm using the Parameters utility type to get a handle on the anonymous generic type parameter corresponding to A. Otherwise you'd have to do it very explicitly and actually declare the type parameters:

在这里，我使用参数实用程序类型来获取对应于A的匿名泛型类型参数的句柄。否则，您必须非常显式地执行此操作，并实际声明类型参数：

const mapOption3: MapOption = <A, B>(f: (x: A) => B) => (fa: Option<A>) => (
  match(
    () => none,
    (value: A) => some(f(value))
  )
)(fa);

Another workaround is to make use of some point-free style to eliminate fa and thus make type inference easier by shortening the "distance" between the expected return type and the required input type:

另一种解决方法是使用一些无点样式来消除fa，从而通过缩短预期返回类型和所需输入类型之间的“距离”来更容易地进行类型推断：

const mapOption: MapOption = f => match(
  () => none,
  value => some(f(value))
);

This way is probably ideal for the particular code example, but you might need to resort to one of the earlier approaches in general. Without full unification, you'll have to specify types in some places where they might have otherwise been inferred.

对于特定的代码示例，这种方法可能是理想的，但通常您可能需要求助于较早的方法之一。如果没有完全统一，您将不得不在某些地方指定类型，否则可能会推断出这些类型。

Playground link to code

游乐场链接到代码