@fncts/base 0.0.19 → 0.0.21

package/_src/collection/Iterable/api.ts

@@ -4,44 +4,48 @@ import { Iterable } from "@fncts/base/collection/Iterable/definition";
 import { tuple } from "@fncts/base/data/function";
 
 /**
- * @tsplus fluent fncts.Iterable ap
+ * @tsplus pipeable fncts.Iterable ap
  */
-export function ap_<A, B>(self: Iterable<(a: A) => B>, fa: Iterable<A>): Iterable<B> {
-  return self.flatMap((f) => fa.map(f));
+export function ap<A>(fa: Iterable<A>) {
+  return <B>(self: Iterable<(a: A) => B>): Iterable<B> => {
+    return self.flatMap((f) => fa.map(f));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Iterable append
+ * @tsplus pipeable fncts.Iterable append
  */
-export function append_<A, B>(self: Iterable<A>, b: B): Iterable<A | B> {
-  return Iterable.make<A | B>(() => {
-    let done = false;
-    const ia = self[Symbol.iterator]();
-    let va: IteratorResult<A>;
-    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?: unknown) {
-        done = true;
-        if (!done) {
+export function append<B>(b: B) {
+  return <A>(self: Iterable<A>): Iterable<A | B> => {
+    return Iterable.make<A | B>(() => {
+      let done = false;
+      const ia = self[Symbol.iterator]();
+      let va: IteratorResult<A>;
+      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?: unknown) {
           done = true;
-        }
-        if (typeof ia.return === "function") {
-          ia.return();
-        }
-        return { done, value };
-      },
-    };
-  });
+          if (!done) {
+            done = true;
+          }
+          if (typeof ia.return === "function") {
+            ia.return();
+          }
+          return { done, value };
+        },
+      };
+    });
+  };
 }
 
 /**
@@ -52,375 +56,413 @@ export function asIterable<A>(self: Iterable<A>): Iterable<A> {
 }
 
 /**
- * @tsplus fluent fncts.Iterable flatMap
+ * @tsplus pipeable fncts.Iterable flatMap
  */
