Question

不幸的是，从0.9.5开始，TypeScript（尚未）具有代数数据类型（联合类型）和模式匹配（用于解构它们）。更重要的是，它甚至不支持接口上的instanceof。您使用哪种模式来模拟具有最大类型安全性和最小样板代码的这些语言功能？

Answer 1

我选择了以下类似访客的模式，灵感来自this和this（在示例中，Choice可以是Foo或Bar ）：

interface Choice {
    match<T>(cases: ChoiceCases<T>): T;
}

interface ChoiceCases<T> {
    foo(foo: Foo): T;
    bar(bar: Bar): T;
}

class Foo implements Choice {

    match<T>(cases: ChoiceCases<T>): T {
        return cases.foo(this);
    }

}

class Bar implements Choice {

    match<T>(cases: ChoiceCases<T>): T {
        return cases.bar(this);
    }

}

用法：

function getName(choice: Choice): string {
    return choice.match({
        foo: foo => "Foo",
        bar: bar => "Bar",
    });
}

匹配本身具有表现力和类型安全性，但是要为类型编写很多样板文件。

Answer 2

TypeScript 1.4添加了union types and type guards。

Answer 3

回答

它甚至不支持接口上的instanceof。

原因是类型擦除。接口只是一个编译类型构造，没有任何运行时的含义。但是，您可以在类上使用instanceof，例如：

class Foo{}
var x = new Foo();
console.log(x instanceof Foo); // true

Answer 4

说明接受的答案的示例：

enum ActionType { AddItem, RemoveItem, UpdateItem }
type Action =
    {type: ActionType.AddItem, content: string} |
    {type: ActionType.RemoveItem, index: number} |
    {type: ActionType.UpdateItem, index: number, content: string}

function dispatch(action: Action) {
    switch(action.type) {
    case ActionType.AddItem:
        // now TypeScript knows that "action" has only "content" but not "index"
        console.log(action.content);
        break;
    case ActionType.RemoveItem:
        // now TypeScript knows that "action" has only "index" but not "content"
        console.log(action.index);
        break;
    default:
    }
}

Answer 5

这是@thSoft非常好的答案的替代方案。从好的方面来说，这个替代方案

与T表单上的原始javascript对象具有潜在的互操作性，其中type的形状取决于// One-time boilerplate, used by all cases. interface Maybe<T> { value : T } interface Matcher<T> { (union : Union) : Maybe<T> } interface Union { type : string } class Case<T> { name : string; constructor(name: string) { this.name = name; } _ = (data: T) => ( <Union>({ type : this.name, data : data }) ) $ = <U>(f:(t:T) => U) => (union : Union) => union.type === this.name ? { value : f((<any>union).data) } : null } function match<T>(union : Union, destructors : Matcher<T> [], t : T = null) { for (const destructor of destructors) { const option = destructor(union); if (option) return option.value; } return t; } function any<T>(f:() => T) : Matcher<T> { return x => ({ value : f() }); } // Usage. Define cases. const A = new Case<number>("A"); const B = new Case<string>("B"); // Construct values. const a = A._(0); const b = B._("foo"); // Destruct values. function f(union : Union) { match(union, [ A.$(x => console.log(`A : ${x}`)) , B.$(y => console.log(`B : ${y}`)) , any (() => console.log(`default case`)) ]) } f(a); f(b); f(<any>{});的值，
的选择样板少得多;

在消极方面

不会静态强制您匹配所有情况，
不区分不同的ADT。

看起来像这样：

{{1}}

Answer 6

这是一个古老的问题，但这也许仍然可以帮助某人：

就像@SorenDebois的答案一样，这是@theSoft案例的一半。它也比@Soren的封装得更多。此外，此解决方案具有类型安全性，类似switch的行为，并迫使您检查所有情况。

// If you want to be able to not check all cases, you can wrap this type in `Partial<...>`
type MapToFuncs<T> = { [K in keyof T]: (v: T[K]) => void }
// This is used to extract the enum value type associated with an enum. 
type ValueOfEnum<_T extends Enum<U>, U = any> = EnumValue<U>

class EnumValue<T> {
  constructor(
    private readonly type: keyof T,
    private readonly value?: T[keyof T]
  ) {}

  switch(then: MapToFuncs<T>) {
    const f = then[this.type] as (v: T[keyof T]) => void
    f(this.value)
  }
}

// tslint:disable-next-line: max-classes-per-file
class Enum<T> {
  case<K extends keyof T>(k: K, v: T[K]) {
    return new EnumValue(k, v)
  }
}

用法：

// Define the enum. We only need to mention the cases once!
const GameState = new Enum<{
  NotStarted: {}
  InProgress: { round: number }
  Ended: {}
}>()

// Some function that checks the game state:
const doSomethingWithState = (state: ValueOfEnum<typeof GameState>) => {
    state.switch({
      Ended: () => { /* One thing */ },
      InProgress: ({ round }) => { /* Two thing with round */ },
      NotStarted: () => { /* Three thing */ },
    })
}

// Calling the function
doSomethingWithState(GameState.case("Ended", {}))

这里真的不理想的一个方面是对ValueOfEnum的需求。在我的应用程序中，使用@theSoft的答案就足够了。如果有人知道如何压缩它，请在下面添加评论！

如何在TypeScript中模拟ADT和模式匹配？

6 个答案: