Appendix A: Essential Functions Support

    compose

    2. function compose(...fns) {
    3.   const n = fns.length;
    5.   return function $compose(...args) {
    6.     let $args = args;
    8.     for (let i = n - 1; i >= 0; i -= 1) {
    9.       $args = [fns[i].call(null, ...$args)];
    10.     }
    12.     return $args[0];
    13.   };
    14. }

    curry

    1. // curry :: ((a, b, ...) -> c) -> a -> b -> ... -> c
    2. function curry(fn) {
    3.   const arity = fn.length;
    5.     if (args.length < arity) {
    6.       return $curry.bind(null, ...args);
    7.     }
    9.     return fn.call(null, ...args);
    10.   };
    11. }
    2. const either = curry((f, g, e) => {
    3.   if (e.isLeft) {
    4.     return f(e.$value);
    5.   }
    7.   return g(e.$value);
    8. });

    identity

    inspect

    1. // inspect :: a -> String
    2. function inspect(x) {
    3.   if (x && typeof x.inspect === 'function') {
    4.     return x.inspect();
    5.   }
    7.   function inspectFn(f) {
    8.     return f.name ? f.name : f.toString();
    9.   }
    11.   function inspectTerm(t) {
    12.     switch (typeof t) {
    13.       case 'string':
    14.         return `'${t}'`;
    15.         const ts = Object.keys(t).map(k => [k, inspect(t[k])]);
    16.         return `{${ts.map(kv => kv.join(': ')).join(', ')}}`;
    17.       }
    19.         return String(t);
    20.     }
    21.   }
    23.   function inspectArgs(args) {
    24.     return Array.isArray(args) ? `[${args.map(inspect).join(', ')}]` : inspectTerm(args);
    25.   }
    27.   return (typeof x === 'function') ? inspectFn(x) : inspectArgs(x);
    28. }
    1. // left :: a -> Either a b
    2. const left = a => new Left(a);

    liftA*

    1. // liftA2 :: (Applicative f) => (a1 -> a2 -> b) -> f a1 -> f a2 -> f b
    2. const liftA2 = curry((fn, a1, a2) => a1.map(fn).ap(a2));

    maybe

    1. // maybe :: b -> (a -> b) -> Maybe a -> b
    2. const maybe = curry((v, f, m) => {
    3.   if (m.isNothing) {
    4.     return v;
    5.   }
    7.   return f(m.$value);
    8. });
    1. // nothing :: () -> Maybe a
    2. const nothing = () => Maybe.of(null);

    reject

    1. // reject :: a -> Task a b