pattern matching - tricíclicos - ¿Cómo se emulan los ADT y la coincidencia de patrones en TypeScript?

principales farmacos antidepresivos triciclicos

Question

Desafortunadamente, a partir de la versión 0.9.5, TypeScript aún no (tiene) tipos de datos algebraicos (tipos de unión) y coincidencia de patrones (para desestructurarlos). Además, ni siquiera es compatible con instanceof en las interfaces. ¿Qué patrón usas para emular estas funciones del lenguaje con la máxima seguridad de tipo y el código mínimo repetitivo?

Answer 1

Fui con el siguiente patrón similar al de Visitor, inspirado en esto y esto (en el ejemplo, una Choice puede ser Foo o 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);
    }

}

Uso:

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

La coincidencia en sí misma es expresiva y segura, pero hay mucho que repetir para los tipos.

Answer 2

TypeScript 1.4 agrega tipos de unión y guarda de tipo .

Answer 3

Aquí hay una alternativa a la muy buena respuesta de @thSoft. En el lado positivo, esta alternativa

1. tiene interoperabilidad potencial con objetos javascript sin formato en la forma { type : string } & T , donde la forma de T depende del valor del type ,
2. tiene una repetición sustancialmente menor por elección;

en el lado negativo

3. no hace cumplir estáticamente que coincida con todos los casos,
4. no distingue entre diferentes ADT.

Se parece a esto:

// 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>{});

Answer 4

Contestar

ni siquiera es compatible con instanceof en las interfaces.

La razón es borrado de tipo. Las interfaces son solo una construcción de tipo compilación y no tienen implicaciones de tiempo de ejecución. Sin embargo, puede usar instanceof en las clases, por ejemplo:

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