Question

我通常会尝试将流功能类型与其实现分开。当我写作时，它的可读性略高一些：

type Fn = string => string;
const aFn: Fn = name => `hello, ${ name }`;

而不是：

const aFn = (name: string): string => `hello, ${ name }`;

使用泛型类型时，我们可以写：

const j= <T>(i: T): T => i;

const jString: string = j('apple'); // √
const jNumber: number = j(7);       // √

但是如何将这种类型与函数表达式分开？

type H<T> = (input: T) => T;
const h:H<*> = i => i;              // --> WHAT SHOULD GO FOR '*'?

const hString: string = h('apple'); // X error
const hNumber: number = h(7);       // X error

*应该使用什么？ any会起作用，但这不是我想要的。

在haskell中，这不是问题：

identity :: a -> a
identity a = a

identity "a-string" // √
identity 666        // √

请参阅flow.org/try

Answer 1

所以我注意到，如果我使用bounded generics，它就会起作用：

type H<T> = <T: *>(input: T) => T;
const h:H<*> = i => i;

const a: string = h('apple');      // √
const b: number = h(7);            // √
const c: {} = h({ nane: 'jon' });  // √

不要问我为什么。

Answer 2

 type H<T> = (input: T) => T;
    const h2:H<*> = i => i;   
    const h3:H<*> = i => i;   
    const hString: string = h3('apple');
    const hNumber: number = h2(7);

Answer 3

我认为您的代码和类型定义的根本问题是基于对泛型的特定属性（也称为参数多态）的误解： Parametricity 。

Parametricity声明泛型函数必须不知道有关其多态参数/返回值的类型的任何信息。它是类型不可知的。

因此，泛型函数必须平等地处理与多态类型相关联的每个值，而不管具体类型如何。当然，这是非常有限的。当一个函数对它的参数一无所知时，除了不改变它之外，它不能对它做任何事情。

让我们看一下不正确的泛型函数：

const f = <a>(x :a) :a => x + "bar"; // type error

Try

f未按预期键入检查，因为f不得将x视为String。 Flow强制执行参数化。

请注意，与高阶函数相关的泛型更有用。以下是正确的通用高阶函数的示例：

type F<X, Y> = (x: X) => Y;

const apply = <X, Y>(f: F<X, Y>, x: X) :Y => f(x);

const sqr = (x :number) :number => x * x;
const toUC = (s :string) :string => s.toUpperCase();

apply(sqr, 5); // does type check
apply(toUC, "foo"); // does type check

Try

为什么要为每种可能的类型定义apply的特定版本？只要f和x的类型兼容，只需将其应用于任意类型的值即可。

结论

当你有一个无界泛型函数时，你可以将它应用于你想要的任何值 - 它总是按预期工作。 所以没有理由为每种可能的类型声明一个独特的函数。聪明的人发明了多态，以避免这种情况。

但问题仍然存在。只要将泛型类型定义从函数声明中分离出来，Flow就不再强制执行参数：

const f = <a>(x :a) :a => x + "bar"; // type error

type G<a> = a => a;
const g :G<*> = x => x + ""; // type checks!?!

Try

所以你的问题仍然合理，不幸的是，我无法为你提供食谱。希望Flow的行为在未来版本中会发生变化。

在您自己的回答中，您建议使用有界泛型。我不这样做是因为它解决了一个根本不存在的问题，因为它似乎是对这种多态性的误用。

函数表达式的流泛型类型（箭头函数）

3 个答案:

结论