@fncts/base 0.0.20 → 0.0.21

package/_cjs/collection/Iterable/api.cjs

@@ -3,33 +3,32 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.ap_ = ap_;
-exports.append_ = append_;
+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.concat = concat;
+exports.corresponds = corresponds;
+exports.crossWith = crossWith;
+exports.every = every;
+exports.everyWithIndex = void 0;
+exports.filter = filter;
+exports.filterMap = filterMap;
+exports.filterWithIndex = exports.filterMapWithIndex = void 0;
+exports.find = find;
 exports.findIndex = findIndex;
-exports.find_ = find_;
-exports.foldMapWithIndex_ = exports.foldLeft_ = exports.foldLeftWithIndex_ = exports.flatMap_ = void 0;
-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.foldLeftWithIndex = exports.foldLeft = exports.flatMap = void 0;
+exports.foldMap = foldMap;
+exports.foldMapWithIndex = void 0;
+exports.foldRight = foldRight;
+exports.mapWithIndex = exports.map = exports.foldRightWithIndex = void 0;
+exports.partition = partition;
+exports.partitionMap = partitionMap;
+exports.partitionWithIndex = exports.partitionMapWithIndex = void 0;
 exports.size = size;
 exports.sum = sum;
 exports.take = take;
+exports.zipWith = zipWith;
 exports.zipWithIndex = zipWithIndex;
-exports.zipWith_ = zipWith_;
 
 var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/Iterable/constructors"));
 
@@ -45,88 +44,92 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "functio
 
 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 foldLeft_ = foldLeft_1;
-exports.foldLeft_ = foldLeft_;
-const foldMapWithIndex_ = foldMapWithIndex_1;
-exports.foldMapWithIndex_ = foldMapWithIndex_;
-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_;
+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 foldLeft = foldLeft_1;
+exports.foldLeft = foldLeft;
+const foldMapWithIndex = foldMapWithIndex_1;
+exports.foldMapWithIndex = foldMapWithIndex;
+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
+ * @tsplus pipeable fncts.Iterable ap
  */
