@fncts/base 0.0.39 → 0.0.41

package/_src/collection/Iterable/api.ts

@@ -1,7 +1,16 @@
 import type * as P from "@fncts/base/typeclass";
 
-import { Iterable } from "@fncts/base/collection/Iterable/definition";
 import { tuple } from "@fncts/base/data/function";
+import { isNumber } from "@fncts/base/util/predicates";
+
+type PartitionHandleResult<A> =
+  | {
+      emit: true;
+      value: A;
+    }
+  | {
+      emit: false;
+    };
 
 /**
  * @tsplus pipeable fncts.Iterable ap
@@ -48,73 +57,6 @@ export function append<B>(b: B) {
   };
 }
 
-/**
- * @tsplus getter fncts.Iterable toIterable
- */
-export function toIterable<A>(self: Iterable<A>): Iterable<A> {
-  return self;
-}
-
-/**
- * @tsplus getter fncts.Iterable toArray
- */
-export function toArray<A>(self: Iterable<A>): Array<A> {
-  return Array.from(self);
-}
-
-/**
- * @tsplus pipeable fncts.Iterable flatMap
- */
-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();
-        }
-        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!();
-          }
-          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 };
-        },
-      };
-    });
-  };
-}
-
 /**
  * @tsplus pipeable fncts.Iterable concat
  */
@@ -315,6 +257,7 @@ export function filterWithIndex<A>(p: PredicateWithIndex<number, A>) {
  */
 export function find<A, B extends A>(refinement: Refinement<A, B>): (self: Iterable<A>) => Maybe<B>;
 export function find<A>(predicate: Predicate<A>): (self: Iterable<A>) => Maybe<A>;
+
 export function find<A>(predicate: Predicate<A>) {
   return (self: Iterable<A>): Maybe<A> => {
     for (const value of self) {
@@ -342,6 +285,68 @@ export function findIndex<A>(p: Predicate<A>) {
   };
 }
 
+/**
+ * @tsplus pipeable fncts.Iterable flatMap
+ */
+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();
+        }
+        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!();
+          }
+          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 };
+        },
+      };
+    });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.Iterable foldLeft
+ */
+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 pipeable fncts.Iterable foldLeftWithIndex
  */
@@ -357,15 +362,6 @@ export function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B) {
   };
 }
 
-/**
- * @tsplus pipeable fncts.Iterable foldLeft
- */
-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 pipeable fncts.Iterable foldMap
  */
