@fncts/base 0.0.39 → 0.0.41

package/_src/collection/immutable.ts

@@ -1,14 +1,14 @@
 /* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: type-barrel, include: ./immutable/*.ts }
-export type {} from "./immutable/Vector.js";
-export type {} from "./immutable/SortedMap.js";
-export type {} from "./immutable/RoseTree.js";
-export type {} from "./immutable/Queue.js";
-export type {} from "./immutable/List.js";
-export type {} from "./immutable/ImmutableNonEmptyArray.js";
-export type {} from "./immutable/ImmutableArray.js";
-export type {} from "./immutable/HashSet.js";
-export type {} from "./immutable/HashMap.js";
-export type {} from "./immutable/Dictionary.js";
-export type {} from "./immutable/Conc.js";
+export type {} from "./immutable/Vector.js"
+export type {} from "./immutable/SortedMap.js"
+export type {} from "./immutable/RoseTree.js"
+export type {} from "./immutable/ReadonlyNonEmptyArray.js"
+export type {} from "./immutable/ReadonlyArray.js"
+export type {} from "./immutable/Queue.js"
+export type {} from "./immutable/List.js"
+export type {} from "./immutable/HashSet.js"
+export type {} from "./immutable/HashMap.js"
+export type {} from "./immutable/Dictionary.js"
+export type {} from "./immutable/Conc.js"
 // codegen:end

package/_src/collection.ts

@@ -1,8 +1,9 @@
 /* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: type-barrel, include: ./collection/*.ts, exclude: collection/internal.ts }
-export type {} from "./collection/weak.js";
-export type {} from "./collection/mutable.js";
-export type {} from "./collection/immutable.js";
-export type {} from "./collection/compat.js";
-export type {} from "./collection/Iterable.js";
+export type {} from "./collection/weak.js"
+export type {} from "./collection/mutable.js"
+export type {} from "./collection/immutable.js"
+export type {} from "./collection/compat.js"
+export type {} from "./collection/Iterable.js"
+export type {} from "./collection/AsyncIterable.js"
 // codegen:end

package/_src/control/Eval/api.ts

@@ -3,6 +3,15 @@ import type { _A } from "@fncts/base/types";
 import { EvalPrimitive, EvalTag } from "@fncts/base/control/Eval/definition";
 import { identity } from "@fncts/base/data/function";
 
+/**
+ * @tsplus pipeable fncts.control.Eval ap
+ */
+export function ap<A>(fa: Eval<A>) {
+  return <B>(self: Eval<(a: A) => B>): Eval<B> => {
+    return self.zipWith(fa, (f, a) => f(a));
+  };
+}
+
 /**
  * @tsplus pipeable fncts.control.Eval and
  */
@@ -24,6 +33,43 @@ export function flatMap<A, B>(f: (a: A) => Eval<B>) {
   };
 }
 
+/**
+ * @tsplus static fncts.control.EvalOps whileLoop
+ */
+export function whileLoop<A>(check: Lazy<boolean>, body: Lazy<Eval<A>>, process: (a: A) => void): Eval<void> {
+  return Eval.defer(() => {
+    if (check()) {
+      return body().flatMap((a) => {
+        process(a);
+        return whileLoop(check, body, process);
+      });
+    } else {
+      return Eval.unit;
+    }
+  });
+}
+
+/**
+ * @tsplus static fncts.control.EvalOps forEach
+ */
+export function forEach<A, B>(as: Iterable<A>, f: (a: A) => Eval<B>): Eval<Conc<B>> {
+  return Eval.defer(() => {
+    const iterator               = as[Symbol.iterator]();
+    let value: IteratorResult<A> = iterator.next();
+
+    const out = new ConcBuilder<B>();
+
+    return Eval.whileLoop(
+      () => !value?.done,
+      () => f(value!.value),
+      (b) => {
+        out.append(b);
+        value = iterator.next();
+      },
+    ).map(() => out.result());
+  });
+}
+
 /**
  * @tsplus getter fncts.control.Eval flatten
  */
@@ -58,24 +104,75 @@ export function zip<B>(fb: Eval<B>) {
   };
 }
 