-function ap_(self, fa) {
-  return flatMap_1(self, f => map_1(fa, f));
+function ap(fa) {
+  return self => {
+    return flatMap_1(f => map_1(f)(fa))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Iterable append
+ * @tsplus pipeable 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();
-        }
+function append(b) {
+  return self => {
+    return tsplus_module_1.makeIterable(() => {
+      let done = false;
+      const ia = self[Symbol.iterator]();
+      let va;
+      return {
+        next() {
+          if (done) {
+            return this.return();
+          }
 
-        va = ia.next();
+          va = ia.next();
+
+          if (va.done) {
+            done = true;
+            return {
+              done: false,
+              value: b
+            };
+          }
 
-        if (va.done) {
-          done = true;
           return {
-            done: false,
-            value: b
+            done,
+            value: va.value
           };
-        }
+        },
 
-        return {
-          done,
-          value: va.value
-        };
-      },
+        return(value) {
+          done = true;
 
-      return(value) {
-        done = true;
+          if (!done) {
+            done = true;
+          }
 
-        if (!done) {
-          done = true;
-        }
+          if (typeof ia.return === "function") {
+            ia.return();
+          }
 
-        if (typeof ia.return === "function") {
-          ia.return();
+          return {
+            done,
+            value
+          };
         }
 
-        return {
-          done,
-          value
-        };
-      }
-
-    };
-  });
+      };
+    });
+  };
 }
 /**
  * @tsplus getter fncts.Iterable asIterable
@@ -137,437 +140,477 @@ function asIterable(self) {
   return self;
 }
 /**
- * @tsplus fluent fncts.Iterable flatMap
+ * @tsplus pipeable 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;
+function flatMap_1(f) {
+  return self => {
+    return tsplus_module_1.makeIterable(() => {
+      const ia = self[Symbol.iterator]();
+      let ib;
+      let va;
+      let vb;
+      let done = false;
 
-    const pullA = onDone => {
-      va = ia.next();
+      const pullA = onDone => {
+        va = ia.next();
 
-      if (va.done) {
-        return onDone();
-      }
+        if (va.done) {
+          return onDone();
+        }
 
-      ib = f(va.value)[Symbol.iterator]();
-      return pullB(onDone);
-    };
+        ib = f(va.value)[Symbol.iterator]();
+        return pullB(onDone);
+      };
 
-    const pullB = onDone => {
-      if (!ib) {
-        return pullA(onDone);
-      }
+      const pullB = onDone => {
+        if (!ib) {
+          return pullA(onDone);
+        }
 
-      vb = ib.next();
+        vb = ib.next();
 
-      if (!vb.done) {
-        return {
-          done,
-          value: vb.value
-        };
-      }
+        if (!vb.done) {
+          return {
+            done,
+            value: vb.value
+          };
+        }
 
-      return pullA(onDone);
-    };
+        return pullA(onDone);
+      };
 
-    return {
-      next() {
-        if (done) {
-          return this.return();
-        }
+      return {
+        next() {
+          if (done) {
+            return this.return();
+          }
 
-        return pullB(() => this.return());
-      },
+          return pullB(() => this.return());
+        },
 
-      return(value) {
-        if (!done) {
-          done = true;
+        return(value) {
+          if (!done) {
+            done = true;
 
-          if (typeof ia.return === "function") {
-            ia.return();
-          }
+            if (typeof ia.return === "function") {
+              ia.return();
+            }
 
-          if (ib && typeof ib.return === "function") {
-            ib.return();
+            if (ib && typeof ib.return === "function") {
+              ib.return();
+            }
           }
-        }
 
-        return {
-          done,
-          value
-        };
-      }
+          return {
+            done,
+            value
+          };
+        }
 
-    };
-  });
+      };
+    });
+  };
 }
 /**
- * @tsplus fluent fncts.Iterable concat
+ * @tsplus pipeable 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();
+function concat(ib) {
+  return self => {
+    return tsplus_module_1.makeIterable(() => {
+      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();
+            }
 
-          if (r.done) {
-            doneA = true;
-            iterB = ib[Symbol.iterator]();
-            return iterB.next();
+            return r;
           }
 
-          return r;
+          return iterB.next();
         }
 
-        return iterB.next();
-      }
-
-    };
-  });
+      };
+    });
+  };
 }
 /**
- * @tsplus fluent fncts.Iterable corresponds
+ * @tsplus pipeable 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
+function corresponds(right, f) {
+  return left => {
+    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();
+    while (true) {
+      const lnext = leftIterator.next();
+      const rnext = rightIterator.next();
 
-    if (lnext.done !== rnext.done) {
-      return false;
-    }
+      if (lnext.done !== rnext.done) {
+        return false;
+      }
 
-    if (lnext.done) {
-      return true;
-    }
+      if (lnext.done) {
+        return true;
+      }
 
-    if (!f(lnext.value, rnext.value)) {
-      return false;
+      if (!f(lnext.value, rnext.value)) {
+        return false;
+      }
     }
-  }
+  };
 }
 /**
- * @tsplus fluent fncts.Iterable crossWith
+ * @tsplus pipeable fncts.Iterable crossWith
  */
 
 