@@ -390,6 +386,15 @@ export function foldMapWithIndex<A, M>(f: (i: number, a: A) => M, /** @tsplus au
   };
 }
 
+/**
+ * @tsplus pipeable fncts.Iterable foldRight
+ */
+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 pipeable fncts.Iterable foldRightWithIndex
  */
@@ -409,13 +414,75 @@ export function foldRightWithIndex<A, B>(b: Eval<B>, f: (i: number, a: A, b: Eva
   };
 }
 
+function handlePartition<A>(
+  predicate: PredicateWithIndex<number, A>,
+  i: number,
+  a: A,
+  h: boolean,
+): PartitionHandleResult<A> {
+  return h === predicate(i, a) ? { emit: true, value: a } : { emit: false };
+}
+
+function handlePartitionMap<A, B, C>(
+  f: (i: number, a: A) => Either<B, C>,
+  i: number,
+  a: A,
+  h: "Left" | "Right",
+): PartitionHandleResult<B | C> {
+  const bc = f(i, a);
+  Either.concrete(bc);
+  return h === "Left" && bc._tag === "Left"
+    ? { emit: true, value: bc.left }
+    : h === "Right" && bc._tag === "Right"
+      ? { emit: true, value: bc.right }
+      : { emit: false };
+}
+
 /**
- * @tsplus pipeable fncts.Iterable foldRight
+ * @tsplus getter fncts.Iterable intrinsicSize
  */
-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));
-  };
+export function intrinsicSize<A>(self: Iterable<A>): Maybe<number> {
+  if (self.hasProperty("size") && isNumber(self["size"])) {
+    return Just(self.size);
+  }
+
+  if (self.hasProperty("length") && isNumber(self["length"])) {
+    return Just(self.length);
+  }
+
+  return Nothing();
+}
+
+/**
+ * @tsplus getter fncts.Iterable isEmpty
+ */
+export function isEmpty<A>(self: Iterable<A>): boolean {
+  return self.intrinsicSize.match(
+    () => {
+      for (const _ of self) {
+        return false;
+      }
+
+      return true;
+    },
+    (n) => n <= 0,
+  );
+}
+
+/**
+ * @tsplus getter fncts.Iterable isNonEmpty
+ */
+export function isNonEmpty<A>(self: Iterable<A>): boolean {
+  return self.intrinsicSize.match(
+    () => {
+      for (const _ of self) {
+        return true;
+      }
+
+      return false;
+    },
+    (n) => n > 0,
+  );
 }
 
 /**
@@ -462,27 +529,38 @@ export function mapWithIndex<A, B>(f: (i: number, a: A) => B) {
   };
 }
 
-type PartitionHandleResult<A> =
-  | {
-      emit: true;
-      value: A;
-    }
-  | {
-      emit: false;
-    };
-function handlePartitionMap<A, B, C>(
-  f: (i: number, a: A) => Either<B, C>,
-  i: number,
-  a: A,
-  h: "Left" | "Right",
-): PartitionHandleResult<B | C> {
-  const bc = f(i, a);
-  Either.concrete(bc);
-  return h === "Left" && bc._tag === "Left"
-    ? { emit: true, value: bc.left }
-    : h === "Right" && bc._tag === "Right"
-      ? { emit: true, value: bc.right }
-      : { emit: false };
+/**
+ * @tsplus pipeable fncts.Iterable partition
+ */
+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 pipeable fncts.Iterable partitionMap
+ */
+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 pipeable fncts.Iterable partitionMapWithIndex
+ */
+export function partitionMapWithIndex<A, B, C>(f: (i: number, a: A) => Either<B, C>) {
+  return (self: Iterable<A>): readonly [Iterable<B>, Iterable<C>] => {
+    return tuple(
+      Iterable.make(() => partitionMapWithIndexIterator(self, f, "Left")) as Iterable<B>,
+      Iterable.make(() => partitionMapWithIndexIterator(self, f, "Right")) as Iterable<C>,
+    );
+  };
 }
 
 function partitionMapWithIndexIterator<A, B, C>(
@@ -524,35 +602,23 @@ function partitionMapWithIndexIterator<A, B, C>(
 }
 
 /**
- * @tsplus pipeable fncts.Iterable partitionMap
- */
-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 pipeable fncts.Iterable partitionMapWithIndex
+ * @tsplus pipeable fncts.Iterable partitionWithIndex
  */
-export function partitionMapWithIndex<A, B, C>(f: (i: number, a: A) => Either<B, C>) {
-  return (self: Iterable<A>): readonly [Iterable<B>, Iterable<C>] => {
+export function partitionWithIndex<A, B extends A>(
+  p: RefinementWithIndex<number, A, B>,
+): (self: Iterable<A>) => readonly [Iterable<A>, Iterable<B>];
+export function partitionWithIndex<A>(
+  p: PredicateWithIndex<number, A>,
+): (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(() => partitionMapWithIndexIterator(self, f, "Left")) as Iterable<B>,
-      Iterable.make(() => partitionMapWithIndexIterator(self, f, "Right")) as Iterable<C>,
+      Iterable.make(() => partitionWithIndexIterator(self, p, false)),
+      Iterable.make(() => partitionWithIndexIterator(self, p, true)),
     );
   };
 }
 
-function handlePartition<A>(
-  predicate: PredicateWithIndex<number, A>,
-  i: number,
-  a: A,
-  h: boolean,
-): PartitionHandleResult<A> {
-  return h === predicate(i, a) ? { emit: true, value: a } : { emit: false };
-}
-
 function partitionWithIndexIterator<A>(
   self: Iterable<A>,
   predicate: PredicateWithIndex<number, A>,
@@ -591,37 +657,6 @@ function partitionWithIndexIterator<A>(
   };
 }
 
-/**
- * @tsplus pipeable fncts.Iterable partition
- */
-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 pipeable fncts.Iterable partitionWithIndex
- */
-export function partitionWithIndex<A, B extends A>(
-  p: RefinementWithIndex<number, A, B>,
-): (self: Iterable<A>) => readonly [Iterable<A>, Iterable<B>];
-export function partitionWithIndex<A>(
-  p: PredicateWithIndex<number, A>,
-): (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)),
-    );
-  };
-}
-
 /**
  * @tsplus static fncts.IterableOps replicate
  */