-export function flatMap_<A, B>(self: Iterable<A>, f: (a: A) => Iterable<B>): Iterable<B> {
-  return Iterable.make<B>(() => {
-    const ia = self[Symbol.iterator]();
-    let ib: Iterator<B>;
-    let va: IteratorResult<A>;
-    let vb: IteratorResult<B>;
-    let done = false;
-
-    const pullA = (onDone: () => IteratorResult<B>): IteratorResult<B> => {
-      va = ia.next();
-      if (va.done) {
-        return onDone();
-      }
-      ib = f(va.value)[Symbol.iterator]();
-      return pullB(onDone);
-    };
-    const pullB = (onDone: () => IteratorResult<B>): IteratorResult<B> => {
-      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!();
+export function flatMap<A, B>(f: (a: A) => Iterable<B>) {
+  return (self: Iterable<A>): Iterable<B> => {
+    return Iterable.make<B>(() => {
+      const ia    = self[Symbol.iterator]();
+      let ib: Iterator<B>;
+      let va: IteratorResult<A>;
+      let vb: IteratorResult<B>;
+      let done    = false;
+      const pullA = (onDone: () => IteratorResult<B>): IteratorResult<B> => {
+        va = ia.next();
+        if (va.done) {
+          return onDone();
         }
-        return pullB(() => this.return!());
-      },
-      return(value?: unknown) {
-        if (!done) {
-          done = true;
-          if (typeof ia.return === "function") {
-            ia.return();
+        ib = f(va.value)[Symbol.iterator]();
+        return pullB(onDone);
+      };
+      const pullB = (onDone: () => IteratorResult<B>): IteratorResult<B> => {
+        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!();
           }
-          if (ib && typeof ib.return === "function") {
-            ib.return();
+          return pullB(() => this.return!());
+        },
+        return(value?: unknown) {
+          if (!done) {
+            done = true;
+            if (typeof ia.return === "function") {
+              ia.return();
+            }
+            if (ib && typeof ib.return === "function") {
+              ib.return();
+            }
           }
-        }
-        return { done, value };
-      },
-    };
-  });
+          return { done, value };
+        },
+      };
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.Iterable concat
- */
-export function concat_<A>(self: Iterable<A>, ib: Iterable<A>): Iterable<A> {
-  return Iterable.make(() => {
-    const iterA = self[Symbol.iterator]();
-    let doneA   = false;
-    let iterB: Iterator<A>;
-    return {
-      next() {
-        if (!doneA) {
-          const r = iterA.next();
-          if (r.done) {
-            doneA = true;
-            iterB = ib[Symbol.iterator]();
-            return iterB.next();
+ * @tsplus pipeable fncts.Iterable concat
+ */
+export function concat<A>(ib: Iterable<A>) {
+  return (self: Iterable<A>): Iterable<A> => {
+    return Iterable.make(() => {
+      const iterA = self[Symbol.iterator]();
+      let doneA   = false;
+      let iterB: Iterator<A>;
+      return {
+        next() {
+          if (!doneA) {
+            const r = iterA.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
  */
-export function corresponds_<A, B>(left: Iterable<A>, right: Iterable<B>, f: (a: A, b: B) => boolean): boolean {
-  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;
+export function corresponds<A, B>(right: Iterable<B>, f: (a: A, b: B) => boolean) {
+  return (left: Iterable<A>): boolean => {
+    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
+ * @tsplus pipeable fncts.Iterable crossWith
  */
-export function crossWith_<A, B, C>(self: Iterable<A>, fb: Iterable<B>, f: (a: A, b: B) => C): Iterable<C> {
-  return self.flatMap((a) => fb.map((b) => f(a, b)));
+export function crossWith<A, B, C>(fb: Iterable<B>, f: (a: A, b: B) => C) {
+  return (self: Iterable<A>): Iterable<C> => {
+    return self.flatMap((a) => fb.map((b) => f(a, b)));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Iterable every
+ * @tsplus pipeable fncts.Iterable every
  */
-export function every_<A, B extends A>(self: Iterable<A>, p: Refinement<A, B>): boolean;
-export function every_<A>(self: Iterable<A>, p: Predicate<A>): boolean;
-export function every_<A>(self: Iterable<A>, p: Predicate<A>): boolean {
-  return self.everyWithIndex((_, a) => p(a));
+export function every<A, B extends A>(p: Refinement<A, B>): (self: Iterable<A>) => boolean;
+export function every<A>(p: Predicate<A>): (self: Iterable<A>) => boolean;
+export function every<A>(p: Predicate<A>) {
+  return (self: Iterable<A>): boolean => {
+    return self.everyWithIndex((_, a) => p(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Iterable everyWithIndex
+ * @tsplus pipeable fncts.Iterable everyWithIndex
  */
-export function everyWithIndex_<A, B extends A>(self: Iterable<A>, p: RefinementWithIndex<number, A, B>): boolean;
-export function everyWithIndex_<A>(self: Iterable<A>, p: PredicateWithIndex<number, A>): boolean;
-export function everyWithIndex_<A>(self: Iterable<A>, p: PredicateWithIndex<number, A>): boolean {
-  const iterator = self[Symbol.iterator]();
-  let i          = 0;
-  let next: IteratorResult<A>;
-  while (!(next = iterator.next()).done) {
-    if (!p(i, next.value)) {
-      if (typeof iterator.return === "function") {
-        iterator.return();
+export function everyWithIndex<A, B extends A>(p: RefinementWithIndex<number, A, B>): (self: Iterable<A>) => boolean;
+export function everyWithIndex<A>(p: PredicateWithIndex<number, A>): (self: Iterable<A>) => boolean;
+export function everyWithIndex<A>(p: PredicateWithIndex<number, A>) {
+  return (self: Iterable<A>): boolean => {
+    const iterator = self[Symbol.iterator]();
+    let i          = 0;
+    let next: IteratorResult<A>;
+    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;
+  };
 }
 
 /**
- * @tsplus fluent fncts.Iterable filter
+ * @tsplus pipeable fncts.Iterable filter
  */
-export function filter_<A, B extends A>(self: Iterable<A>, p: Refinement<A, B>): Iterable<B>;
-export function filter_<A>(self: Iterable<A>, p: Predicate<A>): Iterable<A>;
-export function filter_<A>(self: Iterable<A>, p: Predicate<A>): Iterable<A> {
-  return self.filterWithIndex((_, a) => p(a));
+export function filter<A, B extends A>(p: Refinement<A, B>): (self: Iterable<A>) => Iterable<B>;
+export function filter<A>(p: Predicate<A>): (self: Iterable<A>) => Iterable<A>;
+export function filter<A>(p: Predicate<A>) {
+  return (self: Iterable<A>): Iterable<A> => {
+    return self.filterWithIndex((_, a) => p(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Iterable filterMap
+ * @tsplus pipeable fncts.Iterable filterMap
  */
-export function filterMap_<A, B>(self: Iterable<A>, f: (a: A) => Maybe<B>): Iterable<B> {
-  return self.filterMapWithIndex((_, a) => f(a));
+export function filterMap<A, B>(f: (a: A) => Maybe<B>) {
+  return (self: Iterable<A>): Iterable<B> => {
+    return self.filterMapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Iterable filterMapWithIndex
+ * @tsplus pipeable fncts.Iterable filterMapWithIndex
  */
-export function filterMapWithIndex_<A, B>(self: Iterable<A>, f: (i: number, a: A) => Maybe<B>): Iterable<B> {
-  return Iterable.make<B>(() => {
-    let i    = 0;
-    const ia = self[Symbol.iterator]();
-    let va: IteratorResult<A>;
-    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!();
+export function filterMapWithIndex<A, B>(f: (i: number, a: A) => Maybe<B>) {
+  return (self: Iterable<A>): Iterable<B> => {
+    return Iterable.make<B>(() => {
+      let i    = 0;
+      const ia = self[Symbol.iterator]();
+      let va: IteratorResult<A>;
+      let done = false;
+      return {
+        next() {
+          if (done) {
+            this.return!();
           }
-          const mb = f(i++, va.value);
-          if (mb.isJust()) {
-            return { done, value: mb.value };
+          // 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 (mb.isJust()) {
+              return { done, value: mb.value };
+            }
           }
-        }
-      },
-      return(value?: unknown) {
-        if (!done) {
-          done = true;
-          if (typeof ia.return === "function") {
-            ia.return();
+        },
+        return(value?: unknown) {
+          if (!done) {
+            done = true;
+            if (typeof ia.return === "function") {
+              ia.return();
+            }
           }
-        }
-        return { done, value };
-      },
-    };
-  });
+          return { done, value };
+        },
+      };
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.Iterable filterWithIndex
+ * @tsplus pipeable fncts.Iterable filterWithIndex
  */
-export function filterWithIndex_<A, B extends A>(self: Iterable<A>, p: RefinementWithIndex<number, A, B>): Iterable<B>;
-export function filterWithIndex_<A>(self: Iterable<A>, p: PredicateWithIndex<number, A>): Iterable<A>;
-export function filterWithIndex_<A>(self: Iterable<A>, p: PredicateWithIndex<number, A>): Iterable<A> {
-  return Iterable.make<A>(() => {
-    let done = false;
-    let i    = 0;
-    const ia = self[Symbol.iterator]();
-    let va: IteratorResult<A>;
-    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?: unknown) {
-        if (!done) {
-          done = true;
-          if (typeof ia.return === "function") {
-            ia.return();
+export function filterWithIndex<A, B extends A>(
+  p: RefinementWithIndex<number, A, B>,
+): (self: Iterable<A>) => Iterable<B>;
+export function filterWithIndex<A>(p: PredicateWithIndex<number, A>): (self: Iterable<A>) => Iterable<A>;
+export function filterWithIndex<A>(p: PredicateWithIndex<number, A>) {
+  return (self: Iterable<A>): Iterable<A> => {
+    return Iterable.make<A>(() => {
+      let done = false;
+      let i    = 0;
+      const ia = self[Symbol.iterator]();
+      let va: IteratorResult<A>;
+      return {
+        next() {
+          if (done) {
+            return this.return!();
           }
-        }
-        return { done, value };
-      },
-    };
-  });
+          // 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?: unknown) {
+          if (!done) {
+            done = true;
+            if (typeof ia.return === "function") {
+              ia.return();
+            }
+          }
+          return { done, value };
+        },
+      };
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.Iterable find
+ * @tsplus pipeable fncts.Iterable find
  */
-export function find_<A, B extends A>(ia: Iterable<A>, refinement: Refinement<A, B>): Maybe<B>;
-export function find_<A>(ia: Iterable<A>, predicate: Predicate<A>): Maybe<A>;
-export function find_<A>(ia: Iterable<A>, predicate: Predicate<A>): Maybe<A> {
-  for (const value of ia) {
-    if (predicate(value)) {
-      return Just(value);
+export function find<A, B extends A>(refinement: Refinement<A, B>): (ia: Iterable<A>) => Maybe<B>;
+export function find<A>(predicate: Predicate<A>): (ia: Iterable<A>) => Maybe<A>;
+export function find<A>(predicate: Predicate<A>) {
+  return (ia: Iterable<A>): Maybe<A> => {
+    for (const value of ia) {
+      if (predicate(value)) {
+        return Just(value);
+      }
     }
-  }
-  return Nothing();
+    return Nothing();
+  };
 }
 
 /**
- * @tsplus fluent fncts.Iterable findIndex
+ * @tsplus pipeable fncts.Iterable findIndex
  */
-export function findIndex<A>(self: Iterable<A>, p: Predicate<A>): number {
-  let i = 0;
-  for (const value of self) {
-    if (p(value)) {
-      return i;
+export function findIndex<A>(p: Predicate<A>) {
+  return (self: Iterable<A>): number => {
+    let i = 0;
+    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
  */
-export function foldLeftWithIndex_<A, B>(fa: Iterable<A>, b: B, f: (i: number, b: B, a: A) => B): B {
-  let res = b;
-  let i   = -1;
-  for (const value of fa) {
-    i  += 1;
-    res = f(i, res, value);
-  }
-  return res;
+export function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B) {
+  return (fa: Iterable<A>): B => {
+    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
+ * @tsplus pipeable fncts.Iterable foldLeft
  */
-export function foldLeft_<A, B>(self: Iterable<A>, b: B, f: (b: B, a: A) => B): B {
-  return self.foldLeftWithIndex(b, (_, b, a) => f(b, a));
+export function foldLeft<A, B>(b: B, f: (b: B, a: A) => B) {
+  return (self: Iterable<A>): B => {
+    return self.foldLeftWithIndex(b, (_, b, a) => f(b, a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Iterable foldMap
+ * @tsplus pipeable fncts.Iterable foldMap
  */
-export function foldMap_<A, M>(self: Iterable<A>, f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M {
-  return self.foldMapWithIndex((_, a) => f(a), M);
+export function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>) {
+  return (self: Iterable<A>): M => {
+    return self.foldMapWithIndex((_, a) => f(a), M);
+  };
 }
 
 /**
- * @tsplus fluent fncts.Iterable foldMapWithIndex
+ * @tsplus pipeable fncts.Iterable foldMapWithIndex
  */
-export function foldMapWithIndex_<A, M>(
-  self: Iterable<A>,
-  f: (i: number, a: A) => M,
-  /** @tsplus auto */ M: P.Monoid<M>,
-): M {
-  let res = M.nat;
-  let n   = -1;
-  for (const value of self) {
-    n  += 1;
-    res = M.combine(res, f(n, value));
-  }
-  return res;
+export function foldMapWithIndex<A, M>(f: (i: number, a: A) => M, /** @tsplus auto */ M: P.Monoid<M>) {
+  return (self: Iterable<A>): M => {
+    let res = M.nat;
+    let n   = -1;
+    for (const value of self) {
+      n  += 1;
+      res = M.combine(res, f(n, value));
+    }
+    return res;
+  };
 }
 
 /**
- * @tsplus fluent fncts.Iterable foldRightWithIndex
+ * @tsplus pipeable fncts.Iterable foldRightWithIndex
  */
-export function foldRightWithIndex_<A, B>(
-  self: Iterable<A>,
-  b: Eval<B>,
-  f: (i: number, a: A, b: Eval<B>) => Eval<B>,
-): Eval<B> {
-  let i             = 0;
-  const iterator    = self[Symbol.iterator]();
-  const go: Eval<B> = Eval.defer(() => {
-    const { value: current, done } = iterator.next();
-    if (done) {
-      return b;
-    } else {
-      return f(i++, current, go);
-    }
-  });
-  return go;
+export function foldRightWithIndex<A, B>(b: Eval<B>, f: (i: number, a: A, b: Eval<B>) => Eval<B>) {
+  return (self: Iterable<A>): Eval<B> => {
+    let i             = 0;
+    const iterator    = self[Symbol.iterator]();
+    const go: Eval<B> = Eval.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
  */
-export function foldRight_<A, B>(self: Iterable<A>, b: Eval<B>, f: (a: A, b: Eval<B>) => Eval<B>): Eval<B> {
-  return self.foldRightWithIndex(b, (_, a, b) => f(a, b));
+export function foldRight<A, B>(b: Eval<B>, f: (a: A, b: Eval<B>) => Eval<B>) {
+  return (self: Iterable<A>): Eval<B> => {
+    return self.foldRightWithIndex(b, (_, a, b) => f(a, b));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Iterable map
+ * @tsplus pipeable fncts.Iterable map
  */
-export function map_<A, B>(self: Iterable<A>, f: (a: A) => B): Iterable<B> {
-  return self.mapWithIndex((_, a) => f(a));
+export function map<A, B>(f: (a: A) => B) {
+  return (self: Iterable<A>): Iterable<B> => {
+    return self.mapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Iterable mapWithIndex
+ * @tsplus pipeable fncts.Iterable mapWithIndex
  */
-export function mapWithIndex_<A, B>(self: Iterable<A>, f: (i: number, a: A) => B): Iterable<B> {
-  return Iterable.make<B>(() => {
-    const ia = self[Symbol.iterator]();
-    let i    = 0;
-    let done = false;
-    let va: IteratorResult<A>;
-    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?: unknown) {
-        if (!done) {
-          done = true;
-          if (typeof ia.return === "function") {
-            ia.return();
+export function mapWithIndex<A, B>(f: (i: number, a: A) => B) {
+  return (self: Iterable<A>): Iterable<B> => {
+    return Iterable.make<B>(() => {
+      const ia = self[Symbol.iterator]();
+      let i    = 0;
+      let done = false;
+      let va: IteratorResult<A>;
+      return {
+        next() {
+          if (done) {
+            return this.return!();
           }
-        }
-        return { done, value };
-      },
-    };
-  });
+          va = ia.next();
+          if (va.done) {
+            return this.return!();
+          }
+          return { done, value: f(i++, va.value) };
+        },
+        return(value?: unknown) {
+          if (!done) {
+            done = true;
+            if (typeof ia.return === "function") {
+              ia.return();
+            }
+          }
+          return { done, value };
+        },
+      };
+    });
+  };
 }
 
-type PartitionHandleResult<A> = { emit: true; value: A } | { emit: false };
-
+type PartitionHandleResult<A> =
+  | {
+      emit: true;
+      value: A;
+    }
+  | {
+      emit: false;
+    };
 function handlePartitionMap<A, B, C>(
   f: (i: number, a: A) => Either<B, C>,
   i: number,
@@ -475,26 +517,24 @@ function partitionMapWithIndexIterator<A, B, C>(
 }
 
 /**
- * @tsplus fluent fncts.Iterable partitionMap
+ * @tsplus pipeable fncts.Iterable partitionMap
  */
-export function partitionMap_<A, B, C>(
-  self: Iterable<A>,
-  f: (a: A) => Either<B, C>,
-): readonly [Iterable<B>, Iterable<C>] {
-  return self.partitionMapWithIndex((_, a) => f(a));
+export function partitionMap<A, B, C>(f: (a: A) => Either<B, C>) {
+  return (self: Iterable<A>): readonly [Iterable<B>, Iterable<C>] => {
+    return self.partitionMapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Iterable partitionMapWithIndex
+ * @tsplus pipeable fncts.Iterable partitionMapWithIndex
  */
-export function partitionMapWithIndex_<A, B, C>(
-  fa: Iterable<A>,
-  f: (i: number, a: A) => Either<B, C>,
-): readonly [Iterable<B>, Iterable<C>] {
-  return tuple(
-    Iterable.make(() => partitionMapWithIndexIterator(fa, f, "Left")) as Iterable<B>,
-    Iterable.make(() => partitionMapWithIndexIterator(fa, f, "Right")) as Iterable<C>,
-  );
+export function partitionMapWithIndex<A, B, C>(f: (i: number, a: A) => Either<B, C>) {
+  return (fa: Iterable<A>): readonly [Iterable<B>, Iterable<C>] => {
+    return tuple(
+      Iterable.make(() => partitionMapWithIndexIterator(fa, f, "Left")) as Iterable<B>,
+      Iterable.make(() => partitionMapWithIndexIterator(fa, f, "Right")) as Iterable<C>,
+    );
+  };
 }
 
 function handlePartition<A>(
@@ -545,33 +585,34 @@ function partitionWithIndexIterator<A>(
 }
 
 /**
- * @tsplus fluent fncts.Iterable partition
+ * @tsplus pipeable fncts.Iterable partition
  */
-export function partition_<A, B extends A>(self: Iterable<A>, p: Refinement<A, B>): readonly [Iterable<A>, Iterable<B>];
-export function partition_<A>(self: Iterable<A>, p: Predicate<A>): readonly [Iterable<A>, Iterable<A>];
-export function partition_<A>(self: Iterable<A>, p: Predicate<A>): readonly [Iterable<A>, Iterable<A>] {
-  return self.partitionWithIndex((_, a) => p(a));
+export function partition<A, B extends A>(
+  p: Refinement<A, B>,
+): (self: Iterable<A>) => readonly [Iterable<A>, Iterable<B>];
+export function partition<A>(p: Predicate<A>): (self: Iterable<A>) => readonly [Iterable<A>, Iterable<A>];
+export function partition<A>(p: Predicate<A>) {
+  return (self: Iterable<A>): readonly [Iterable<A>, Iterable<A>] => {
+    return self.partitionWithIndex((_, a) => p(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Iterable partitionWithIndex
+ * @tsplus pipeable fncts.Iterable partitionWithIndex
  */
-export function partitionWithIndex_<A, B extends A>(
-  self: Iterable<A>,
+export function partitionWithIndex<A, B extends A>(
   p: RefinementWithIndex<number, A, B>,
-): readonly [Iterable<A>, Iterable<B>];
-export function partitionWithIndex_<A>(
-  self: Iterable<A>,
-  p: PredicateWithIndex<number, A>,
-): readonly [Iterable<A>, Iterable<A>];
-export function partitionWithIndex_<A>(
-  self: Iterable<A>,
+): (self: Iterable<A>) => readonly [Iterable<A>, Iterable<B>];
+export function partitionWithIndex<A>(
   p: PredicateWithIndex<number, A>,
-): readonly [Iterable<A>, Iterable<A>] {
-  return tuple(
-    Iterable.make(() => partitionWithIndexIterator(self, p, false)),
-    Iterable.make(() => partitionWithIndexIterator(self, p, true)),
-  );
+): (self: Iterable<A>) => readonly [Iterable<A>, Iterable<A>];
+export function partitionWithIndex<A>(p: PredicateWithIndex<number, A>) {
+  return (self: Iterable<A>): readonly [Iterable<A>, Iterable<A>] => {
+    return tuple(
+      Iterable.make(() => partitionWithIndexIterator(self, p, false)),
+      Iterable.make(() => partitionWithIndexIterator(self, p, true)),
+    );
+  };
 }
 
 /**
@@ -593,78 +634,74 @@ export function sum(self: Iterable<number>): number {
 }
 
 /**
- * @tsplus fluent fncts.Iterable take
+ * @tsplus pipeable fncts.Iterable take
  */
-export function take<A>(self: Iterable<A>, n: number): Iterable<A> {
-  return Iterable.make<A>(() => {
-    let done       = false;
-    let i          = 0;
-    let value: IteratorResult<A>;
-    const iterator = self[Symbol.iterator]();
-    return {
-      next() {
-        if (done || i >= n) {
-          return this.return!();
-        }
-        value = iterator.next();
-        i++;
-        if (value.done) {
-          this.return!();
-        }
-        return value;
-      },
-      return(value?: unknown) {
-        if (!done) {
-          done = true;
-          if (typeof iterator.return === "function") {
-            iterator.return();
+export function take(n: number) {
+  return <A>(self: Iterable<A>): Iterable<A> => {
+    return Iterable.make<A>(() => {
+      let done       = false;
+      let i          = 0;
+      let value: IteratorResult<A>;
+      const iterator = self[Symbol.iterator]();
+      return {
+        next() {
+          if (done || i >= n) {
+            return this.return!();
           }
-        }
-        return { done: true, value };
-      },
-    };
-  });
+          value = iterator.next();
+          i++;
+          if (value.done) {
+            this.return!();
+          }
+          return value;
+        },
+        return(value?: unknown) {
+          if (!done) {
+            done = true;
+            if (typeof iterator.return === "function") {
+              iterator.return();
+            }
+          }
+          return { done: true, value };
+        },
+      };
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.Iterable zipWith
+ * @tsplus pipeable fncts.Iterable zipWith
  */
-export function zipWith_<A, B, C>(self: Iterable<A>, fb: Iterable<B>, f: (a: A, b: B) => C): Iterable<C> {
-  return Iterable.make<C>(() => {
-    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?: unknown) {
-        if (!done) {
-          done = true;
-
-          if (typeof ia.return === "function") {
-            ia.return();
+export function zipWith<A, B, C>(fb: Iterable<B>, f: (a: A, b: B) => C) {
+  return (self: Iterable<A>): Iterable<C> => {
+    return Iterable.make<C>(() => {
+      let done = false;
+      const ia = self[Symbol.iterator]();
+      const ib = fb[Symbol.iterator]();
+      return {
+        next() {
+          if (done) {
+            return this.return!();
           }
-          if (typeof ib.return === "function") {
-            ib.return();
+          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?: unknown) {
+          if (!done) {
+            done = true;
+            if (typeof ia.return === "function") {
+              ia.return();
+            }
+            if (typeof ib.return === "function") {
+              ib.return();
+            }
           }
-        }
-
-        return { done: true, value };
-      },
-    };
-  });
+          return { done: true, value };
+        },
+      };
+    });
+  };
 }
 
 /**