-function crossWith_(self, fb, f) {
-  return flatMap_1(self, a => map_1(fb, b => f(a, b)));
+function crossWith(fb, f) {
+  return self => {
+    return flatMap_1(a => map_1(b => f(a, b))(fb))(self);
+  };
 }
 
-function every_(self, p) {
-  return everyWithIndex_1(self, (_, a) => p(a));
+function every(p) {
+  return self => {
+    return everyWithIndex_1((_, a) => p(a))(self);
+  };
 }
 
-function everyWithIndex_1(self, p) {
-  const iterator = self[Symbol.iterator]();
-  let i = 0;
-  let next;
+function everyWithIndex_1(p) {
+  return self => {
+    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();
+        }
 
-  while (!(next = iterator.next()).done) {
-    if (!p(i, next.value)) {
-      if (typeof iterator.return === "function") {
-        iterator.return();
+        return false;
       }
 
-      return false;
+      i++;
     }
 
-    i++;
-  }
-
-  return true;
+    return true;
+  };
 }
 
-function filter_(self, p) {
-  return filterWithIndex_1(self, (_, a) => p(a));
+function filter(p) {
+  return self => {
+    return filterWithIndex_1((_, a) => p(a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Iterable filterMap
+ * @tsplus pipeable fncts.Iterable filterMap
  */
 
 
-function filterMap_(self, f) {
-  return filterMapWithIndex_1(self, (_, a) => f(a));
+function filterMap(f) {
+  return self => {
+    return filterMapWithIndex_1((_, a) => f(a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Iterable filterMapWithIndex
+ * @tsplus pipeable 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
+function filterMapWithIndex_1(f) {
+  return self => {
+    return tsplus_module_1.makeIterable(() => {
+      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();
+          while (true) {
+            va = ia.next();
 
-          if (va.done) {
-            return this.return();
-          }
+            if (va.done) {
+              return this.return();
+            }
 
-          const mb = f(i++, va.value);
+            const mb = f(i++, va.value);
 
-          if (tsplus_module_2.isJust(mb)) {
-            return {
-              done,
-              value: mb.value
-            };
+            if (tsplus_module_2.isJust(mb)) {
+              return {
+                done,
+                value: mb.value
+              };
+            }
           }
-        }
-      },
+        },
 
-      return(value) {
-        if (!done) {
-          done = true;
+        return(value) {
+          if (!done) {
+            done = true;
 
-          if (typeof ia.return === "function") {
-            ia.return();
+            if (typeof ia.return === "function") {
+              ia.return();
+            }
           }
-        }
 
-        return {
-          done,
-          value
-        };
-      }
+          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
+function filterWithIndex_1(p) {
+  return self => {
+    return tsplus_module_1.makeIterable(() => {
+      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
-          };
-        }
-      },
+          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;
+        return(value) {
+          if (!done) {
+            done = true;
 
-          if (typeof ia.return === "function") {
-            ia.return();
+            if (typeof ia.return === "function") {
+              ia.return();
+            }
           }
-        }
 
-        return {
-          done,
-          value
-        };
-      }
+          return {
+            done,
+            value
+          };
+        }
 
-    };
-  });
+      };
+    });
+  };
 }
 
-function find_(ia, predicate) {
-  for (const value of ia) {
-    if (predicate(value)) {
-      return tsplus_module_3.just(value);
+function find(predicate) {
+  return ia => {
+    for (const value of ia) {
+      if (predicate(value)) {
+        return tsplus_module_3.just(value);
+      }
     }
-  }
 
-  return tsplus_module_3.nothing();
+    return tsplus_module_3.nothing();
+  };
 }
 /**
- * @tsplus fluent fncts.Iterable findIndex
+ * @tsplus pipeable fncts.Iterable findIndex
  */
 
 
-function findIndex(self, p) {
-  let i = 0;
+function findIndex(p) {
+  return self => {
+    let i = 0;
 
-  for (const value of self) {
-    if (p(value)) {
-      return i;
-    }
+    for (const value of self) {
+      if (p(value)) {
+        return i;
+      }
 
-    i++;
-  }
+      i++;
+    }
 
-  return -1;
+    return -1;
+  };
 }
 /**
- * @tsplus fluent fncts.Iterable foldLeftWithIndex
+ * @tsplus pipeable fncts.Iterable foldLeftWithIndex
  */
 
 
-function foldLeftWithIndex_1(fa, b, f) {
-  let res = b;
-  let i = -1;
+function foldLeftWithIndex_1(b, f) {
+  return fa => {
+    let res = b;
+    let i = -1;
 
-  for (const value of fa) {
-    i += 1;
-    res = f(i, res, value);
-  }
+    for (const value of fa) {
+      i += 1;
+      res = f(i, res, value);
+    }
 
-  return res;
+    return res;
+  };
 }
 /**
- * @tsplus fluent fncts.Iterable foldLeft
+ * @tsplus pipeable fncts.Iterable foldLeft
  */
 
 
-function foldLeft_1(self, b, f) {
-  return foldLeftWithIndex_1(self, b, (_, b, a) => f(b, a));
+function foldLeft_1(b, f) {
+  return self => {
+    return foldLeftWithIndex_1(b, (_, b, a) => f(b, a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Iterable foldMap
+ * @tsplus pipeable fncts.Iterable foldMap
  */
 
 
-function foldMap_(self, f,
+function foldMap(f,
 /** @tsplus auto */
 M) {
-  return foldMapWithIndex_1(self, (_, a) => f(a), M);
+  return self => {
+    return foldMapWithIndex_1((_, a) => f(a), M)(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Iterable foldMapWithIndex
+ * @tsplus pipeable fncts.Iterable foldMapWithIndex
  */
 
 
-function foldMapWithIndex_1(self, f,
+function foldMapWithIndex_1(f,
 /** @tsplus auto */
 M) {
-  let res = M.nat;
-  let n = -1;
+  return self => {
+    let res = M.nat;
+    let n = -1;
 
-  for (const value of self) {
-    n += 1;
-    res = M.combine(res, f(n, value));
-  }
+    for (const value of self) {
+      n += 1;
+      res = M.combine(res, f(n, value));
+    }
 
-  return res;
+    return res;
+  };
 }
 /**
- * @tsplus fluent fncts.Iterable foldRightWithIndex
+ * @tsplus pipeable 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;
+function foldRightWithIndex_1(b, f) {
+  return self => {
+    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
+ * @tsplus pipeable fncts.Iterable foldRight
  */
 
 
-function foldRight_(self, b, f) {
-  return foldRightWithIndex_1(self, b, (_, a, b) => f(a, b));
+function foldRight(b, f) {
+  return self => {
+    return foldRightWithIndex_1(b, (_, a, b) => f(a, b))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Iterable map
+ * @tsplus pipeable fncts.Iterable map
  */
 
 
-function map_1(self, f) {
-  return mapWithIndex_1(self, (_, a) => f(a));
+function map_1(f) {
+  return self => {
+    return mapWithIndex_1((_, a) => f(a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Iterable mapWithIndex
+ * @tsplus pipeable 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();
-        }
+function mapWithIndex_1(f) {
+  return self => {
+    return tsplus_module_1.makeIterable(() => {
+      const ia = self[Symbol.iterator]();
+      let i = 0;
+      let done = false;
+      let va;
+      return {
+        next() {
+          if (done) {
+            return this.return();
+          }
 
-        va = ia.next();
+          va = ia.next();
 
-        if (va.done) {
-          return this.return();
-        }
+          if (va.done) {
+            return this.return();
+          }
 
-        return {
-          done,
-          value: f(i++, va.value)
-        };
-      },
+          return {
+            done,
+            value: f(i++, va.value)
+          };
+        },
 
-      return(value) {
-        if (!done) {
-          done = true;
+        return(value) {
+          if (!done) {
+            done = true;
 
-          if (typeof ia.return === "function") {
-            ia.return();
+            if (typeof ia.return === "function") {
+              ia.return();
+            }
           }
-        }
 
-        return {
-          done,
-          value
-        };
-      }
+          return {
+            done,
+            value
+          };
+        }
 
-    };
-  });
+      };
+    });
+  };
 }
 
 function handlePartitionMap(f, i, a, h) {
@@ -632,20 +675,24 @@ function partitionMapWithIndexIterator(fa, f, h) {
   };
 }
 /**
- * @tsplus fluent fncts.Iterable partitionMap
+ * @tsplus pipeable fncts.Iterable partitionMap
  */
 
 
-function partitionMap_(self, f) {
-  return partitionMapWithIndex_1(self, (_, a) => f(a));
+function partitionMap(f) {
+  return self => {
+    return partitionMapWithIndex_1((_, a) => f(a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Iterable partitionMapWithIndex
+ * @tsplus pipeable 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 partitionMapWithIndex_1(f) {
+  return fa => {
+    return (0, _function.tuple)(tsplus_module_1.makeIterable(() => partitionMapWithIndexIterator(fa, f, "Left")), tsplus_module_1.makeIterable(() => partitionMapWithIndexIterator(fa, f, "Right")));
+  };
 }
 
 function handlePartition(predicate, i, a, h) {
@@ -705,12 +752,16 @@ function partitionWithIndexIterator(fa, predicate, h) {
   };
 }
 
-function partition_(self, p) {
-  return partitionWithIndex_1(self, (_, a) => p(a));
+function partition(p) {
+  return self => {
+    return partitionWithIndex_1((_, a) => p(a))(self);
+  };
 }
 
-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)));
+function partitionWithIndex_1(p) {
+  return self => {
+    return (0, _function.tuple)(tsplus_module_1.makeIterable(() => partitionWithIndexIterator(self, p, false)), tsplus_module_1.makeIterable(() => partitionWithIndexIterator(self, p, true)));
+  };
 }
 /**
  * @tsplus getter fncts.Iterable size
@@ -732,100 +783,102 @@ function size(self) {
 
 
 function sum(self) {
-  return foldLeft_1(self, 0, (b, a) => b + a);
+  return foldLeft_1(0, (b, a) => b + a)(self);
 }
 /**
- * @tsplus fluent fncts.Iterable take
+ * @tsplus pipeable fncts.Iterable take
  */
 
 
-function take(self, n) {
-  return tsplus_module_1.mkIterable(() => {
-    let done = false;
-    let i = 0;
-    let value;
-    const iterator = self[Symbol.iterator]();
-    return {
-      next() {
-        if (done || i >= n) {
-          return this.return();
-        }
+function take(n) {
+  return self => {
+    return tsplus_module_1.makeIterable(() => {
+      let done = false;
+      let i = 0;
+      let value;
+      const iterator = self[Symbol.iterator]();
+      return {
+        next() {
+          if (done || i >= n) {
+            return this.return();
+          }
 
-        value = iterator.next();
-        i++;
+          value = iterator.next();
+          i++;
 
-        if (value.done) {
-          this.return();
-        }
+          if (value.done) {
+            this.return();
+          }
 
-        return value;
-      },
+          return value;
+        },
 
-      return(value) {
-        if (!done) {
-          done = true;
+        return(value) {
+          if (!done) {
+            done = true;
 
-          if (typeof iterator.return === "function") {
-            iterator.return();
+            if (typeof iterator.return === "function") {
+              iterator.return();
+            }
           }
-        }
 
-        return {
-          done: true,
-          value
-        };
-      }
+          return {
+            done: true,
+            value
+          };
+        }
 
-    };
-  });
+      };
+    });
+  };
 }
 /**
- * @tsplus fluent fncts.Iterable zipWith
+ * @tsplus pipeable 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();
-        }
+function zipWith(fb, f) {
+  return self => {
+    return tsplus_module_1.makeIterable(() => {
+      let done = false;
+      const ia = self[Symbol.iterator]();
+      const ib = fb[Symbol.iterator]();
+      return {
+        next() {
+          if (done) {
+            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)
-        };
-      },
+          const va = ia.next();
+          const vb = ib.next();
+          return va.done || vb.done ? this.return() : {
+            done: false,
+            value: f(va.value, vb.value)
+          };
+        },
 
-      return(value) {
-        if (!done) {
-          done = true;
+        return(value) {
+          if (!done) {
+            done = true;
 
-          if (typeof ia.return === "function") {
-            ia.return();
-          }
+            if (typeof ia.return === "function") {
+              ia.return();
+            }
 
-          if (typeof ib.return === "function") {
-            ib.return();
+            if (typeof ib.return === "function") {
+              ib.return();
+            }
           }
-        }
 
-        return {
-          done: true,
-          value
-        };
-      }
+          return {
+            done: true,
+            value
+          };
+        }
 
-    };
-  });
+      };
+    });
+  };
 }
 /**
  * @tsplus getter fncts.Iterable zipWithIndex
@@ -833,7 +886,7 @@ function zipWith_(self, fb, f) {
 
 
 function zipWithIndex(self) {
-  return tsplus_module_1.mkIterable(() => {
+  return tsplus_module_1.makeIterable(() => {
     let n = 0;
     let done = false;
     const iterator = self[Symbol.iterator]();