saga-poly.js

// @flow

interface Command<A> {
  run(): A;
}

class Call<A> implements Command<A> {
  value: () => A;

  constructor<X>(f: X => A, x: X) {
    this.value = () => f(x);
  }

  run(): A {
    return this.value();
  }
}

interface Saga<A> {
  run(): A;
  map<B>(f: (A) => B): Saga<B>;
  chain<B>(next: (A) => Saga<B>): Saga<B>;
}

class Pure<A> implements Saga<A> {
  value: A;

  constructor(value: A) {
    this.value = value;
  }

  run(): A {
    return this.value;
  }

  map<B>(f: A => B): Saga<B> {
    return new Pure(f(this.value));
  }

  chain<B>(next: A => Saga<B>): Saga<B> {
    return next(this.value);
  }
}

class Next<A> implements Saga<A> {
  next: () => Saga<A>;

  constructor(next: () => Saga<A>) {
    this.next = next;
  }

  static fromCommand(command: Command<A>): Saga<A> {
    return new Next(() => new Pure(command.run()));
  }

  run(): A {
    return this.next().run();
  }

  map<B>(f: A => B): Saga<B> {
    return new Next(() => this.next().map(f));
  }

  chain<B>(next: A => Saga<B>): Saga<B> {
    return new Next(() => next(this.next().run()));
  }
}

function inc(x: number): number {
  return x + 1;
}

function numberToString(x: number): string {
  return `Number(${x})`;
}

console.log(
  new Pure(10)
    .chain(x =>
      Next.fromCommand(new Call(inc, x))
        .chain(y => Next.fromCommand(new Call(numberToString, y)))
        .map(y => `Before: ${x}, After: ${y}`),
    )
    .run(),
); // Number(11)