Flow不透明类型别名（Opaque Type Aliases）

不透明类型别名（Opaque Type Aliases）

通过类型系统加强抽象

不透明类型别名是类型别名，它们不允许在定义它们的文件之外访问其基础类型。

opaque type ID = string;

function identity(x: ID): ID {
  return x;
}
export type {ID};

不透明类型语法（Opaque Type Alias Syntax）

opaque type Alias = Type;

你可以通过在名称后面添加: type来选择性地将子类型约束添加到不透明类型别名中。

opaque type Alias: SuperType = Type;

任何类型都可以成为超类型或不透明类型的别名。

opaque type StringAlias = string;
opaque type ObjectAlias = {
  property: string,
  method(): number,
};
opaque type UnionAlias = 1 | 2 | 3;
opaque type AliasAlias: ObjectAlias = ObjectAlias;
opaque type VeryOpaque: AliasAlias = ObjectAlias;

不透明类型别名类型检查

在定义文件中

在同一文件中定义别名时，不透明类型别名的行为与常规类型别名完全相同。

//@flow
opaque type NumberAlias = number;

(0: NumberAlias);

function add(x: NumberAlias, y: NumberAlias): NumberAlias {
    return x + y;
}
function toNumberAlias(x: number): NumberAlias { return x; }
function toNumber(x: NumberAlias): number { return x; }

在定义文件之外

当导入一个不透明类型的别名时，它的行为就像一个名义类型，隐藏了它的基础类型。
exports.js

export opaque type NumberAlias = number;

imports.js

import type {NumberAlias} from './exports';

(0: NumberAlias) // Error: 0 is not a NumberAlias!

function convert(x: NumberAlias): number {
  return x; // Error: x is not a number!
}

子类型约束（Subtyping Constraints）

exports.js

export opaque type ID: string = string;

imports.js

import type {ID} from './exports';

function formatID(x: ID): string {
    return "ID: " + x; // Ok! IDs are strings.
}

function toID(x: string): ID {
    return x; // Error: strings are not IDs.
}

当你使用子类型约束创建不透明类型别名时，类型位置中的类型必须是超类型位置中的类型的子类型。

//@flow
opaque type Bad: string = number; // Error: number is not a subtype of string
opaque type Good: {x: string} = {x: string, y: number};

泛型（Generics）

不透明类型别名也可以有自己的泛型，而且它们的工作方式与普通类型别名一样。

// @flow
opaque type MyObject<A, B, C>: { foo: A, bar: B } = {
  foo: A,
  bar: B,
  baz: C,
};

var val: MyObject<number, boolean, string> = {
  foo: 1,
  bar: true,
  baz: 'three',
};