@effectful/transducers-loose/v2/combinators.js

@effectful/transducers built with faster generators

"use strict";

exports.__esModule = true;
exports.cons = cons;
exports.curry = curry;
exports.curryN = curryN;
exports.forEach = exports.flatMap = exports.filter = void 0;
exports.group = group;
exports.groupUniq = groupUniq;
exports.groupWith = groupWith;
exports.map = void 0;
exports.mapAdd = mapAdd;
exports.mapArr = mapArr;
exports.mapPush = mapPush;
exports.pipe = pipe;
exports.reverse = reverse;
var _config = require("./config");
var M = require("@effectful/es-rt/opts/loose");
/**
 * similar to Ramda.curryN, likely less efficient,
 * but Ramda dependency can be dropped
 */
function curryN(num, fun) {
  function step(args) {
    return function curryStep() {
      const next = args.concat(Array.from(arguments));
      return next.length >= num ? fun.apply(undefined, next) : step(next);
    };
  }
  return step([]);
}

/**
 * similar to Ramda.curry, likely less efficient,
 * but Ramda dependency can be dropped
 */
function curry(fun, trace) {
  return curryN(fun.length, fun, trace);
}
const filter = exports.filter = curry(function filter(pred, s) {
  var i,
    _filter = M.generator(),
    loop,
    r,
    p;
  _filter.step = filter_1;
  _filter.$step = 3;
  return _filter;
  function filter_1(p) {
    for (;;) {
      switch (_filter.$cur = _filter.$step) {
        case 3:
          loop = M.iterator(s);
          _filter.$step = 4;
          _filter.$step = 4;
          continue;
        case 4:
          if (!(loop = loop.step()).done) {
            i = loop.value;
            if (pred(i)) {
              _filter.$step = 4;
              _filter.value = i;
              return _filter;
            } else {
              _filter.$step = 4;
              _filter.$step = 4;
              continue;
            }
          } else {
            _filter.$step = 0;
            _filter.value = void 0;
            _filter.done = true;
            return _filter;
          }
        case 0:
          _filter.$step = 0;
          _filter.value = p;
          _filter.done = true;
          return _filter;
        case 1:
          _filter.$step = 0;
          throw p;
        default:
          throw new Error("invalid state");
      }
    }
  }
});
const flatMap = exports.flatMap = curry(function flatMap(act, s) {
  var i,
    _flatMap = M.generator(),
    loop,
    r,
    p;
  _flatMap.step = flatMap_1;
  _flatMap.$step = 3;
  return _flatMap;
  function flatMap_1(p) {
    var a;
    for (;;) {
      switch (_flatMap.$cur = _flatMap.$step) {
        case 3:
          loop = M.iterator(s);
          _flatMap.$step = 4;
          _flatMap.$step = 4;
          continue;
        case 4:
          if (!(loop = loop.step()).done) {
            i = loop.value;
            a = act(i);
            _flatMap.$step = 4;
            return _flatMap.$delegate(a);
          } else {
            _flatMap.$step = 0;
            _flatMap.value = void 0;
            _flatMap.done = true;
            return _flatMap;
          }
        case 0:
          _flatMap.$step = 0;
          _flatMap.value = p;
          _flatMap.done = true;
          return _flatMap;
        case 1:
          _flatMap.$step = 0;
          throw p;
        case 2:
          return _flatMap.$redir(p);
        default:
          throw new Error("invalid state");
      }
    }
  }
});
const map = exports.map = curry(function map(fun, s) {
  var i,
    _map = M.generator(),
    loop,
    r,
    p;
  _map.step = map_1;
  _map.$step = 3;
  return _map;
  function map_1(p) {
    var a;
    for (;;) {
      switch (_map.$cur = _map.$step) {
        case 3:
          loop = M.iterator(s);
          _map.$step = 4;
          _map.$step = 4;
          continue;
        case 4:
          if (!(loop = loop.step()).done) {
            i = loop.value;
            a = fun(i);
            _map.$step = 4;
            _map.value = a;
            return _map;
          } else {
            _map.$step = 0;
            _map.value = void 0;
            _map.done = true;
            return _map;
          }
        case 0:
          _map.$step = 0;
          _map.value = p;
          _map.done = true;
          return _map;
        case 1:
          _map.$step = 0;
          throw p;
        default:
          throw new Error("invalid state");
      }
    }
  }
});
const forEach = exports.forEach = curry(function forEach(act, s) {
  var loop = M.iterator(s);
  for (; !(loop = loop.step()).done;) {
    const i = loop.value;
    act(i);
  }
});