+export function foreachWithIndex<A, B>(as: Iterable<A>, f: (index: number, a: A) => Eval<B>): Eval<ReadonlyArray<B>> {
+  return Eval.defer(() => {
+    const it = as[Symbol.iterator]();
+    let i    = 0;
+    let result: IteratorResult<A> = it.next();
+
+    const out: Array<B> = [];
+
+    return Eval.whileLoop(
+      () => !result.done,
+      () => f(i, result.value),
+      (b) => {
+        i++;
+        result = it.next();
+        out.push(b);
+      },
+    ).map(() => out);
+  });
+}
+
 /**
- * @tsplus pipeable fncts.control.Eval ap
+ * @tsplus static fncts.control.EvalOps foreach
  */
-export function ap<A>(fa: Eval<A>) {
-  return <B>(self: Eval<(a: A) => B>): Eval<B> => {
-    return self.zipWith(fa, (f, a) => f(a));
-  };
+export function foreach<A, B>(as: Iterable<A>, f: (a: A) => Eval<B>): Eval<ReadonlyArray<B>> {
+  return Eval.defer(() => {
+    const it = as[Symbol.iterator]();
+    let result: IteratorResult<A> = it.next();
+    const out: Array<B>           = [];
+    return Eval.whileLoop(
+      () => !result.done,
+      () => f(result.value),
+      (b) => {
+        result = it.next();
+        out.push(b);
+      },
+    ).map(() => out);
+  });
 }
 
 /**
- * @tsplus static fncts.control.EvalOps sequenceT
+ * @tsplus static fncts.control.EvalOps all
  */
-export function sequenceT<A extends Array<Eval<any>>>(
-  ...computations: A
-): Eval<{
-  [K in keyof A]: _A<A[K]>;
-}> {
-  return Eval.defer(Eval.now(computations.map((e) => e.run)) as Eval<any>);
+export function all<A extends ReadonlyArray<Eval<any>>>(...computations: A): Eval<{ [K in keyof A]: _A<A[K]> }>;
+export function all<A extends Iterable<Eval<any>>>(
+  computations: A,
+): [A] extends [Iterable<infer A>] ? Eval<ReadonlyArray<_A<A>>> : never;
+export function all<A extends Record<string, Eval<any>>>(computations: A): Eval<{ [K in keyof A]: _A<A[K]> }>;
+export function all(
+  ...args: [Record<string, Eval<any>>] | [Iterable<Eval<any>>] | ReadonlyArray<Eval<any>>
+): Eval<any> {
+  if (args.length === 1) {
+    const arg = args[0];
+    if (Symbol.iterator in arg) {
+      return Eval.foreach(<Iterable<Eval<any>>>arg, identity);
+    } else {
+      return Eval.foreach(
+        Object.entries(arg).map(([k, computation]) => (<Eval<any>>computation).map((value) => [k, value] as const)),
+        identity,
+      ).map((result) => {
+        const out: Record<string, any> = {};
+        for (const [k, v] of result) {
+          out[k] = v;
+        }
+        return out;
+      });
+    }
+  } else {
+    return Eval.foreach(<Iterable<Eval<any>>>args, identity);
+  }
 }
 
 class GenEval<A> {
@@ -113,7 +210,3 @@ export function gen<T extends GenEval<any>, A>(
     return runGenEval(state, iterator);
   });
 }
-
-// codegen:start { preset: barrel, include: api/*.ts }
-export * from "./api/sequenceArray.js";
-// codegen:end

package/_src/control/Eval/constructors.ts

@@ -26,6 +26,11 @@ export function always<A>(make: Lazy<A>): Eval<A> {
   return Eval.defer(Eval.now(make()));
 }
 
+/**
+ * @tsplus static fncts.control.EvalOps unit
+ */
+export const unit: Eval<void> = Eval.now(undefined);
+
 const UNSET = Symbol.for("@tsplus/base/control/Eval/UNSET");
 
 /**

package/_src/control/Pure/runtime.ts

@@ -143,8 +143,14 @@ export function unsafeRunAll<S1>(s: S1) {
               environment.push(currPure.i1);
               current             = new PurePrimitive(PureTag.Match) as any;
               (current as any).i0 = currPure;
-              (current as any).i1 = (e: any) => Pure.succeedNow(environment.pop()).flatMap(() => Pure.failNow(e));
-              (current as any).i2 = (a: any) => Pure.succeedNow(environment.pop()).flatMap(() => Pure.succeedNow(a));
+              (current as any).i1 = (log: Conc<any>, e: Cause<any>) => {
+                environment.pop();
+                return Pure.failCauseNow(e).writeAll(log);
+              };
+              (current as any).i2 = (a: any) => {
+                environment.pop();
+                return Pure.succeedNow(a);
+              };
               break;
             }
             case PureTag.Modify: {

package/_src/data/CaseClass.ts

@@ -8,7 +8,7 @@ const keysSymbol = Symbol.for("fncts.CaseClass.keys");
 const argsSymbol = Symbol.for("fncts.CaseClass.args");
 
 export interface CaseArgs {
-  readonly [CaseClassTypeId]: ImmutableArray<string>;
+  readonly [CaseClassTypeId]: ReadonlyArray<string>;
 }
 
 export interface Copy<T> {
@@ -16,7 +16,7 @@ export interface Copy<T> {
 }
 
 export interface CaseConstructor {
-  [CaseClassTypeId]: ImmutableArray<string>;
+  [CaseClassTypeId]: ReadonlyArray<string>;
   new <T>(args: Equals<T, {}> extends True ? void : T): T & Copy<T> & CaseArgs;
 }
 
@@ -31,14 +31,14 @@ export const CaseClass: CaseConstructor = class<T extends Record<PropertyKey, an
   implements Hashable, Equatable, CaseArgs
 {
   private [argsSymbol]: T;
-  private [keysSymbol]: ImmutableArray<string> = ImmutableArray.empty();
+  private [keysSymbol]: ReadonlyArray<string> = [];
   constructor(args: T) {
     this[argsSymbol] = args;
-    this[keysSymbol] = args ? Object.keys(args).asImmutableArray : ImmutableArray.empty();
+    this[keysSymbol] = args ? Object.keys(args) : [];
     Object.assign(this, args);
   }
 
-  get [CaseClassTypeId](): ImmutableArray<string> {
+  get [CaseClassTypeId](): ReadonlyArray<string> {
     return this[keysSymbol];
   }
 

package/_src/data/Cause/api/fold.ts

@@ -36,8 +36,8 @@ function foldLoop<E, Z>(
   out: List<Either<CauseCase, Z>>,
 ): List<Z> {
   if (inp.isNonEmpty()) {
-    const head   = inp.unsafeHead;
-    const causes = inp.unsafeTail;
+    const head   = inp.head;
+    const causes = inp.tail;
     switch (head._tag) {
       case CauseTag.Empty:
         return foldLoop(cases, causes, out.prepend(Either.right(cases.Empty())));

package/_src/data/Const/api.ts

@@ -1,5 +1,13 @@
 import { Const } from "./definition.js";
 
+/**
+ * @tsplus static fncts.ConstOps make
+ * @tsplus static fncts.ConstOps __call
+ */
+export function makeConst<E, A = never>(e: E): Const<E, A> {
+  return new Const(e);
+}
+
 /**
  * @tsplus pipeable fncts.Const map
  */
@@ -8,11 +16,3 @@ export function map<A, B>(_f: (a: A) => B) {
     return self.unsafeCoerce();
   };
 }
-
-/**
- * @tsplus static fncts.ConstOps make
- * @tsplus static fncts.ConstOps __call
- */
-export function makeConst<E, A = never>(e: E): Const<E, A> {
-  return new Const(e);
-}

package/_src/data/Const/instances.ts

@@ -3,6 +3,16 @@ import type { ConstF } from "@fncts/base/data/Const/definition";
 
 import { Const } from "@fncts/base/data/Const/definition";
 
+/**
+ * @tsplus static fncts.ConstOps getApplicative
+ */
+export function getApplicative<E>(M: P.Monoid<E>): P.Applicative<ConstF, HKT.Fix<"E", E>> {
+  return {
+    ...getApply(M),
+    pure: <A>() => Const<E, A>(M.nat),
+  };
+}
+
 /**
  * @tsplus static fncts.ConstOps getApply
  */
@@ -13,13 +23,3 @@ export function getApply<E>(S: P.Semigroup<E>) {
     zipWith: (that, _f) => (self) => Const(S.combine(that.getConst)(self.getConst)),
   });
 }
-
-/**
- * @tsplus static fncts.ConstOps getApplicative
- */
-export function getApplicative<E>(M: P.Monoid<E>): P.Applicative<ConstF, HKT.Fix<"E", E>> {
-  return {
-    ...getApply(M),
-    pure: <A>() => Const<E, A>(M.nat),
-  };
-}

package/_src/data/Datum/api.ts

@@ -17,86 +17,6 @@ export function initial<A = never>(): Datum<A> {
 
 const _Pending = new Pending();
 
-/**
- * @tsplus static fncts.DatumOps pending
- * @tsplus static fncts.Datum.PendingOps __call
- */
-export function pending<A = never>(): Datum<A> {
-  return _Pending;
-}
-
-/**
- * @tsplus static fncts.DatumOps refresh
- * @tsplus static fncts.Datum.RefreshOps __call
- */
-export function refresh<A>(value: A): Datum<A> {
-  return new Refresh(value);
-}
-
-/**
- * @tsplus static fncts.DatumOps replete
- * @tsplus static fncts.Datum.RepleteOps __call
- */
-export function replete<A>(value: A): Datum<A> {
-  return new Replete(value);
-}
-
-/**
- * @tsplus getter fncts.Datum value
- */
-export function left<E, A>(self: Datum<A>): A | undefined {
-  return self.isNonEmpty() ? self.value : undefined;
-}
-
-/**
- * @tsplus fluent fncts.Datum isInitial
- */
-export function isInitial<A>(self: Datum<A>): self is Initial {
-  return self._tag === DatumTag.Initial;
-}
-
-/**
- * @tsplus fluent fncts.Datum isPending
- */
-export function isPending<A>(self: Datum<A>): self is Pending {
-  return self._tag === DatumTag.Pending;
-}
-
-/**
- * @tsplus fluent fncts.Datum isRefresh
- */
-export function isRefresh<A>(self: Datum<A>): self is Refresh<A> {
-  return self._tag === DatumTag.Refresh;
-}
-
-/**
- * @tsplus fluent fncts.Datum isReplete
- */
-export function isReplete<A>(self: Datum<A>): self is Replete<A> {
-  return self._tag === DatumTag.Replete;
-}
-
-/**
- * @tsplus fluent fncts.Datum isEmpty
- */
-export function isEmpty<A>(self: Datum<A>): self is Initial | Pending {
-  return self.isInitial() || self.isPending();
-}
-
-/**
- * @tsplus fluent fncts.Datum isNonEmpty
- */
-export function isNonEmpty<A>(self: Datum<A>): self is Refresh<A> | Replete<A> {
-  return self.isRefresh() || self.isReplete();
-}
-
-/**
- * @tsplus fluent fncts.Datum isLoading
- */
-export function isLoading<A>(self: Datum<A>): self is Pending | Refresh<A> {
-  return self.isPending() || self.isRefresh();
-}
-
 /**
  * @tsplus pipeable fncts.Datum elem
  */
@@ -111,20 +31,6 @@ export function elem<A>(a: A, /** @tsplus auto */ E: Eq<A>) {
   };
 }
 
-/**
- * @tsplus pipeable fncts.Datum some
- */
-export function some<A>(p: Predicate<A>) {
-  return (self: Datum<A>): boolean => {
-    return self.match({
-      Initial: () => false,
-      Pending: () => false,
-      Refresh: p,
-      Replete: p,
-    });
-  };
-}
-
 /**
  * @tsplus pipeable fncts.Datum extend
  */
