@fncts/base 0.0.20 → 0.0.21

package/_mjs/collection/Iterable/api.mjs

@@ -2,76 +2,80 @@ import * as tsplus_module_1 from "@fncts/base/collection/Iterable/constructors";
 import * as tsplus_module_2 from "@fncts/base/data/Maybe/definition";
 import * as tsplus_module_3 from "@fncts/base/data/Maybe/constructors";
 import * as tsplus_module_4 from "@fncts/base/control/Eval/constructors";
-export const flatMap_ = flatMap_1;
-export const everyWithIndex_ = everyWithIndex_1;
-export const filterMapWithIndex_ = filterMapWithIndex_1;
-export const filterWithIndex_ = filterWithIndex_1;
-export const foldLeftWithIndex_ = foldLeftWithIndex_1;
-export const foldLeft_ = foldLeft_1;
-export const foldMapWithIndex_ = foldMapWithIndex_1;
-export const foldRightWithIndex_ = foldRightWithIndex_1;
-export const map_ = map_1;
-export const mapWithIndex_ = mapWithIndex_1;
-export const partitionMapWithIndex_ = partitionMapWithIndex_1;
-export const partitionWithIndex_ = partitionWithIndex_1;
+export const flatMap = flatMap_1;
+export const everyWithIndex = everyWithIndex_1;
+export const filterMapWithIndex = filterMapWithIndex_1;
+export const filterWithIndex = filterWithIndex_1;
+export const foldLeftWithIndex = foldLeftWithIndex_1;
+export const foldLeft = foldLeft_1;
+export const foldMapWithIndex = foldMapWithIndex_1;
+export const foldRightWithIndex = foldRightWithIndex_1;
+export const map = map_1;
+export const mapWithIndex = mapWithIndex_1;
+export const partitionMapWithIndex = partitionMapWithIndex_1;
+export const partitionWithIndex = partitionWithIndex_1;
 import { tuple } from "@fncts/base/data/function";
 /**
- * @tsplus fluent fncts.Iterable ap
+ * @tsplus pipeable fncts.Iterable ap
  */
 
-export function ap_(self, fa) {
-  return flatMap_1(self, f => map_1(fa, f));
+export function ap(fa) {
+  return self => {
+    return flatMap_1(f => map_1(f)(fa))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Iterable append
+ * @tsplus pipeable fncts.Iterable append
  */
 
-export 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();
-        }
+export 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
@@ -81,427 +85,467 @@ export 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
  */
 
 
-export 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();
+export 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
  */
 
-export function corresponds_(left, right, f) {
-  const leftIterator = left[Symbol.iterator]();
-  const rightIterator = right[Symbol.iterator](); // eslint-disable-next-line no-constant-condition
+export 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
  */
 
-export function crossWith_(self, fb, f) {
-  return flatMap_1(self, a => map_1(fb, b => f(a, b)));
+export function crossWith(fb, f) {
+  return self => {
+    return flatMap_1(a => map_1(b => f(a, b))(fb))(self);
+  };
 }
-export function every_(self, p) {
-  return everyWithIndex_1(self, (_, a) => p(a));
+export 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;
+  };
 }
 
-export function filter_(self, p) {
-  return filterWithIndex_1(self, (_, a) => p(a));
+export function filter(p) {
+  return self => {
+    return filterWithIndex_1((_, a) => p(a))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.Iterable filterMap
+ * @tsplus pipeable fncts.Iterable filterMap
  */
 
-export function filterMap_(self, f) {
-  return filterMapWithIndex_1(self, (_, a) => f(a));
+export 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
+          };
+        }
 
-    };
-  });
+      };
+    });
+  };
 }
 
-export function find_(ia, predicate) {
-  for (const value of ia) {
-    if (predicate(value)) {
-      return tsplus_module_3.just(value);
+export 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
  */
 
-export function findIndex(self, p) {
-  let i = 0;
+export 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
  */
 
 
-export function foldMap_(self, f,
+export 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
  */
 
 
-export function foldRight_(self, b, f) {
-  return foldRightWithIndex_1(self, b, (_, a, b) => f(a, b));
+export 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) {
@@ -566,19 +610,23 @@ function partitionMapWithIndexIterator(fa, f, h) {
   };
 }
 /**
- * @tsplus fluent fncts.Iterable partitionMap
+ * @tsplus pipeable fncts.Iterable partitionMap
  */
 
 
-export function partitionMap_(self, f) {
-  return partitionMapWithIndex_1(self, (_, a) => f(a));
+export 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 tuple(tsplus_module_1.mkIterable(() => partitionMapWithIndexIterator(fa, f, "Left")), tsplus_module_1.mkIterable(() => partitionMapWithIndexIterator(fa, f, "Right")));
+function partitionMapWithIndex_1(f) {
+  return fa => {
+    return tuple(tsplus_module_1.makeIterable(() => partitionMapWithIndexIterator(fa, f, "Left")), tsplus_module_1.makeIterable(() => partitionMapWithIndexIterator(fa, f, "Right")));
+  };
 }
 
 function handlePartition(predicate, i, a, h) {
@@ -638,12 +686,16 @@ function partitionWithIndexIterator(fa, predicate, h) {
   };
 }
 
-export function partition_(self, p) {
-  return partitionWithIndex_1(self, (_, a) => p(a));
+export function partition(p) {
+  return self => {
+    return partitionWithIndex_1((_, a) => p(a))(self);
+  };
 }
 
-function partitionWithIndex_1(self, p) {
-  return tuple(tsplus_module_1.mkIterable(() => partitionWithIndexIterator(self, p, false)), tsplus_module_1.mkIterable(() => partitionWithIndexIterator(self, p, true)));
+function partitionWithIndex_1(p) {
+  return self => {
+    return tuple(tsplus_module_1.makeIterable(() => partitionWithIndexIterator(self, p, false)), tsplus_module_1.makeIterable(() => partitionWithIndexIterator(self, p, true)));
+  };
 }
 /**
  * @tsplus getter fncts.Iterable size
@@ -664,105 +716,107 @@ export function size(self) {
  */
 
 export 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
  */
 
-export 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();
-        }
+export 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
  */
 
-export 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();
-        }
+export 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
  */
 
 export function zipWithIndex(self) {
-  return tsplus_module_1.mkIterable(() => {
+  return tsplus_module_1.makeIterable(() => {
     let n = 0;
     let done = false;
     const iterator = self[Symbol.iterator]();