@fncts/base 0.0.32 → 0.0.34

package/_src/collection/immutable/Vector.ts

@@ -1,4 +1,5 @@
-// codegen:start { preset: barrel, include: ./Vector/*.ts, exclude: ./Vector/internal.ts }
-export * from "./Vector/api.js";
+/* eslint-disable simple-import-sort/exports */
+// codegen:start { preset: barrel, include: ./Vector/*.ts, exclude: Vector/internal.ts }
 export * from "./Vector/definition.js";
+export * from "./Vector/api.js";
 // codegen:end

package/_src/collection/immutable.ts

@@ -1,13 +1,14 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: type-barrel, include: ./immutable/*.ts }
-export type {} from "./immutable/Conc.js";
-export type {} from "./immutable/Dictionary.js";
-export type {} from "./immutable/HashMap.js";
-export type {} from "./immutable/HashSet.js";
-export type {} from "./immutable/ImmutableArray.js";
-export type {} from "./immutable/ImmutableNonEmptyArray.js";
-export type {} from "./immutable/List.js";
-export type {} from "./immutable/Queue.js";
-export type {} from "./immutable/RoseTree.js";
-export type {} from "./immutable/SortedMap.js";
 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";
 // codegen:end

package/_src/collection/mutable/ArrayDeque.ts

@@ -6,7 +6,11 @@ const DEFAULT_INITIAL_SIZE = 16;
  * @tsplus companion fncts.MutableArrayDeque
  */
 export class ArrayDeque<A> {
-  constructor(protected array: Array<A>, private start: number, private end: number) {}
+  constructor(
+    protected array: Array<A>,
+    private start: number,
+    private end: number,
+  ) {}
 
   static empty<A>(initialSize = DEFAULT_INITIAL_SIZE): ArrayDeque<A> {
     return new ArrayDeque(new Array(initialSize), 0, 0);

package/_src/collection/mutable/HashMap.ts

@@ -281,7 +281,12 @@ export class HashMap<K, V> implements Iterable<readonly [K, V]> {
 }
 
 class Node<K, V> {
-  constructor(public key: K, public hash: number, public value: V, public next: Node<K, V> | undefined) {}
+  constructor(
+    public key: K,
+    public hash: number,
+    public value: V,
+    public next: Node<K, V> | undefined,
+  ) {}
 
   findNode(k: K, h: number, equals: (y: K) => (x: K) => boolean): Node<K, V> | undefined {
     let n: Node<K, V> | undefined = this;
@@ -309,7 +314,10 @@ export class HashMapIterator<K, V, A> implements Iterator<A> {
   private i = 0;
   private len: number;
   private done = false;
-  constructor(private table: Array<Node<K, V> | undefined>, private extract: (nd: Node<K, V>) => A) {
+  constructor(
+    private table: Array<Node<K, V> | undefined>,
+    private extract: (nd: Node<K, V>) => A,
+  ) {
     this.len = table.length;
   }
 

package/_src/collection/mutable/HashSet.ts

@@ -188,7 +188,11 @@ export class HashSet<A> implements Iterable<A> {
 }
 
 class Node<K> {
-  constructor(public key: K, public hash: number, public next: Node<K> | undefined) {}
+  constructor(
+    public key: K,
+    public hash: number,
+    public next: Node<K> | undefined,
+  ) {}
 
   findNode(k: K, h: number, equals: (y: K) => (x: K) => boolean): Node<K> | undefined {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
@@ -218,7 +222,10 @@ export class HashSetIterator<V, A> implements Iterator<A> {
   private len: number;
   private i    = 0;
   private done = false;
-  constructor(private table: Array<Node<V> | undefined>, private extract: (nd: Node<V>) => A) {
+  constructor(
+    private table: Array<Node<V> | undefined>,
+    private extract: (nd: Node<V>) => A,
+  ) {
     this.len = table.length;
   }
 

package/_src/collection/mutable.ts

@@ -1,8 +1,9 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: type-barrel, include: ./mutable/*.ts }
-export type {} from "./mutable/ArrayDeque.js";
-export type {} from "./mutable/HashMap.js";
-export type {} from "./mutable/HashSet.js";
 export type {} from "./mutable/internal.js";
-export type {} from "./mutable/ListBuffer.js";
 export type {} from "./mutable/Queue.js";
+export type {} from "./mutable/ListBuffer.js";
+export type {} from "./mutable/HashSet.js";
+export type {} from "./mutable/HashMap.js";
+export type {} from "./mutable/ArrayDeque.js";
 // codegen:end

package/_src/collection/weak.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: type-barrel, include: ./weak/*.ts }
-export type {} from "./weak/IterableWeakMap.js";
 export type {} from "./weak/IterableWeakSet.js";
+export type {} from "./weak/IterableWeakMap.js";
 // codegen:end

package/_src/collection.ts

@@ -1,7 +1,8 @@
-// codegen:start { preset: type-barrel, include: ./collection/*.ts }
-export type {} from "./collection/compat.js";
+/* 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/mutable.js";
-export type {} from "./collection/weak.js";
 // codegen:end

package/_src/control/Eval/api.ts

@@ -114,6 +114,7 @@ export function gen<T extends GenEval<any>, A>(
   });
 }
 
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: api/*.ts }
 export * from "./api/sequenceArray.js";
 // codegen:end

package/_src/control/Eval.ts

@@ -1,7 +1,8 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Eval/*.ts }
-export * from "./Eval/api.js";
-export * from "./Eval/constructors.js";
-export * from "./Eval/definition.js";
-export * from "./Eval/instance.js";
 export * from "./Eval/run.js";
+export * from "./Eval/instance.js";
+export * from "./Eval/definition.js";
+export * from "./Eval/constructors.js";
+export * from "./Eval/api.js";
 // codegen:end

package/_src/control/Pure.ts

@@ -1,6 +1,7 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Pure/*.ts }
-export * from "./Pure/api.js";
-export * from "./Pure/definition.js";
-export * from "./Pure/instances.js";
 export * from "./Pure/runtime.js";
+export * from "./Pure/instances.js";
+export * from "./Pure/definition.js";
+export * from "./Pure/api.js";
 // codegen:end

package/_src/control.ts

@@ -1,6 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: type-barrel, include: ./control/*.ts }
-export type {} from "./control/CompletablePromise.js";
-export type {} from "./control/Eval.js";
-export type {} from "./control/LazyValue.js";
 export type {} from "./control/Pure.js";
+export type {} from "./control/LazyValue.js";
+export type {} from "./control/Eval.js";
 // codegen:end

package/_src/data/Branded/definition.ts

@@ -23,17 +23,18 @@ export declare namespace Brand {
     : never;
 
   export type Unbranded<P> = P extends infer Q & Brands<P> ? Q : P;
-  export type Brands<P> = P extends Valid<any, any>
-    ? Union.IntersectionOf<
-        {
-          [K in keyof P[Brand.valid]]: P extends P[Brand.valid][K]
-            ? K extends string
-              ? Valid<P[Brand.valid][K], K>
-              : never
-            : never;
-        }[keyof P[Brand.valid]]
-      >
-    : unknown;
+  export type Brands<P> =
+    P extends Valid<any, any>
+      ? Union.IntersectionOf<
+          {
+            [K in keyof P[Brand.valid]]: P extends P[Brand.valid][K]
+              ? K extends string
+                ? Valid<P[Brand.valid][K], K>
+                : never
+              : never;
+          }[keyof P[Brand.valid]]
+        >
+      : unknown;
 }
 
 /**
@@ -42,7 +43,10 @@ export declare namespace Brand {
  * @tsplus derive nominal
  */
 export class Validation<in out A, in out K extends string> {
-  constructor(readonly validate: Refinement<A, A & Brand.Valid<A, K>>, readonly name: K) {}
+  constructor(
+    readonly validate: Refinement<A, A & Brand.Valid<A, K>>,
+    readonly name: K,
+  ) {}
 }
 
 /**

package/_src/data/Branded.ts

@@ -1,3 +1,4 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Branded/*.ts }
 export * from "./Branded/definition.js";
 // codegen:end

package/_src/data/CaseClass.ts

@@ -45,6 +45,7 @@ export const CaseClass: CaseConstructor = class<T extends Record<PropertyKey, an
   get [Symbol.hash](): number {
     let h = hash0;
     for (const k of this[keysSymbol]) {
+      // @ts-expect-error
       h = Hashable.combine(h, Hashable.unknown(this[k]!));
     }
     return h;
@@ -67,6 +68,7 @@ export const CaseClass: CaseConstructor = class<T extends Record<PropertyKey, an
       while (result && i < len) {
         result =
           this[keysSymbol][i] === thatKeys[i] &&
+          // @ts-expect-error
           Equatable.strictEquals(this[this[keysSymbol]![i]!] as {}, (that as T)[thatKeys[i]!]);
         i++;
       }

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

@@ -1,4 +1,4 @@
-import { Fail, Halt, Interrupt, Sequential,Stackless } from "../definition.js";
+import { Fail, Halt, Interrupt, Sequential, Stackless } from "../definition.js";
 
 /**
  * @tsplus getter fncts.Cause linearize

package/_src/data/Cause/api.ts

@@ -285,7 +285,10 @@ class FCEStackFrameThenLeft<E, A> {
 class FCEStackFrameThenRight<E, A> {
   readonly _tag = "FCEStackFrameThenRight";
 
-  constructor(readonly cause: Sequential<Either<E, A>>, readonly leftResult: Either<Cause<E>, A>) {}
+  constructor(
+    readonly cause: Sequential<Either<E, A>>,
+    readonly leftResult: Either<Cause<E>, A>,
+  ) {}
 }
 
 class FCEStackFrameBothLeft<E, A> {
@@ -297,7 +300,10 @@ class FCEStackFrameBothLeft<E, A> {
 class FCEStackFrameBothRight<E, A> {
   readonly _tag = "FCEStackFrameBothRight";
 
-  constructor(readonly cause: Parallel<Either<E, A>>, readonly leftResult: Either<Cause<E>, A>) {}
+  constructor(
+    readonly cause: Parallel<Either<E, A>>,
+    readonly leftResult: Either<Cause<E>, A>,
+  ) {}
 }
 
 type FCEStackFrame<E, A> =
@@ -418,7 +424,10 @@ class FCOStackFrameThenLeft<E> {
 class FCOStackFrameThenRight<E> {
   readonly _tag = "FCOStackFrameThenRight";
 
-  constructor(readonly cause: Sequential<Maybe<E>>, readonly leftResult: Maybe<Cause<E>>) {}
+  constructor(
+    readonly cause: Sequential<Maybe<E>>,
+    readonly leftResult: Maybe<Cause<E>>,
+  ) {}
 }
 
 class FCOStackFrameBothLeft<E> {
@@ -430,7 +439,10 @@ class FCOStackFrameBothLeft<E> {
 class FCOStackFrameBothRight<E> {
   readonly _tag = "FCOStackFrameBothRight";
 
-  constructor(readonly cause: Parallel<Maybe<E>>, readonly leftResult: Maybe<Cause<E>>) {}
+  constructor(
+    readonly cause: Parallel<Maybe<E>>,
+    readonly leftResult: Maybe<Cause<E>>,
+  ) {}
 }
 
 type FCOStackFrame<E> =
@@ -859,18 +871,18 @@ export function stripSomeDefects(p: Predicate<unknown>) {
         l.isJust() && r.isJust()
           ? Just(Sequential(l.value, r.value))
           : l.isJust()
-          ? Just(l.value)
-          : r.isJust()
-          ? Just(r.value)
-          : Nothing(),
+            ? Just(l.value)
+            : r.isJust()
+              ? Just(r.value)
+              : Nothing(),
       Both: (l, r) =>
         l.isJust() && r.isJust()
           ? Just(Sequential(l.value, r.value))
           : l.isJust()
-          ? Just(l.value)
-          : r.isJust()
-          ? Just(r.value)
-          : Nothing(),
+            ? Just(l.value)
+            : r.isJust()
+              ? Just(r.value)
+              : Nothing(),
       Stackless: (causeOption, stackless) => causeOption.map((cause) => Stackless(cause, stackless)),
     });
   };
@@ -965,8 +977,8 @@ function sequenceCauseMaybeEval<E>(self: Cause<Maybe<E>>): Eval<Maybe<Cause<E>>>
               ? Maybe.just(Cause.sequential(lefts.value, rights.value))
               : lefts
             : rights._tag === MaybeTag.Just
-            ? rights
-            : Maybe.nothing();
+              ? rights
+              : Maybe.nothing();
         },
       );
     }
@@ -981,8 +993,8 @@ function sequenceCauseMaybeEval<E>(self: Cause<Maybe<E>>): Eval<Maybe<Cause<E>>>
               ? Maybe.just(Cause.parallel(lefts.value, rights.value))
               : lefts
             : rights._tag === MaybeTag.Just
-            ? rights
-            : Maybe.nothing();
+              ? rights
+              : Maybe.nothing();
         },
       );
     }
@@ -1038,6 +1050,7 @@ export function squashWith<E>(f: (e: E) => unknown) {
  *
  * @tsplus static fncts.CauseOps sequential
  * @tsplus static fncts.Cause.SequentialOps __call
+ * @tsplus operator fncts.Cause +
  */
 export function sequential<E, E1>(left: Cause<E>, right: Cause<E1>): Cause<E | E1> {
   return left.isEmpty ? right : right.isEmpty ? left : new Sequential<E | E1>(left, right);

package/_src/data/Cause/definition.ts

@@ -81,7 +81,10 @@ export class Fail<E> implements Equatable {
   };
   readonly _tag = CauseTag.Fail;
 
-  constructor(readonly value: E, readonly trace: Trace) {}
+  constructor(
+    readonly value: E,
+    readonly trace: Trace,
+  ) {}
 
   get [Symbol.hash](): number {
     return Hashable.combine(Hashable.string(this._tag), Hashable.unknown(this.value));
@@ -119,7 +122,10 @@ export class Halt implements Equatable {
   };
   readonly _tag = CauseTag.Halt;
 
-  constructor(readonly value: unknown, readonly trace: Trace) {}
+  constructor(
+    readonly value: unknown,
+    readonly trace: Trace,
+  ) {}
 
   get [Symbol.hash](): number {
     return Hashable.combine(Hashable.string(this._tag), Hashable.unknown(this.value));
@@ -157,7 +163,10 @@ export class Interrupt implements Equatable {
   };
   readonly _tag = CauseTag.Interrupt;
 
-  constructor(readonly id: FiberId, readonly trace: Trace) {}
+  constructor(
+    readonly id: FiberId,
+    readonly trace: Trace,
+  ) {}
 
   get [Symbol.hash](): number {
     return Hashable.combine(Hashable.string(this._tag), Hashable.unknown(this.id));
@@ -196,7 +205,10 @@ export class Sequential<E> implements Equatable {
   };
   readonly _tag = CauseTag.Sequential;
 
-  constructor(readonly left: Cause<E>, readonly right: Cause<E>) {}
+  constructor(
+    readonly left: Cause<E>,
+    readonly right: Cause<E>,
+  ) {}
 
   get [Symbol.hash](): number {
     return hashCode(this);
@@ -230,7 +242,10 @@ export class Parallel<E> implements Equatable {
   };
   readonly _tag = CauseTag.Parallel;
 
-  constructor(readonly left: Cause<E>, readonly right: Cause<E>) {}
+  constructor(
+    readonly left: Cause<E>,
+    readonly right: Cause<E>,
+  ) {}
 
   get [Symbol.hash](): number {
     return hashCode(this);
@@ -264,7 +279,10 @@ export class Stackless<E> implements Equatable {
   };
   readonly _tag = CauseTag.Stackless;
 
-  constructor(readonly cause: Cause<E>, readonly stackless: boolean) {}
+  constructor(
+    readonly cause: Cause<E>,
+    readonly stackless: boolean,
+  ) {}
 
   get [Symbol.hash](): number {
     return this.cause[Symbol.hash];
@@ -280,7 +298,11 @@ export class Stackless<E> implements Equatable {
 }
 
 export class Unified {
-  constructor(readonly fiberId: FiberId, readonly message: ReadonlyArray<string>, readonly trace: Conc<string>) {}
+  constructor(
+    readonly fiberId: FiberId,
+    readonly message: ReadonlyArray<string>,
+    readonly trace: Conc<string>,
+  ) {}
 }
 
 /*

package/_src/data/Cause.ts

@@ -1,11 +1,13 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Cause/*.ts }
-export * from "./Cause/api.js";
 export * from "./Cause/definition.js";
+export * from "./Cause/api.js";
 // codegen:end
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Cause/api/*.ts }
-export * from "./Cause/api/fold.js";
-export * from "./Cause/api/isEmpty.js";
-export * from "./Cause/api/linearize.js";
-export * from "./Cause/api/prettyPrint.js";
 export * from "./Cause/api/unified.js";
+export * from "./Cause/api/prettyPrint.js";
+export * from "./Cause/api/linearize.js";
+export * from "./Cause/api/isEmpty.js";
+export * from "./Cause/api/fold.js";
 // codegen:end

package/_src/data/Const.ts

@@ -1,5 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Const/*.ts }
-export * from "./Const/api.js";
-export * from "./Const/definition.js";
 export * from "./Const/instances.js";
+export * from "./Const/definition.js";
+export * from "./Const/api.js";
 // codegen:end

package/_src/data/Data.ts

@@ -0,0 +1,144 @@
+import type { Equals } from "@fncts/typelevel/Any";
+import type { True } from "@fncts/typelevel/Boolean";
+
+export interface Copy<T> {
+  copy(args: Equals<T, {}> extends True ? void : Partial<T>): this;
+}
+
+export interface DataClassConstructor {
+  new <T>(
+    args: Equals<T, {}> extends True
+      ? void
+      : { readonly [P in keyof T as P extends keyof Equatable ? never : P]: T[P] },
+  ): Readonly<T> & Copy<T>;
+}
+
+const keysSymbol = Symbol.for("fncts.Data.keys");
+
+abstract class StructuralPrototype implements Equatable, Hashable {
+  abstract [keysSymbol]: ReadonlyArray<any>;
+
+  get [Symbol.hash](): number {
+    return Hashable.plainObject(this);
+  }
+  [Symbol.equals](that: unknown): boolean {
+    if (!isObject(that)) {
+      return false;
+    }
+    const selfKeys = Object.keys(this);
+    const thatKeys = Object.keys(that);
+    if (selfKeys.length !== thatKeys.length) {
+      return false;
+    }
+    for (const key of selfKeys) {
+      if (!(key in that) && Equatable.strictEquals((this as any)[key], that[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  copy(args: void | object) {
+    if (!args) {
+      if (this[keysSymbol].length === 0) {
+        // @ts-expect-error
+        return new this.constructor();
+      }
+
+      const properties = {} as Record<any, any>;
+      for (const k of this[keysSymbol]) {
+        properties[k] = (this as any)[k];
+      }
+      // @ts-expect-error
+      return new this.constructor(properties);
+    }
+
+    const properties = {} as Record<any, any>;
+    for (const k of this[keysSymbol]) {
+      if (k in (args as any)) {
+        properties[k] = (args as any)[k];
+      } else {
+        properties[k] = (this as any)[k];
+      }
+    }
+
+    // @ts-expect-error
+    return new this.constructor(properties);
+  }
+}
+
+const Structural: new <A>(
+  args: Equals<Omit<A, keyof Equatable>, {}> extends True
+    ? void
+    : { readonly [P in keyof A as P extends keyof Equatable ? never : P]: A[P] },
+) => {} = (function () {
+  return class Structural extends StructuralPrototype {
+    readonly [keysSymbol]: ReadonlyArray<any> = [];
+
+    constructor(args: any) {
+      super();
+      if (args) {
+        this[keysSymbol] = Object.keys(args);
+        Object.assign(this, args);
+      }
+    }
+  };
+})();
+
+export const DataClass: DataClassConstructor = Structural as any;
+
+export interface TaggedDataClassConstructor<Tag extends string | symbol, K extends string | symbol> {
+  new <T extends Record<string, any> = {}>(
+    args: Equals<T, {}> extends True ? void : T,
+  ): {
+    readonly [P in keyof T as P extends Tag ? never : P]: T[P];
+  } & Copy<T> & {
+      readonly [k in K]: Tag;
+    };
+}
+
+export const TaggedClass = <Tag extends string | symbol, Key extends string | symbol = "_tag">(
+  tag: Tag,
+  key?: Key,
+): TaggedDataClassConstructor<Tag, Key> => {
+  if (key) {
+    class Base extends Structural<any> {
+      // @ts-expect-error
+      readonly [key] = tag;
+    }
+    return Base as any;
+  }
+
+  class Base extends Structural<any> {
+    readonly _tag = tag;
+  }
+  return Base as any;
+};
+
+export function struct<As extends Readonly<Record<string, any>>>(as: As): As {
+  return Object.assign(Object.create(StructuralPrototype.prototype), as);
+}
+
+export const Error: new <A extends Record<string, any> = {}>(
+  args: Equals<A, {}> extends True ? void : { readonly [P in keyof A]: A[P] },
+) => Error & Readonly<A> = (function () {
+  return class Base extends globalThis.Error {
+    constructor(args: any) {
+      super();
+      if (args) {
+        Object.assign(this, args);
+      }
+    }
+  } as any;
+})();
+
+export function TaggedError<Tag extends string>(
+  tag: Tag,
+): new <A extends Record<string, any> = {}>(
+  args: Equals<A, {}> extends True ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] },
+) => Error & { readonly _tag: Tag } & Readonly<A> {
+  class Base extends Error<{}> {
+    readonly _tag = tag;
+  }
+  Base.prototype.name = tag;
+  return Base as any;
+}

package/_src/data/Date.ts

@@ -1,3 +1,4 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Date/*.ts }
 export * from "./Date/definition.js";
 // codegen:end

package/_src/data/DatumEither.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./DatumEither/*.ts }
-export * from "./DatumEither/api.js";
 export * from "./DatumEither/definition.js";
+export * from "./DatumEither/api.js";
 // codegen:end