@@ -138,7 +44,9 @@ export function extend<A, B>(f: (wa: Datum<A>) => B) {
  * @tsplus pipeable fncts.Datum filter
  */
 export function filter<A, B extends A>(p: Refinement<A, B>): (self: Datum<A>) => Datum<B>;
+
 export function filter<A>(p: Predicate<A>): (self: Datum<A>) => Datum<A>;
+
 export function filter<A>(p: Predicate<A>) {
   return (self: Datum<A>): Datum<A> => {
     return self.match({
@@ -244,6 +152,70 @@ export function getOrElse<B>(b: Lazy<B>) {
   };
 }
 
+/**
+ * @tsplus fluent fncts.Datum isEmpty
+ */
+export function isEmpty<A>(self: Datum<A>): self is Initial | Pending {
+  return self.isInitial() || self.isPending();
+}
+
+/**
+ * @tsplus fluent fncts.Datum isInitial
+ */
+export function isInitial<A>(self: Datum<A>): self is Initial {
+  return self._tag === DatumTag.Initial;
+}
+
+/**
+ * @tsplus fluent fncts.Datum isLoading
+ */
+export function isLoading<A>(self: Datum<A>): self is Pending | Refresh<A> {
+  return self.isPending() || self.isRefresh();
+}
+
+/**
+ * @tsplus fluent fncts.Datum isNonEmpty
+ */
+export function isNonEmpty<A>(self: Datum<A>): self is Refresh<A> | Replete<A> {
+  return self.isRefresh() || self.isReplete();
+}
+/**
+ * @tsplus fluent fncts.Datum isPending
+ */
+export function isPending<A>(self: Datum<A>): self is Pending {
+  return self._tag === DatumTag.Pending;
+}
+/**
+ * @tsplus fluent fncts.Datum isRefresh
+ */
+export function isRefresh<A>(self: Datum<A>): self is Refresh<A> {
+  return self._tag === DatumTag.Refresh;
+}
+
+/**
+ * @tsplus fluent fncts.Datum isReplete
+ */
+export function isReplete<A>(self: Datum<A>): self is Replete<A> {
+  return self._tag === DatumTag.Replete;
+}
+
+/**
+ * @tsplus pipeable fncts.Datum map
+ */
+export function map<A, B>(f: (a: A) => B) {
+  return (self: Datum<A>): Datum<B> => {
+    switch (self._tag) {
+      case DatumTag.Initial:
+      case DatumTag.Pending:
+        return self;
+      case DatumTag.Refresh:
+        return Refresh(f(self.value));
+      case DatumTag.Replete:
+        return Replete(f(self.value));
+    }
+  };
+}
+
 /**
  * @tsplus pipeable fncts.Datum match
  */
@@ -285,23 +257,6 @@ export function match2<A, B, C>(onEmpty: (isLoading: boolean) => B, onValue: (a:
   };
 }
 
-/**
- * @tsplus pipeable fncts.Datum map
- */
-export function map<A, B>(f: (a: A) => B) {
-  return (self: Datum<A>): Datum<B> => {
-    switch (self._tag) {
-      case DatumTag.Initial:
-      case DatumTag.Pending:
-        return self;
-      case DatumTag.Refresh:
-        return Refresh(f(self.value));
-      case DatumTag.Replete:
-        return Replete(f(self.value));
-    }
-  };
-}
-
 /**
  * @tsplus pipeable fncts.Datum orElse
  */
@@ -349,6 +304,44 @@ export function partitionMap<A, B, C>(f: (a: A) => Either<B, C>) {
   };
 }
 
+/**
+ * @tsplus static fncts.DatumOps pending
+ * @tsplus static fncts.Datum.PendingOps __call
+ */
+export function pending<A = never>(): Datum<A> {
+  return _Pending;
+}
+
+/**
+ * @tsplus static fncts.DatumOps refresh
+ * @tsplus static fncts.Datum.RefreshOps __call
+ */
+export function refresh<A>(value: A): Datum<A> {
+  return new Refresh(value);
+}
+
+/**
+ * @tsplus static fncts.DatumOps replete
+ * @tsplus static fncts.Datum.RepleteOps __call
+ */
+export function replete<A>(value: A): Datum<A> {
+  return new Replete(value);
+}
+
+/**
+ * @tsplus pipeable fncts.Datum some
+ */
+export function some<A>(p: Predicate<A>) {
+  return (self: Datum<A>): boolean => {
+    return self.match({
+      Initial: () => false,
+      Pending: () => false,
+      Refresh: p,
+      Replete: p,
+    });
+  };
+}
+
 /**
  * @tsplus getter fncts.Datum toPending
  */
@@ -362,7 +355,6 @@ export function toPending<A>(self: Datum<A>): Datum<A> {
     case DatumTag.Replete:
       return Refresh(self.value);
   }
-  // return self.isEmpty() ? self : Refresh(self.value);
 }
 
 /**
@@ -375,7 +367,7 @@ export function toReplete<A>(self: Datum<A>): Datum<A> {
 /**
  * @tsplus getter fncts.Datum traverse
  */
-export function _traverse<A>(self: Datum<A>) {
+export function traverse_<A>(self: Datum<A>) {
   return <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) =>
     <K, Q, W, X, I, S, R, E1, B>(
       f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>,
@@ -388,6 +380,13 @@ export function _traverse<A>(self: Datum<A>) {
       });
 }
 
+/**
+ * @tsplus getter fncts.Datum value
+ */
+export function value<A>(self: Datum<A>): A | undefined {
+  return self.isNonEmpty() ? self.value : undefined;
+}
+
 export const traverse: P.Traversable<DatumF>["traverse"] = (G) => (f) => (self) => self.traverse(G)(f);
 
 /**
@@ -398,6 +397,7 @@ export function zip<B>(that: Datum<B>) {
     return self.zipWith(that, (a, b) => Zipped(a, b));
   };
 }
+
 /**
  * @tsplus pipeable fncts.Datum zipWith
  */

package/_src/data/Datum.ts

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