@fncts/base 0.0.20 → 0.0.22

package/_mjs/collection/immutable/Conc/definition.mjs

@@ -1,7 +1,7 @@
-import * as tsplus_module_1 from "@fncts/base/typeclass/Hashable/definition";
-import * as tsplus_module_2 from "@fncts/base/typeclass/Hashable/hash";
-import * as tsplus_module_3 from "@fncts/base/typeclass/Equatable/definition";
-import * as tsplus_module_4 from "@fncts/base/typeclass/Equatable/api";
+import * as tsplus_module_1 from "@fncts/base/data/Hashable/definition";
+import * as tsplus_module_2 from "@fncts/base/data/Hashable/hash";
+import * as tsplus_module_3 from "@fncts/base/data/Equatable/definition";
+import * as tsplus_module_4 from "@fncts/base/data/Equatable/api";
 import * as tsplus_module_5 from "@fncts/base/util/predicates";
 import * as tsplus_module_6 from "@fncts/base/data/exceptions";
 import * as tsplus_module_7 from "@fncts/base/collection/Iterable/api";
@@ -10,7 +10,7 @@ import * as tsplus_module_9 from "@fncts/base/collection/compat/ArrayLike/api";
 import * as tsplus_module_10 from "@fncts/base/data/function/api";
 export const fromArray = fromArray_1;
 export const isConc = isConc_1;
-export const corresponds_ = corresponds_1;
+export const corresponds = corresponds_1;
 export const toArray = toArray_1;
 export const BUFFER_SIZE = 64;
 export const UPDATE_BUFFER_SIZE = 256;
@@ -19,106 +19,76 @@ export const ConcTypeId = /*#__PURE__*/Symbol.for("fncts.Conc");
  * @tsplus type fncts.Conc
  * @tsplus companion fncts.ConcOps
  */
-
 export class Conc {
   constructor() {
     this._typeId = ConcTypeId;
   }
-
   get [tsplus_module_1.hashSymbol]() {
     return tsplus_module_2.hashIterator(this[Symbol.iterator]());
   }
-
   [tsplus_module_3.equalsSymbol](that) {
-    return isConc_1(that) && corresponds_1(this, that, tsplus_module_4.strictEquals);
+    return isConc_1(that) && corresponds_1(that, tsplus_module_4.strictEquals)(this);
   }
-
 }
