@fncts/base 0.0.20 → 0.0.22

package/_src/collection/immutable/Conc/definition.ts

@@ -1,12 +1,8 @@
 import { Iterable } from "../../Iterable/definition.js";
-
-export const BUFFER_SIZE = 64;
-
+export const BUFFER_SIZE        = 64;
 export const UPDATE_BUFFER_SIZE = 256;
-
-export const ConcTypeId = Symbol.for("fncts.Conc");
+export const ConcTypeId         = Symbol.for("fncts.Conc");
 export type ConcTypeId = typeof ConcTypeId;
-
 export const enum ConcTag {
   Empty = "Empty",
   Concat = "Concat",
@@ -224,12 +220,11 @@ const alloc = typeof Buffer !== "undefined" ? Buffer.alloc : (n: number) => new
 
 export class Empty<A> extends ConcImplementation<A> {
   readonly _tag = ConcTag.Empty;
-
-  length = 0;
-  depth  = 0;
-  left   = this;
-  right  = this;
-  binary = false;
+  length        = 0;
+  depth         = 0;
+  left          = this;
+  right         = this;
+  binary        = false;
   get(index: number): A {
     throw new ArrayIndexOutOfBoundsError(`Conc.get access to ${index}`);
   }
@@ -272,10 +267,9 @@ export const _Empty = new Empty<never>();
 export class Concat<A> extends ConcImplementation<A> {
   declare _A: () => A;
   readonly _tag = ConcTag.Concat;
-
-  length = this.left.length + this.right.length;
-  depth  = 1 + Math.max(this.left.depth, this.right.depth);
-  binary = this.left.binary && this.right.binary;
+  length        = this.left.length + this.right.length;
+  depth         = 1 + Math.max(this.left.depth, this.right.depth);
+  binary        = this.left.binary && this.right.binary;
   constructor(readonly left: ConcImplementation<A>, readonly right: ConcImplementation<A>) {
     super();
   }
@@ -291,7 +285,7 @@ export class Concat<A> extends ConcImplementation<A> {
     this.right.copyToArray(n + this.left.length, dest);
   }
   [Symbol.iterator](): Iterator<A> {
-    return this.left.asIterable.concat(this.right)[Symbol.iterator]();
+    return this.left.toIterable.concat(this.right)[Symbol.iterator]();
   }
   arrayIterator(): Iterator<ArrayLike<A>> {
     return Iterable.make(() => this.left.arrayIterator())
@@ -324,7 +318,7 @@ class AppendN<A> extends ConcImplementation<A> {
   }
 
   [Symbol.iterator](): Iterator<A> {
-    return this.start.asIterable.concat(this.buffer.asIterable.take(this.bufferUsed))[Symbol.iterator]() as Iterator<A>;
+    return this.start.toIterable.concat(this.buffer.toIterable.take(this.bufferUsed))[Symbol.iterator]() as Iterator<A>;
   }
 
   append<A1>(a: A1): ConcImplementation<A | A1> {
@@ -402,7 +396,10 @@ class PrependN<A> extends ConcImplementation<A> {
   }
 
   [Symbol.iterator](): Iterator<A> {
-    return this.buffer.asIterable.take(this.bufferUsed).concat(this.end)[Symbol.iterator]() as Iterator<A>;
+    return this.buffer
+      .slice(BUFFER_SIZE - this.bufferUsed, this.buffer.length)
+      .toIterable.concat(this.end)
+      [Symbol.iterator]() as Iterator<A>;
   }
 
   prepend<A1>(a: A1): ConcImplementation<A | A1> {
@@ -534,11 +531,10 @@ class Update<A> extends ConcImplementation<A> {
 
 export class Singleton<A> extends ConcImplementation<A> {
   readonly _tag = ConcTag.Singleton;
-
-  length = 1;
-  depth  = 0;
-  left   = _Empty;
-  right  = _Empty;
+  length        = 1;
+  depth         = 0;
+  left          = _Empty;
+  right         = _Empty;
   binary: boolean;
 
   constructor(readonly value: A) {
@@ -739,56 +735,52 @@ export function isConc(u: unknown): u is Conc<unknown> {
 }
 
 /**
- * @tsplus fluent fncts.Conc corresponds
+ * @tsplus pipeable fncts.Conc corresponds
  */
-export function corresponds_<A, B>(self: Conc<A>, bs: Conc<B>, f: (a: A, b: B) => boolean): boolean {
-  if (self.length !== bs.length) {
-    return false;
-  }
-
-  concrete(self);
-  concrete(bs);
-
-  const leftIterator  = self.arrayIterator();
-  const rightIterator = bs.arrayIterator();
-
-  let left: ArrayLike<A> | undefined  = undefined;
-  let right: ArrayLike<B> | undefined = 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)) {
+export function corresponds<A, B>(bs: Conc<B>, f: (a: A, b: B) => boolean) {
+  return (self: Conc<A>): boolean => {
+    if (self.length !== bs.length) {
+      return false;
+    }
+    concrete(self);
+    concrete(bs);
+    const leftIterator                  = self.arrayIterator();
+    const rightIterator                 = bs.arrayIterator();
+    let left: ArrayLike<A> | undefined  = undefined;
+    let right: ArrayLike<B> | undefined = 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;
+  };
 }
 
 /**

package/_src/collection/immutable/Conc.ts

@@ -2,7 +2,6 @@
 export * from "./Conc/api.js";
 export * from "./Conc/constructors.js";
 export * from "./Conc/definition.js";
-export * from "./Conc/derivations.js";
 // codegen:end
 
 // codegen:start { preset: barrel, include: ./Conc/api/*.ts }

package/_src/collection/immutable/Dictionary/api.ts

@@ -1,29 +1,35 @@
 /**
- * @tsplus fluent fncts.Dictionary foldLeft
+ * @tsplus pipeable fncts.Dictionary foldLeft
  */
-export function foldLeft_<A, B>(self: Dictionary<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: Dictionary<A>): B => {
+    return self.foldLeftWithIndex(b, (_, b, a) => f(b, a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Dictionary foldLeftWithIndex
+ * @tsplus pipeable fncts.Dictionary foldLeftWithIndex
  */
-export function foldLeftWithIndex_<A, B>(self: Dictionary<A>, b: B, f: (k: string, b: B, a: A) => B): B {
-  let out   = b;
-  const ks  = self.keys;
-  const len = ks.length;
-  for (let i = 0; i < len; i++) {
-    const k = ks[i]!;
-    out     = f(k, out, self.toRecord[k]!);
-  }
-  return out;
+export function foldLeftWithIndex<A, B>(b: B, f: (k: string, b: B, a: A) => B) {
+  return (self: Dictionary<A>): B => {
+    let out   = b;
+    const ks  = self.keys;
+    const len = ks.length;
+    for (let i = 0; i < len; i++) {
+      const k = ks[i]!;
+      out     = f(k, out, self.toRecord[k]!);
+    }
+    return out;
+  };
 }
 
 /**
- * @tsplus fluent fncts.Dictionary get
+ * @tsplus pipeable fncts.Dictionary get
  */
-export function get_<A>(self: Dictionary<A>, key: string): Maybe<A> {
-  return Maybe.fromNullable(self.unsafeGet(key));
+export function get(key: string) {
+  return <A>(self: Dictionary<A>): Maybe<A> => {
+    return Maybe.fromNullable(self.unsafeGet(key));
+  };
 }
 
 /**
@@ -34,24 +40,28 @@ export function keys<A>(self: Dictionary<A>): ReadonlyArray<string> {
 }
 
 /**
- * @tsplus fluent fncts.Dictionary map
+ * @tsplus pipeable fncts.Dictionary map
  */
-export function map_<A, B>(self: Dictionary<A>, f: (a: A) => B): Dictionary<B> {
-  return self.mapWithIndex((_, a) => f(a));
+export function map<A, B>(f: (a: A) => B) {
+  return (self: Dictionary<A>): Dictionary<B> => {
+    return self.mapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.Dictionary mapWithIndex
+ * @tsplus pipeable fncts.Dictionary mapWithIndex
  */
-export function mapWithIndex_<A, B>(self: Dictionary<A>, f: (k: string, a: A) => B): Dictionary<B> {
-  const out = {} as Record<string, B>;
-  const ks  = self.keys;
-  const len = ks.length;
-  for (let i = 0; i < len; i++) {
-    const k = ks[i]!;
-    out[k]  = f(k, self.toRecord[k]!);
-  }
-  return Dictionary.get(out);
+export function mapWithIndex<A, B>(f: (k: string, a: A) => B) {
+  return (self: Dictionary<A>): Dictionary<B> => {
+    const out = {} as Record<string, B>;
+    const ks  = self.keys;
+    const len = ks.length;
+    for (let i = 0; i < len; i++) {
+      const k = ks[i]!;
+      out[k]  = f(k, self.toRecord[k]!);
+    }
+    return Dictionary.get(out);
+  };
 }
 
 /**
@@ -63,8 +73,10 @@ export function toRecord<A>(self: Dictionary<A>): Record<string, A> {
 }
 
 /**
- * @tsplus fluent fncts.Dictionary unsafeGet
+ * @tsplus pipeable fncts.Dictionary unsafeGet
  */
-export function unsafeGet_<A>(self: Dictionary<A>, key: string): A | undefined {
-  return self.toRecord[key];
+export function unsafeGet(key: string) {
+  return <A>(self: Dictionary<A>): A | undefined => {
+    return self.toRecord[key];
+  };
 }

package/_src/collection/immutable/Dictionary.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./Dictionary/*.ts }
+export * from "./Dictionary/api.js";
+export * from "./Dictionary/definition.js";
+// codegen:end