/**
 * reverse array iterator
 */
function reverse(arr) {
  arr = Array.isArray(arr) ? arr : Array.from(arr);
  let i = arr.length;
  return {
    [Symbol.iterator]() {
      return {
        next() {
          return i === 0 ? {
            value: null,
            done: true
          } : {
            value: arr[--i],
            done: false
          };
        }
      };
    }
  };
}

/**
 * adds value `v` to an Array in a map `m` value by `k`
 * creates the Array if needed
 */
function mapPush(m, k, v) {
  let l = m.get(k);
  if (l == null) m.set(k, l = []);
  l.push(v);
}

/**
 * Returns Map's `m` value by `k` if it doesn't exist inserts an empty array,
 * and returns it.
 */
function mapArr(m, k) {
  let l = m.get(k);
  if (l == null) m.set(k, l = []);
  return l;
}

/**
 * adds value `v` to a Set in a map `m` value by `k`
 * creates the Set if needed
 */
function mapAdd(m, k, v) {
  let l = m.get(k);
  if (l == null) m.set(k, l = new Set());
  l.add(v);
}
function groupWith /*::<K,V,W>*/(i /*:Iterable<[K,V]>*/, accum /*:(w:W,v:V,k?:K) => W*/, init /*::?: (k?:K) => W*/) {
  /*: Map<K,W>*/const ret /*:Map<K,W>*/ = new Map();
  if (init == null) init = () => null;
  var loop = M.iterator(i);
  for (; !(loop = loop.step()).done;) {
    const [k, v] = loop.value;
    const l = ret.get(k);
    ret.set(k, l == null ? accum(init(k), v, k) : accum(l, v, k));
  }
  return ret;
}
function group /*::<K,V>*/(i /*:Iterable<[K,V]>*/) /*: Map<K,V[]>*/{
  const ret /*:Map<K,V[]>*/ = new Map();
  var loop = M.iterator(i);
  for (; !(loop = loop.step()).done;) {
    const [k, v] = loop.value;
    mapPush(ret, k, v);
  }
  return ret;
  // return groupWith<K,V,V[]>(i,(w:V[],v:V) => (w.push(v),w), () => [])
}
function groupUniq /*::<K,V>*/(i /*:Iterable<[K,V]>*/) /*: Map<K,Set<V>>*/{
  const ret /*:Map<K,V[]>*/ = new Map();
  var loop = M.iterator(i);
  for (; !(loop = loop.step()).done;) {
    const [k, v] = loop.value;
    mapAdd(ret, k, v);
  }
  return ret;
  // return groupWith<K,V,V[]>(i,(v:V,w:V[]) => (w.add(v),w), () => new Set())
}

/**
 * similar to Ramda.pipe, likely less efficient,
 * but Ramda dependency can be dropped
 */
function pipe() {
  var args = arguments;
  if (_config.default.debug && ![...args].every(Boolean)) throw new Error(`pipe with an empty function`);
  return function pipeImpl(cur) {
    for (let i = 0, len = args.length; i < len; ++i) cur = args[i](cur);
    return cur;
  };
}
function cons(a, s) {
  var cons = M.generator(),
    r,
    p;
  cons.step = cons_1;
  cons.$step = 3;
  return cons;
  function cons_1(p) {
    switch (cons.$cur = cons.$step) {
      case 3:
        cons.$step = 4;
        cons.value = a;
        return cons;
      case 4:
        cons.$step = 5;
        return cons.$delegate(s);
      case 5:
        cons.$step = 0;
        cons.value = void 0;
        cons.done = true;
        return cons;
      case 0:
        cons.$step = 0;
        cons.value = p;
        cons.done = true;
        return cons;
      case 1:
        cons.$step = 0;
        throw p;
      case 2:
        return cons.$redir(p);
      default:
        throw new Error("invalid state");
    }
  }
}