-
 class ConcImplementation {
   constructor() {
     this._typeId = ConcTypeId;
     this.depth = 0;
   }
-
   get [tsplus_module_1.hashSymbol]() {
     return tsplus_module_2.hashIterator(this[Symbol.iterator]());
   }
-
   [tsplus_module_3.equalsSymbol](that) {
-    return isConc_1(that) && corresponds_1(this, that, tsplus_module_4.strictEquals);
+    return isConc_1(that) && corresponds_1(that, tsplus_module_4.strictEquals)(this);
   }
-
   arrayIterator() {
     return this.materialize().arrayIterator();
   }
-
   reverseArrayIterator() {
     return this.materialize().reverseArrayIterator();
   }
-
   [Symbol.iterator]() {
     return this.materialize()[Symbol.iterator]();
   }
-
   forEach(startIndex, f) {
     this.materialize().forEach(startIndex, f);
   }
-
   arrayLike() {
     if (this.arrayLikeCache) {
       return this.arrayLikeCache;
     }
-
     const arr = this.binary ? alloc(this.length) : Array(this.length);
     this.copyToArray(0, arr);
     this.arrayLikeCache = arr;
     return arr;
   }
-
   array() {
     if (this.arrayCache) {
       return this.arrayCache;
     }
-
     const arr = Array(this.length);
     this.copyToArray(0, arr);
     this.arrayCache = arr;
     return arr;
   }
-
   concat(that) {
     void 0;
     void 0;
-
-    if (this._tag === "Empty"
-    /* ConcTag.Empty */
-    ) {
+    if (this._tag === "Empty" /* ConcTag.Empty */) {
       return that;
     }
-
-    if (that._tag === "Empty"
-    /* ConcTag.Empty */
-    ) {
+    if (that._tag === "Empty" /* ConcTag.Empty */) {
       return this;
     }
-
-    if (this._tag === "AppendN"
-    /* ConcTag.AppendN */
-    ) {
+    if (this._tag === "AppendN" /* ConcTag.AppendN */) {
       const conc = fromArray_1(this.buffer).take(this.bufferUsed);
       return this.start.concat(conc).concat(that);
     }
-
-    if (that._tag === "PrependN"
-    /* ConcTag.PrependN */
-    ) {
+    if (that._tag === "PrependN" /* ConcTag.PrependN */) {
       const conc = fromArray_1(that.bufferUsed === 0 ? [] : that.buffer.slice(-that.bufferUsed));
       return this.concat(conc).concat(that.end);
     }
-
     const diff = that.depth - this.depth;
-
     if (Math.abs(diff) <= 1) {
       return new Concat(this, that);
     } else if (diff < -1) {
@@ -128,7 +98,6 @@ class ConcImplementation {
       } else {
         void 0;
         const nrr = this.right.right.concat(that);
-
         if (nrr.depth === this.depth - 3) {
           const nr = new Concat(this.right.left, nrr);
           return new Concat(this.left, nr);
@@ -144,7 +113,6 @@ class ConcImplementation {
       } else {
         void 0;
         const nll = this.concat(that.left.left);
-
         if (nll.depth === that.depth - 3) {
           const nl = new Concat(nll, that.left.right);
           return new Concat(nl, that.right);
@@ -155,7 +123,6 @@ class ConcImplementation {
       }
     }
   }
-
   take(n) {
     if (n <= 0) {
       return _Empty;
@@ -163,48 +130,34 @@ class ConcImplementation {
       return this;
     } else {
       void 0;
-
       switch (this._tag) {
-        case "Empty"
-        /* ConcTag.Empty */
-        :
+        case "Empty" /* ConcTag.Empty */:
           return _Empty;
-
-        case "Slice"
-        /* ConcTag.Slice */
-        :
+        case "Slice" /* ConcTag.Slice */:
           return n >= this.l ? this : new Slice(this.conc, this.offset, n);
-
-        case "Singleton"
-        /* ConcTag.Singleton */
-        :
+        case "Singleton" /* ConcTag.Singleton */:
           return this;
-
         default:
           return new Slice(this, 0, n);
       }
     }
   }
-
   append(a) {
     const binary = this.binary && tsplus_module_5.isByte(a);
     const buffer = this.binary && binary ? alloc(BUFFER_SIZE) : Array(BUFFER_SIZE);
     buffer[0] = a;
     return new AppendN(this, buffer, 1, this.binary && binary);
   }
-
   prepend(a) {
     const binary = this.binary && tsplus_module_5.isByte(a);
     const buffer = this.binary && binary ? alloc(BUFFER_SIZE) : Array(BUFFER_SIZE);
     buffer[BUFFER_SIZE - 1] = a;
     return new PrependN(this, buffer, 1, this.binary && binary);
   }
-
   update(index, a1) {
     if (index < 0 || index >= this.length) {
       throw new tsplus_module_6.IndexOutOfBoundsError(`Conc.update access to ${index}`);
     }
-
     const binary = this.binary && tsplus_module_5.isByte(a1);
     const bufferIndices = Array(UPDATE_BUFFER_SIZE);
     const bufferValues = binary ? alloc(UPDATE_BUFFER_SIZE) : Array(UPDATE_BUFFER_SIZE);
@@ -216,55 +169,38 @@ class ConcImplementation {
    * Materializes a Conc into a Conc backed by an array. This method can
    * improve the performance of bulk operations.
    */
-
-
   materialize() {
     void 0;
-
     switch (this._tag) {
-      case "Empty"
-      /* ConcTag.Empty */
-      :
+      case "Empty" /* ConcTag.Empty */:
         return this;
-
-      case "Chunk"
-      /* ConcTag.Chunk */
-      :
+      case "Chunk" /* ConcTag.Chunk */:
         return this;
-
       default:
         return fromArray_1(this.arrayLike());
     }
   }
-
 }
-
 const alloc = typeof Buffer !== "undefined" ? Buffer.alloc : n => new Uint8Array(n);
 export class Empty extends ConcImplementation {
   constructor() {
     super(...arguments);
-    this._tag = "Empty"
-    /* ConcTag.Empty */
-    ;
+    this._tag = "Empty" /* ConcTag.Empty */;
     this.length = 0;
     this.depth = 0;
     this.left = this;
     this.right = this;
     this.binary = false;
   }
-
   get(index) {
     throw new tsplus_module_6.ArrayIndexOutOfBoundsError(`Conc.get access to ${index}`);
   }
-
   forEach(_, __) {
     return;
   }
-
   copyToArray(_, __) {
     return;
   }
-
   [Symbol.iterator]() {
     return {
       next: () => {
@@ -275,7 +211,6 @@ export class Empty extends ConcImplementation {
       }
     };
   }
-
   arrayIterator() {
     return {
       next: () => ({
@@ -284,7 +219,6 @@ export class Empty extends ConcImplementation {
       })
     };
   }
-
   reverseArrayIterator() {
     return {
       next: () => ({
@@ -293,7 +227,6 @@ export class Empty extends ConcImplementation {
       })
     };
   }
-
 }
 export const _Empty = /*#__PURE__*/new Empty();
 export class Concat extends ConcImplementation {
@@ -301,42 +234,32 @@ export class Concat extends ConcImplementation {
     super();
     this.left = left;
     this.right = right;
-    this._tag = "Concat"
-    /* ConcTag.Concat */
-    ;
+    this._tag = "Concat" /* ConcTag.Concat */;
     this.length = this.left.length + this.right.length;
     this.depth = 1 + Math.max(this.left.depth, this.right.depth);
     this.binary = this.left.binary && this.right.binary;
   }
-
   get(n) {
     return n < this.left.length ? this.left.get(n) : this.right.get(n - this.left.length);
   }
-
   forEach(startIndex, f) {
     this.left.forEach(startIndex, f);
     this.right.forEach(startIndex + this.left.length, f);
   }
-
   copyToArray(n, dest) {
     this.left.copyToArray(n, dest);
     this.right.copyToArray(n + this.left.length, dest);
   }
-
   [Symbol.iterator]() {
-    return tsplus_module_7.concat_(tsplus_module_7.asIterable(this.left), this.right)[Symbol.iterator]();
+    return tsplus_module_7.concat(this.right)(tsplus_module_7.toIterable(this.left))[Symbol.iterator]();
   }
-
   arrayIterator() {
-    return tsplus_module_7.concat_(tsplus_module_8.mkIterable(() => this.left.arrayIterator()), tsplus_module_8.mkIterable(() => this.right.arrayIterator()))[Symbol.iterator]();
+    return tsplus_module_7.concat(tsplus_module_8.makeIterable(() => this.right.arrayIterator()))(tsplus_module_8.makeIterable(() => this.left.arrayIterator()))[Symbol.iterator]();
   }
-
   reverseArrayIterator() {
-    return tsplus_module_7.concat_(tsplus_module_8.mkIterable(() => this.right.reverseArrayIterator()), tsplus_module_8.mkIterable(() => this.left.reverseArrayIterator()))[Symbol.iterator]();
+    return tsplus_module_7.concat(tsplus_module_8.makeIterable(() => this.left.reverseArrayIterator()))(tsplus_module_8.makeIterable(() => this.right.reverseArrayIterator()))[Symbol.iterator]();
   }
-
 }
-
 class AppendN extends ConcImplementation {
   constructor(start, buffer, bufferUsed, binary) {
     super();
@@ -344,34 +267,26 @@ class AppendN extends ConcImplementation {
     this.buffer = buffer;
     this.bufferUsed = bufferUsed;
     this.binary = binary;
-    this._tag = "AppendN"
-    /* ConcTag.AppendN */
-    ;
+    this._tag = "AppendN" /* ConcTag.AppendN */;
     this.depth = 0;
     this.left = _Empty;
     this.right = _Empty;
     this.length = this.start.length + this.bufferUsed;
   }
-
   [Symbol.iterator]() {
-    return tsplus_module_7.concat_(tsplus_module_7.asIterable(this.start), tsplus_module_7.take(tsplus_module_9.asIterable(this.buffer), this.bufferUsed))[Symbol.iterator]();
+    return tsplus_module_7.concat(tsplus_module_7.take(this.bufferUsed)(tsplus_module_9.toIterable(this.buffer)))(tsplus_module_7.toIterable(this.start))[Symbol.iterator]();
   }
-
   append(a) {
     const binary = this.binary && tsplus_module_5.isByte(a);
-
     if (this.bufferUsed < this.buffer.length) {
       if (this.binary && !binary) {
         const buffer = Array(BUFFER_SIZE);
-
         for (let i = 0; i < BUFFER_SIZE; i++) {
           buffer[i] = this.buffer[i];
         }
-
         buffer[this.bufferUsed] = a;
         return new AppendN(this.start, this.buffer, this.bufferUsed + 1, this.binary && binary);
       }
-
       this.buffer[this.bufferUsed] = a;
       return new AppendN(this.start, this.buffer, this.bufferUsed + 1, this.binary && binary);
     } else {
@@ -381,7 +296,6 @@ class AppendN extends ConcImplementation {
       return new AppendN(this.start.concat(conc), buffer, 1, this.binary && binary);
     }
   }
-
   get(n) {
     if (n < this.start.length) {
       return this.start.get(n);
@@ -389,22 +303,17 @@ class AppendN extends ConcImplementation {
       return this.buffer[n - this.start.length];
     }
   }
-
   copyToArray(n, dest) {
     this.start.copyToArray(n, dest);
     copyArray(this.buffer, 0, dest, this.start.length + n, this.bufferUsed);
   }
-
   forEach(startIndex, f) {
     this.start.forEach(startIndex, f);
-
     for (let i = 0; i < this.bufferUsed; i++) {
       f(startIndex + this.start.length + i, this.buffer[i]);
     }
   }
-
 }
-
 class PrependN extends ConcImplementation {
   constructor(end, buffer, bufferUsed, binary) {
     super();
@@ -412,33 +321,25 @@ class PrependN extends ConcImplementation {
     this.buffer = buffer;
     this.bufferUsed = bufferUsed;
     this.binary = binary;
-    this._tag = "PrependN"
-    /* ConcTag.PrependN */
-    ;
+    this._tag = "PrependN" /* ConcTag.PrependN */;
     this.left = _Empty;
     this.right = _Empty;
     this.length = this.end.length + this.bufferUsed;
   }
-
   [Symbol.iterator]() {
-    return tsplus_module_7.concat_(tsplus_module_7.take(tsplus_module_9.asIterable(this.buffer), this.bufferUsed), this.end)[Symbol.iterator]();
+    return tsplus_module_7.concat(this.end)(tsplus_module_9.toIterable(this.buffer.slice(BUFFER_SIZE - this.bufferUsed, this.buffer.length)))[Symbol.iterator]();
   }
-
   prepend(a) {
     const binary = this.binary && tsplus_module_5.isByte(a);
-
     if (this.bufferUsed < this.buffer.length) {
       if (this.binary && !binary) {
         const buffer = Array(BUFFER_SIZE);
-
         for (let i = 0; i < BUFFER_SIZE; i++) {
           buffer[i] = this.buffer[i];
         }
-
         buffer[BUFFER_SIZE - this.bufferUsed - 1] = a;
         return new PrependN(this.end, buffer, this.bufferUsed + 1, this.binary && binary);
       }
-
       this.buffer[BUFFER_SIZE - this.bufferUsed - 1] = a;
       return new PrependN(this.end, this.buffer, this.bufferUsed + 1, this.binary && binary);
     } else {
@@ -448,27 +349,21 @@ class PrependN extends ConcImplementation {
       return new PrependN(conc.concat(this.end), buffer, 1, this.binary && binary);
     }
   }
-
   get(n) {
     return n < this.bufferUsed ? this.buffer[BUFFER_SIZE - this.bufferUsed + n] : this.end.get(n - this.bufferUsed);
   }
-
   copyToArray(n, dest) {
     const length = Math.min(this.bufferUsed, Math.max(dest.length - n, 0));
     copyArray(this.buffer, BUFFER_SIZE - this.bufferUsed, dest, n, length);
     this.end.copyToArray(n + length, dest);
   }
-
   forEach(startIndex, f) {
     for (let i = BUFFER_SIZE - this.bufferUsed, j = 0; i < BUFFER_SIZE; i++, j++) {
       f(startIndex + j, this.buffer[i]);
     }
-
     this.end.forEach(startIndex + this.bufferUsed, f);
   }
-
 }
-
 class Update extends ConcImplementation {
   constructor(conc, bufferIndices, bufferValues, used, binary) {
     super();
@@ -477,47 +372,36 @@ class Update extends ConcImplementation {
     this.bufferValues = bufferValues;
     this.used = used;
     this.binary = binary;
-    this._tag = "Update"
-    /* ConcTag.Update */
-    ;
+    this._tag = "Update" /* ConcTag.Update */;
     this.left = _Empty;
     this.right = _Empty;
     this.length = this.conc.length;
   }
-
   get(n) {
     let a = null;
-
     for (let j = this.used; j >= 0; j--) {
       if (this.bufferIndices[j] === n) {
         a = this.bufferValues[j];
         break;
       }
     }
-
     return a !== null ? a : this.conc.get(n);
   }
-
   update(i, a) {
     if (i < 0 || i >= this.length) {
       throw new tsplus_module_6.IndexOutOfBoundsError(`Conc.update access to ${i}`);
     }
-
     const binary = this.binary && tsplus_module_5.isByte(a);
-
     if (this.used < UPDATE_BUFFER_SIZE) {
       if (this.binary && !binary) {
         const buffer = Array(UPDATE_BUFFER_SIZE);
-
         for (let j = 0; j < UPDATE_BUFFER_SIZE; j++) {
           buffer[j] = this.bufferValues[j];
         }
-
         this.bufferIndices[this.used] = i;
         buffer[this.used] = a;
         return new Update(this.conc, this.bufferIndices, buffer, this.used + 1, this.binary && binary);
       }
-
       this.bufferIndices[this.used] = i;
       this.bufferValues[this.used] = a;
       return new Update(this.conc, this.bufferIndices, this.bufferValues, this.used + 1, this.binary && binary);
@@ -530,26 +414,20 @@ class Update extends ConcImplementation {
       return new Update(fromArray_1(array), bufferIndices, bufferValues, 1, this.binary && binary);
     }
   }
-
   copyToArray(n, dest) {
     this.conc.copyToArray(n, dest);
-
     for (let i = 0; i < this.used; i++) {
       const index = this.bufferIndices[i];
       const value = this.bufferValues[i];
       dest[index] = value;
     }
   }
-
 }
-
 export class Singleton extends ConcImplementation {
   constructor(value) {
     super();
     this.value = value;
-    this._tag = "Singleton"
-    /* ConcTag.Singleton */
-    ;
+    this._tag = "Singleton" /* ConcTag.Singleton */;
     this.length = 1;
     this.depth = 0;
     this.left = _Empty;
@@ -557,31 +435,24 @@ export class Singleton extends ConcImplementation {
     this.reverseArrayIterator = this.arrayIterator;
     this.binary = tsplus_module_5.isByte(this.value);
   }
-
   get(n) {
     if (n === 0) {
       return this.value;
     }
-
     throw new tsplus_module_6.ArrayIndexOutOfBoundsError(`Chunk.get access to ${n}`);
   }
-
   forEach(startIndex, f) {
     f(startIndex, this.value);
   }
-
   copyToArray(n, dest) {
     dest[n] = this.value;
   }
-
   [Symbol.iterator]() {
     return tsplus_module_8.single(this.value)[Symbol.iterator]();
   }
-
   arrayIterator() {
     return tsplus_module_8.single([this.value])[Symbol.iterator]();
   }
-
 }
 export class Slice extends ConcImplementation {
   constructor(conc, offset, l) {
@@ -589,48 +460,38 @@ export class Slice extends ConcImplementation {
     this.conc = conc;
     this.offset = offset;
     this.l = l;
-    this._tag = "Slice"
-    /* ConcTag.Slice */
-    ;
+    this._tag = "Slice" /* ConcTag.Slice */;
     this.depth = 0;
     this.left = _Empty;
     this.right = _Empty;
     this.binary = this.conc.binary;
     this.length = this.l;
   }
-
   get(n) {
     return this.conc.get(this.offset + n);
   }
-
   forEach(startIndex, f) {
     let i = 0;
-
     while (i < this.length) {
       f(startIndex + i, this.get(i));
       i++;
     }
   }
-
   copyToArray(n, dest) {
     let i = 0;
     let j = n;
-
     while (i < this.length) {
       dest[j] = this.get(i);
       i++;
       j++;
     }
   }
-
 }
 export class Chunk extends ConcImplementation {
   constructor(_array) {
     super();
     this._array = _array;
-    this._tag = "Chunk"
-    /* ConcTag.Chunk */
-    ;
+    this._tag = "Chunk" /* ConcTag.Chunk */;
     this.depth = 0;
     this.left = _Empty;
     this.right = _Empty;
@@ -638,89 +499,70 @@ export class Chunk extends ConcImplementation {
     this.reverseArrayIterator = this.arrayIterator;
     this.length = this._array.length;
   }
-
   get(n) {
     if (n >= this.length || n < 0) {
       throw new tsplus_module_6.ArrayIndexOutOfBoundsError(`Conc.get access to ${n}`);
     }
-
     return this._array[n];
   }
-
   forEach(startIndex, f) {
     for (let i = 0; i < this.length; i++) {
       f(startIndex + i, this._array[i]);
     }
   }
-
   copyToArray(n, dest) {
     copyArray(this._array, 0, dest, n, this.length);
   }
-
   [Symbol.iterator]() {
     return this._array[Symbol.iterator]();
   }
-
   arrayIterator() {
     return tsplus_module_8.single(this._array)[Symbol.iterator]();
   }
-
 }
 export class ByteChunk extends ConcImplementation {
   constructor(_array) {
     super();
     this._array = _array;
-    this._tag = "ByteChunk"
-    /* ConcTag.ByteChunk */
-    ;
+    this._tag = "ByteChunk" /* ConcTag.ByteChunk */;
     this.depth = 0;
     this.left = _Empty;
     this.right = _Empty;
     this.binary = true;
     this.length = this._array.length;
   }
-
   get(n) {
     if (n >= this.length || n < 0) {
       throw new tsplus_module_6.ArrayIndexOutOfBoundsError(`Conc.get access to ${n}`);
     }
-
     return this._array[n];
   }
-
   forEach(startIndex, f) {
     for (let i = 0; i < this.length; i++) {
       f(startIndex + i, this._array[i]);
     }
   }
-
   [Symbol.iterator]() {
     return this._array[Symbol.iterator]();
   }
-
   copyToArray(n, dest) {
     copyArray(this._array, 0, dest, n, this.length);
   }
-
   arrayIterator() {
     return tsplus_module_8.single(this._array)[Symbol.iterator]();
   }
-
   reverseArrayIterator() {
     return this.arrayIterator();
   }
-
 }
 /**
  * @tsplus macro remove
  */
-
-export function concrete(_) {//
+export function concrete(_) {
+  //
 }
-
 function copyArray(source, sourcePos, dest, destPos, length) {
   const j = Math.min(source.length, sourcePos + length);
-
   for (let i = sourcePos; i < j; i++) {
     dest[destPos + i - sourcePos] = source[i];
   }
@@ -728,8 +570,6 @@ function copyArray(source, sourcePos, dest, destPos, length) {
 /**
  * @tsplus static fncts.ConcOps fromArray
  */
-
-
 function fromArray_1(array) {
   if (array.length === 0) {
     return _Empty;
@@ -737,68 +577,60 @@ function fromArray_1(array) {
     return "buffer" in array ? new ByteChunk(array) : new Chunk(Array.from(array));
   }
 }
-
 function isConc_1(u) {
   return tsplus_module_5.isObject(u) && "_typeId" in u && u["_typeId"] === ConcTypeId;
 }
 /**
- * @tsplus fluent fncts.Conc corresponds
+ * @tsplus pipeable fncts.Conc corresponds
  */
-
-
-function corresponds_1(self, bs, f) {
-  if (self.length !== bs.length) {
-    return false;
-  }
-
-  void 0;
-  void 0;
-  const leftIterator = self.arrayIterator();
-  const rightIterator = bs.arrayIterator();
-  let left = undefined;
-  let right = undefined;
-  let leftLength = 0;
-  let rightLength = 0;
-  let i = 0;
-  let j = 0;
-  let equal = true;
-  let done = false;
-  let leftNext;
-  let rightNext;
-
-  while (equal && !done) {
-    if (i < leftLength && j < rightLength) {
-      const a = left[i];
-      const b = right[j];
-
-      if (!f(a, b)) {
+function corresponds_1(bs, f) {
+  return self => {
+    if (self.length !== bs.length) {
+      return false;
+    }
+    void 0;
+    void 0;
+    const leftIterator = self.arrayIterator();
+    const rightIterator = bs.arrayIterator();
+    let left = undefined;
+    let right = undefined;
+    let leftLength = 0;
+    let rightLength = 0;
+    let i = 0;
+    let j = 0;
+    let equal = true;
+    let done = false;
+    let leftNext;
+    let rightNext;
+    while (equal && !done) {
+      if (i < leftLength && j < rightLength) {
+        const a = left[i];
+        const b = right[j];
+        if (!f(a, b)) {
+          equal = false;
+        }
+        i++;
+        j++;
+      } else if (i === leftLength && !(leftNext = leftIterator.next()).done) {
+        left = leftNext.value;
+        leftLength = left.length;
+        i = 0;
+      } else if (j === rightLength && !(rightNext = rightIterator.next()).done) {
+        right = rightNext.value;
+        rightLength = right.length;
+        j = 0;
+      } else if (i === leftLength && j === rightLength) {
+        done = true;
+      } else {
         equal = false;
       }
-
-      i++;
-      j++;
-    } else if (i === leftLength && !(leftNext = leftIterator.next()).done) {
-      left = leftNext.value;
-      leftLength = left.length;
-      i = 0;
-    } else if (j === rightLength && !(rightNext = rightIterator.next()).done) {
-      right = rightNext.value;
-      rightLength = right.length;
-      j = 0;
-    } else if (i === leftLength && j === rightLength) {
-      done = true;
-    } else {
-      equal = false;
     }
-  }
-
-  return equal;
+    return equal;
+  };
 }
 /**
  * @tsplus getter fncts.Conc toArray
  */
-
-
 function toArray_1(conc) {
   void 0;
   return conc.array();