@fncts/base 0.0.1

package/_cjs/collection/Iterable/api.cjs

@@ -0,0 +1,857 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ap_ = ap_;
+exports.append_ = append_;
+exports.asIterable = asIterable;
+exports.concat_ = concat_;
+exports.corresponds_ = corresponds_;
+exports.crossWith_ = crossWith_;
+exports.everyWithIndex_ = void 0;
+exports.every_ = every_;
+exports.filterMapWithIndex_ = void 0;
+exports.filterMap_ = filterMap_;
+exports.filterWithIndex_ = void 0;
+exports.filter_ = filter_;
+exports.find_ = find_;
+exports.foldLeftWithIndex_ = exports.flatMap_ = void 0;
+exports.foldLeft_ = foldLeft_;
+exports.foldMapSelf = foldMapSelf;
+exports.foldMapWithIndexSelf = void 0;
+exports.foldMapWithIndex_ = foldMapWithIndex_;
+exports.foldMap_ = foldMap_;
+exports.foldRightWithIndex_ = void 0;
+exports.foldRight_ = foldRight_;
+exports.partitionMapWithIndex_ = exports.map_ = exports.mapWithIndex_ = void 0;
+exports.partitionMap_ = partitionMap_;
+exports.partitionWithIndex_ = void 0;
+exports.partition_ = partition_;
+exports.size = size;
+exports.take = take;
+exports.zipWithIndex = zipWithIndex;
+exports.zipWith_ = zipWith_;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/Iterable/constructors"));
+
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/definition"));
+
+var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/constructors"));
+
+var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/control/Eval/constructors"));
+
+var _function = /*#__PURE__*/require("@fncts/base/data/function");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const flatMap_ = flatMap_1;
+exports.flatMap_ = flatMap_;
+const everyWithIndex_ = everyWithIndex_1;
+exports.everyWithIndex_ = everyWithIndex_;
+const filterMapWithIndex_ = filterMapWithIndex_1;
+exports.filterMapWithIndex_ = filterMapWithIndex_;
+const filterWithIndex_ = filterWithIndex_1;
+exports.filterWithIndex_ = filterWithIndex_;
+const foldLeftWithIndex_ = foldLeftWithIndex_1;
+exports.foldLeftWithIndex_ = foldLeftWithIndex_;
+const foldMapWithIndexSelf = foldMapWithIndexSelf_1;
+exports.foldMapWithIndexSelf = foldMapWithIndexSelf;
+const foldRightWithIndex_ = foldRightWithIndex_1;
+exports.foldRightWithIndex_ = foldRightWithIndex_;
+const map_ = map_1;
+exports.map_ = map_;
+const mapWithIndex_ = mapWithIndex_1;
+exports.mapWithIndex_ = mapWithIndex_;
+const partitionMapWithIndex_ = partitionMapWithIndex_1;
+exports.partitionMapWithIndex_ = partitionMapWithIndex_;
+const partitionWithIndex_ = partitionWithIndex_1;
+exports.partitionWithIndex_ = partitionWithIndex_;
+
+/**
+ * @tsplus fluent fncts.Iterable ap
+ */
+function ap_(self, fa) {
+  return flatMap_1(self, f => map_1(fa, f));
+}
+/**
+ * @tsplus fluent fncts.Iterable append
+ */
+
+
+function append_(self, b) {
+  return tsplus_module_1.mkIterable(() => {
+    let done = false;
+    const ia = self[Symbol.iterator]();
+    let va;
+    return {
+      next() {
+        if (done) {
+          return this.return();
+        }
+
+        va = ia.next();
+
+        if (va.done) {
+          done = true;
+          return {
+            done: false,
+            value: b
+          };
+        }
+
+        return {
+          done,
+          value: va.value
+        };
+      },
+
+      return(value) {
+        done = true;
+
+        if (!done) {
+          done = true;
+        }
+
+        if (typeof ia.return === "function") {
+          ia.return();
+        }
+
+        return {
+          done,
+          value
+        };
+      }
+
+    };
+  });
+}
+/**
+ * @tsplus getter fncts.Iterable asIterable
+ */
+
+
+function asIterable(self) {
+  return self;
+}
+/**
+ * @tsplus fluent fncts.Iterable flatMap
+ */
+
+
+function flatMap_1(self, f) {
+  return tsplus_module_1.mkIterable(() => {
+    const ia = self[Symbol.iterator]();
+    let ib;
+    let va;
+    let vb;
+    let done = false;
+
+    const pullA = onDone => {
+      va = ia.next();
+
+      if (va.done) {
+        return onDone();
+      }
+
+      ib = f(va.value)[Symbol.iterator]();
+      return pullB(onDone);
+    };
+
+    const pullB = onDone => {
+      if (!ib) {
+        return pullA(onDone);
+      }
+
+      vb = ib.next();
+
+      if (!vb.done) {
+        return {
+          done,
+          value: vb.value
+        };
+      }
+
+      return pullA(onDone);
+    };
+
+    return {
+      next() {
+        if (done) {
+          return this.return();
+        }
+
+        return pullB(() => this.return());
+      },
+
+      return(value) {
+        if (!done) {
+          done = true;
+
+          if (typeof ia.return === "function") {
+            ia.return();
+          }
+
+          if (ib && typeof ib.return === "function") {
+            ib.return();
+          }
+        }
+
+        return {
+          done,
+          value
+        };
+      }
+
+    };
+  });
+}
+/**
+ * @tsplus fluent fncts.Iterable concat
+ */
+
+
+function concat_(self, ib) {
+  return tsplus_module_1.mkIterable(() => {
+    const iterA = self[Symbol.iterator]();
+    let doneA = false;
+    let iterB;
+    return {
+      next() {
+        if (!doneA) {
+          const r = iterA.next();
+
+          if (r.done) {
+            doneA = true;
+            iterB = ib[Symbol.iterator]();
+            return iterB.next();
+          }
+
+          return r;
+        }
+
+        return iterB.next();
+      }
+
+    };
+  });
+}
+/**
+ * @tsplus fluent fncts.Iterable corresponds
+ */
+
+
+function corresponds_(left, right, f) {
+  const leftIterator = left[Symbol.iterator]();
+  const rightIterator = right[Symbol.iterator](); // eslint-disable-next-line no-constant-condition
+
+  while (true) {
+    const lnext = leftIterator.next();
+    const rnext = rightIterator.next();
+
+    if (lnext.done !== rnext.done) {
+      return false;
+    }
+
+    if (lnext.done) {
+      return true;
+    }
+
+    if (!f(lnext.value, rnext.value)) {
+      return false;
+    }
+  }
+}
+/**
+ * @tsplus fluent fncts.Iterable crossWith
+ */
+
+
+function crossWith_(self, fb, f) {
+  return flatMap_1(self, a => map_1(fb, b => f(a, b)));
+}
+
+function every_(self, p) {
+  return everyWithIndex_1(self, (_, a) => p(a));
+}
+
+function everyWithIndex_1(self, p) {
+  const iterator = self[Symbol.iterator]();
+  let i = 0;
+  let next;
+
+  while (!(next = iterator.next()).done) {
+    if (!p(i, next.value)) {
+      if (typeof iterator.return === "function") {
+        iterator.return();
+      }
+
+      return false;
+    }
+
+    i++;
+  }
+
+  return true;
+}
+
+function filter_(self, p) {
+  return filterWithIndex_1(self, (_, a) => p(a));
+}
+/**
+ * @tsplus fluent fncts.Iterable filterMap
+ */
+
+
+function filterMap_(self, f) {
+  return filterMapWithIndex_1(self, (_, a) => f(a));
+}
+/**
+ * @tsplus fluent fncts.Iterable filterMapWithIndex
+ */
+
+
+function filterMapWithIndex_1(self, f) {
+  return tsplus_module_1.mkIterable(() => {
+    let i = 0;
+    const ia = self[Symbol.iterator]();
+    let va;
+    let done = false;
+    return {
+      next() {
+        if (done) {
+          this.return();
+        } // eslint-disable-next-line no-constant-condition
+
+
+        while (true) {
+          va = ia.next();
+
+          if (va.done) {
+            return this.return();
+          }
+
+          const mb = f(i++, va.value);
+
+          if (tsplus_module_2.isJust(mb)) {
+            return {
+              done,
+              value: mb.value
+            };
+          }
+        }
+      },
+
+      return(value) {
+        if (!done) {
+          done = true;
+
+          if (typeof ia.return === "function") {
+            ia.return();
+          }
+        }
+
+        return {
+          done,
+          value
+        };
+      }
+
+    };
+  });
+}
+
+function filterWithIndex_1(self, p) {
+  return tsplus_module_1.mkIterable(() => {
+    let done = false;
+    let i = 0;
+    const ia = self[Symbol.iterator]();
+    let va;
+    return {
+      next() {
+        if (done) {
+          return this.return();
+        } // eslint-disable-next-line no-constant-condition
+
+
+        while (true) {
+          va = ia.next();
+          if (va.done) return this.return();
+          if (p(i++, va.value)) return {
+            done,
+            value: va.value
+          };
+        }
+      },
+
+      return(value) {
+        if (!done) {
+          done = true;
+
+          if (typeof ia.return === "function") {
+            ia.return();
+          }
+        }
+
+        return {
+          done,
+          value
+        };
+      }
+
+    };
+  });
+}
+
+function find_(ia, predicate) {
+  for (const value of ia) {
+    if (predicate(value)) {
+      return tsplus_module_3.just(value);
+    }
+  }
+
+  return tsplus_module_3.nothing();
+}
+/**
+ * @tsplus fluent fncts.Iterable foldLeftWithIndex
+ */
+
+
+function foldLeftWithIndex_1(fa, b, f) {
+  let res = b;
+  let i = -1;
+
+  for (const value of fa) {
+    i += 1;
+    res = f(i, res, value);
+  }
+
+  return res;
+}
+/**
+ * @tsplus fluent fncts.Iterable foldLeft
+ */
+
+
+function foldLeft_(self, b, f) {
+  return foldLeftWithIndex_1(self, b, (_, b, a) => f(b, a));
+}
+/**
+ * @constrained
+ */
+
+
+function foldMap_(M) {
+  return (self, f) => foldMapWithIndexSelf_1(self)(M)((_, a) => f(a));
+}
+/**
+ * @tsplus getter fncts.Iterable foldMap
+ */
+
+
+function foldMapSelf(self) {
+  return M => f => foldMapWithIndexSelf_1(self)(M)((_, a) => f(a));
+}
+/**
+ * @constrained
+ */
+
+
+function foldMapWithIndex_(M) {
+  return (self, f) => {
+    let res = M.nat;
+    let n = -1;
+
+    for (const value of self) {
+      n += 1;
+      res = M.combine_(res, f(n, value));
+    }
+
+    return res;
+  };
+}
+/**
+ * @tsplus getter fncts.Iterable foldMapWithIndex
+ */
+
+
+function foldMapWithIndexSelf_1(self) {
+  return M => f => foldMapWithIndex_(M)(self, f);
+}
+/**
+ * @tsplus fluent fncts.Iterable foldRightWithIndex
+ */
+
+
+function foldRightWithIndex_1(self, b, f) {
+  let i = 0;
+  const iterator = self[Symbol.iterator]();
+  const go = tsplus_module_4.defer(() => {
+    const {
+      value: current,
+      done
+    } = iterator.next();
+
+    if (done) {
+      return b;
+    } else {
+      return f(i++, current, go);
+    }
+  });
+  return go;
+}
+/**
+ * @tsplus fluent fncts.Iterable foldRight
+ */
+
+
+function foldRight_(self, b, f) {
+  return foldRightWithIndex_1(self, b, (_, a, b) => f(a, b));
+}
+/**
+ * @tsplus fluent fncts.Iterable map
+ */
+
+
+function map_1(self, f) {
+  return mapWithIndex_1(self, (_, a) => f(a));
+}
+/**
+ * @tsplus fluent fncts.Iterable mapWithIndex
+ */
+
+
+function mapWithIndex_1(self, f) {
+  return tsplus_module_1.mkIterable(() => {
+    const ia = self[Symbol.iterator]();
+    let i = 0;
+    let done = false;
+    let va;
+    return {
+      next() {
+        if (done) {
+          return this.return();
+        }
+
+        va = ia.next();
+
+        if (va.done) {
+          return this.return();
+        }
+
+        return {
+          done,
+          value: f(i++, va.value)
+        };
+      },
+
+      return(value) {
+        if (!done) {
+          done = true;
+
+          if (typeof ia.return === "function") {
+            ia.return();
+          }
+        }
+
+        return {
+          done,
+          value
+        };
+      }
+
+    };
+  });
+}
+
+function handlePartitionMap(f, i, a, h) {
+  const bc = f(i, a);
+  return h === "Left" && bc._tag === "Left" ? {
+    emit: true,
+    value: bc.left
+  } : h === "Right" && bc._tag === "Right" ? {
+    emit: true,
+    value: bc.right
+  } : {
+    emit: false
+  };
+}
+
+function partitionMapWithIndexIterator(fa, f, h) {
+  const ia = fa[Symbol.iterator]();
+  let i = 0;
+  let done = false;
+  let va;
+  return {
+    next() {
+      if (done) {
+        return this.return();
+      } // eslint-disable-next-line no-constant-condition
+
+
+      while (true) {
+        va = ia.next();
+
+        if (va.done) {
+          return this.return();
+        }
+
+        const ra = handlePartitionMap(f, i++, va.value, h);
+
+        if (ra.emit) {
+          return {
+            done,
+            value: ra.value
+          };
+        }
+      }
+    },
+
+    return(value) {
+      if (!done) {
+        done = true;
+
+        if (typeof ia.return === "function") {
+          ia.return();
+        }
+      }
+
+      return {
+        done,
+        value
+      };
+    }
+
+  };
+}
+/**
+ * @tsplus fluent fncts.Iterable partitionMap
+ */
+
+
+function partitionMap_(self, f) {
+  return partitionMapWithIndex_1(self, (_, a) => f(a));
+}
+/**
+ * @tsplus fluent fncts.Iterable partitionMapWithIndex
+ */
+
+
+function partitionMapWithIndex_1(fa, f) {
+  return (0, _function.tuple)(tsplus_module_1.mkIterable(() => partitionMapWithIndexIterator(fa, f, "Left")), tsplus_module_1.mkIterable(() => partitionMapWithIndexIterator(fa, f, "Right")));
+}
+
+function handlePartition(predicate, i, a, h) {
+  return h === predicate(i, a) ? {
+    emit: true,
+    value: a
+  } : {
+    emit: false
+  };
+}
+
+function partitionWithIndexIterator(fa, predicate, h) {
+  const ia = fa[Symbol.iterator]();
+  let i = 0;
+  let done = false;
+  let va;
+  return {
+    next() {
+      if (done) {
+        return this.return();
+      } // eslint-disable-next-line no-constant-condition
+
+
+      while (true) {
+        va = ia.next();
+
+        if (va.done) {
+          return this.return();
+        }
+
+        const ra = handlePartition(predicate, i++, va.value, h);
+
+        if (ra.emit) {
+          return {
+            done,
+            value: ra.value
+          };
+        }
+      }
+    },
+
+    return(value) {
+      if (!done) {
+        done = true;
+
+        if (typeof ia.return === "function") {
+          ia.return();
+        }
+      }
+
+      return {
+        done,
+        value
+      };
+    }
+
+  };
+}
+
+function partition_(self, p) {
+  return partitionWithIndex_1(self, (_, a) => p(a));
+}
+
+function partitionWithIndex_1(self, p) {
+  return (0, _function.tuple)(tsplus_module_1.mkIterable(() => partitionWithIndexIterator(self, p, false)), tsplus_module_1.mkIterable(() => partitionWithIndexIterator(self, p, true)));
+}
+/**
+ * @tsplus getter fncts.Iterable size
+ */
+
+
+function size(self) {
+  let len = 0;
+
+  for (const _ of self) {
+    len += 1;
+  }
+
+  return len;
+}
+/**
+ * @tsplus fluent fncts.Iterable take
+ */
+
+
+function take(self, n) {
+  return tsplus_module_1.mkIterable(() => {
+    let done = false;
+    const i = 0;
+    let value;
+    const iterator = self[Symbol.iterator]();
+    return {
+      next() {
+        if (done || i > n) {
+          return this.return();
+        }
+
+        value = iterator.next();
+
+        if (value.done) {
+          this.return();
+        }
+
+        return value;
+      },
+
+      return(value) {
+        if (!done) {
+          done = true;
+
+          if (typeof iterator.return === "function") {
+            iterator.return();
+          }
+        }
+
+        return {
+          done: true,
+          value
+        };
+      }
+
+    };
+  });
+}
+/**
+ * @tsplus fluent fncts.Iterable zipWith
+ */
+
+
+function zipWith_(self, fb, f) {
+  return tsplus_module_1.mkIterable(() => {
+    let done = false;
+    const ia = self[Symbol.iterator]();
+    const ib = fb[Symbol.iterator]();
+    return {
+      next() {
+        if (done) {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          return this.return();
+        }
+
+        const va = ia.next();
+        const vb = ib.next();
+        return va.done || vb.done ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        this.return() : {
+          done: false,
+          value: f(va.value, vb.value)
+        };
+      },
+
+      return(value) {
+        if (!done) {
+          done = true;
+
+          if (typeof ia.return === "function") {
+            ia.return();
+          }
+
+          if (typeof ib.return === "function") {
+            ib.return();
+          }
+        }
+
+        return {
+          done: true,
+          value
+        };
+      }
+
+    };
+  });
+}
+/**
+ * @tsplus getter fncts.Iterable zipWithIndex
+ */
+
+
+function zipWithIndex(self) {
+  return tsplus_module_1.mkIterable(() => {
+    let n = 0;
+    let done = false;
+    const iterator = self[Symbol.iterator]();
+    return {
+      next() {
+        if (done) {
+          this.return();
+        }
+
+        const v = iterator.next();
+        return v.done ? this.return() : {
+          done: false,
+          value: [n++, v.value]
+        };
+      },
+
+      return(value) {
+        if (!done) {
+          done = true;
+
+          if (typeof iterator.return === "function") {
+            iterator.return();
+          }
+        }
+
+        return {
+          done: true,
+          value
+        };
+      }
+
+    };
+  });
+}
+//# sourceMappingURL=api.cjs.map