@@ -633,11 +668,15 @@ export function replicate<A>(n: number, a: A): Iterable<A> {
  * @tsplus getter fncts.Iterable size
  */
 export function size<A>(self: Iterable<A>): number {
-  let len = 0;
-  for (const _ of self) {
-    len += 1;
-  }
-  return len;
+  return self.intrinsicSize.getOrElse(() => {
+    let len = 0;
+
+    for (const _ of self) {
+      len += 1;
+    }
+
+    return len;
+  });
 }
 
 /**
@@ -683,6 +722,20 @@ export function take(n: number) {
   };
 }
 
+/**
+ * @tsplus getter fncts.Iterable toArray
+ */
+export function toArray<A>(self: Iterable<A>): Array<A> {
+  return Array.from(self);
+}
+
+/**
+ * @tsplus getter fncts.Iterable toIterable
+ */
+export function toIterable<A>(self: Iterable<A>): Iterable<A> {
+  return self;
+}
+
 /**
  * @tsplus pipeable fncts.Iterable zipWith
  */

package/_src/collection/Iterable/constructors.ts

@@ -1,7 +1,5 @@
 import { Iterable } from "@fncts/base/collection/Iterable/definition";
 
-import {} from "./definition.js";
-
 /**
  * @tsplus static fncts.IterableOps make
  */

package/_src/collection/compat/ArrayLike/definition.ts

@@ -2,10 +2,10 @@ declare global {
   /**
    * @tsplus type fncts.ArrayLike
    */
-  interface ArrayLike<T> {}
+  export interface ArrayLike<T> {}
 
   /**
    * @tsplus type fncts.ArrayLike
    */
-  interface RelativeIndexable<T> {}
+  export interface RelativeIndexable<T> {}
 }

package/_src/collection/compat.ts

@@ -2,5 +2,4 @@
 // codegen:start { preset: type-barrel, include: ./compat/*.ts }
 export type {} from "./compat/Set.js";
 export type {} from "./compat/Map.js";
-export type {} from "./compat/Array.js";
 // codegen:end

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

@@ -1,4 +1,3 @@
-import { ImmutableArray } from "../ImmutableArray.js";
 import { ByteChunk, Chunk, Singleton } from "./definition.js";
 
 /**
@@ -27,7 +26,7 @@ export function make<A>(...as: ReadonlyArray<A>): Conc<A> {
  * @tsplus static fncts.ConcOps range
  */
 export function range(start: number, end: number): Conc<number> {
-  return Conc.fromArray(ImmutableArray.range(start, end)._array);
+  return Conc.fromArray(Array.range(start, end));
 }
 
 /**

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

@@ -322,7 +322,9 @@ class AppendN<A> extends ConcImplementation<A> {
   }
 
   [Symbol.iterator](): Iterator<A> {
-    return this.start.toIterable.concat(this.buffer.toIterable.take(this.bufferUsed))[Symbol.iterator]() as Iterator<A>;
+    return this.start.toIterable
+      .concat((<ArrayLike<A>>this.buffer).toIterable.take(this.bufferUsed))
+      [Symbol.iterator]();
   }
 
   append<A1>(a: A1): ConcImplementation<A | A1> {
@@ -382,7 +384,7 @@ class AppendN<A> extends ConcImplementation<A> {
   }
 }
 
-class PrependN<A> extends ConcImplementation<A> {
+export class PrependN<A> extends ConcImplementation<A> {
   readonly _tag = ConcTag.PrependN;
 
   length: number;
@@ -405,10 +407,9 @@ class PrependN<A> extends ConcImplementation<A> {
   }
 
   [Symbol.iterator](): Iterator<A> {
-    return this.buffer
-      .slice(BUFFER_SIZE - this.bufferUsed, this.buffer.length)
-      .toIterable.concat(this.end)
-      [Symbol.iterator]() as Iterator<A>;
+    return (<ArrayLike<A>>this.buffer.slice(BUFFER_SIZE - this.bufferUsed, this.buffer.length)).toIterable
+      .concat(this.end)
+      [Symbol.iterator]();
   }
 
   prepend<A1>(a: A1): ConcImplementation<A | A1> {

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

@@ -353,7 +353,7 @@ export function unsafeLast<A>(self: List<A>): A {
   }
   let these = self;
   let scout = self.tail;
-  while (!scout.isEmpty()) {
+  while (scout.isNonEmpty()) {
     these = scout;
     scout = scout.tail;
   }
@@ -363,7 +363,7 @@ export function unsafeLast<A>(self: List<A>): A {
 function copyToArrayWithIndex<A>(list: List<A>, arr: Array<[number, A]>): void {
   let these = list;
   let i     = 0;
-  while (!these.isEmpty()) {
+  while (these.isNonEmpty()) {
     arr[i] = [i, these.head];
     these  = these.tail;
     i++;

package/_src/collection/immutable/ReadonlyArray/api/chunksOf.ts

@@ -0,0 +1,8 @@
+/**
+ * @tsplus pipeable fncts.ReadonlyArray chunksOf
+ */
+export function chunksOf(n: number) {
+  return <A>(self: ReadonlyArray<A>): ReadonlyArray<ReadonlyArray<A>> => {
+    return self.chop((as) => as.splitAt(n));
+  };
+}

package/_src/collection/immutable/ReadonlyArray/api/splitAt.ts

@@ -0,0 +1,8 @@
+/**
+ * @tsplus pipeable fncts.ReadonlyArray splitAt
+ */
+export function splitAt(n: number) {
+  return <A>(as: ReadonlyArray<A>): readonly [ReadonlyArray<A>, ReadonlyArray<A>] => {
+    return [as.slice(0, n), as.slice(n)];
+  };
+}

package/_src/collection/immutable/{ImmutableArray → ReadonlyArray}/api/splitWhere.ts

@@ -1,12 +1,12 @@
 /**
- * @tsplus pipeable fncts.ImmutableArray splitWhere
+ * @tsplus pipeable fncts.ReadonlyArray splitWhere
  */
 export function splitWhere<A>(p: Predicate<A>) {
-  return (self: ImmutableArray<A>): readonly [ImmutableArray<A>, ImmutableArray<A>] => {
+  return (self: ReadonlyArray<A>): readonly [ReadonlyArray<A>, ReadonlyArray<A>] => {
     let cont = true;
     let i    = 0;
     while (cont && i < self.length) {
-      if (p(self._array[i]!)) {
+      if (p(self[i]!)) {
         cont = false;
       } else {
         i++;