Appendix B: Algebraic Structures Support

    Either

    2.   constructor(x) {
    3.     this.$value = x;
    4.   }
    6.   // ----- Pointed (Either a)
    7.   static of(x) {
    8.     return new Right(x);
    9.   }
    10. }
    12. class Left extends Either {
    13.   get isLeft() {
    14.     return true;
    15.   }
    17.   get isRight() {
    18.     return false;
    19.   }
    21.   static of(x) {
    22.     throw new Error('`of` called on class Left (value) instead of Either (type)');
    23.   }
    25.   inspect() {
    26.     return `Left(${inspect(this.$value)})`;
    27.   }
    29.   // ----- Functor (Either a)
    30.   map() {
    31.     return this;
    32.   }
    34.   // ----- Applicative (Either a)
    35.   ap() {
    36.     return this;
    37.   }
    39.   // ----- Monad (Either a)
    40.   chain() {
    41.     return this;
    42.   }
    44.   join() {
    45.     return this;
    46.   }
    48.   // ----- Traversable (Either a)
    49.   sequence(of) {
    50.     return of(this);
    51.   }
    53.   traverse(of, fn) {
    54.     return of(this);
    55.   }
    56. }
    58. class Right extends Either {
    59.   get isLeft() {
    60.     return false;
    61.   }
    63.   get isRight() {
    64.     return true;
    66.   static of(x) {
    67.     throw new Error('`of` called on class Right (value) instead of Either (type)');
    68.   }
    70.   inspect() {
    71.     return `Right(${inspect(this.$value)})`;
    74.   // ----- Functor (Either a)
    75.   map(fn) {
    76.     return Either.of(fn(this.$value));
    77.   }
    79.   // ----- Applicative (Either a)
    80.   ap(f) {
    81.     return f.map(this.$value);
    82.   }
    84.   // ----- Monad (Either a)
    85.   chain(fn) {
    86.     return fn(this.$value);
    87.   }
    89.   join() {
    90.     return this.$value;
    91.   }
    93.   // ----- Traversable (Either a)
    94.   sequence(of) {
    95.     return this.traverse(of, identity);
    96.   }
    98.   traverse(of, fn) {
    99.     fn(this.$value).map(Either.of);
    100.   }
    101. }

    IO

    1. class IO {
    2.   constructor(fn) {
    3.     this.unsafePerformIO = fn;
    4.   }
    6.   inspect() {
    7.     return `IO(?)`;
    8.   }
    10.   // ----- Pointed IO
    11.   static of(x) {
    12.     return new IO(() => x);
    13.   }
    15.   // ----- Functor IO
    16.   map(fn) {
    17.     return new IO(compose(fn, this.unsafePerformIO));
    18.   }
    20.   // ----- Applicative IO
    21.   ap(f) {
    22.     return this.chain(fn => f.map(fn));
    23.   }
    25.   // ----- Monad IO
    26.   chain(fn) {
    27.     return this.map(fn).join();
    28.   }
    30.   join() {
    31.     return this.unsafePerformIO();
    32.   }
    33. }

    Map

    1. class Map {
    2.   constructor(x) {
    3.   }
    5.   inspect() {
    6.     return `Map(${inspect(this.$value)})`;
    7.   }
    10.     const singleton = {};
    11.     singleton[k] = v;
    12.     return Map.of(Object.assign({}, this.$value, singleton));
    13.   }
    15.   reduceWithKeys(fn, zero) {
    16.     return Object.keys(this.$value)
    17.       .reduce((acc, k) => fn(acc, this.$value[k], k), zero);
    18.   }
    20.   // ----- Functor (Map a)
    21.   map(fn) {
    22.     return this.reduceWithKeys(
    23.       (m, v, k) => m.insert(k, fn(v)),
    24.       new Map({}),
    25.     );
    26.   }
    28.   // ----- Traversable (Map a)
    29.   sequence(of) {
    30.     return this.traverse(of, identity);
    31.   }
    33.   traverse(of, fn) {
    34.     return this.reduceWithKeys(
    35.       (f, a, k) => fn(a).map(b => m => m.insert(k, b)).ap(f),
    36.       of(new Map({})),
    37.     );
    38.   }
    39. }

    Task

    1. class Task {
    2.   constructor(fork) {
    3.     this.fork = fork;
    4.   }
    6.   inspect() {
    7.     return 'Task(?)';
    8.   }
    10.   static rejected(x) {
    11.     return new Task((reject, _) => reject(x));
    12.   }
    14.   // ----- Pointed (Task a)
    15.   static of(x) {
    16.     return new Task((_, resolve) => resolve(x));
    17.   }
    19.   // ----- Functor (Task a)
    20.   map(fn) {
    21.     return new Task((reject, resolve) => this.fork(reject, compose(resolve, fn)));
    22.   }
    24.   // ----- Applicative (Task a)
    25.   ap(f) {
    26.     return this.chain(fn => f.map(fn));
    27.   }
    29.   // ----- Monad (Task a)
    30.   chain(fn) {
    31.     return new Task((reject, resolve) => this.fork(reject, x => fn(x).fork(reject, resolve)));
    32.   }
    34.   join() {
    35.     return this.chain(identity);
    36. }