@fncts/base 0.0.41 → 0.0.43

package/_src/data/Equatable/api.ts

@@ -7,9 +7,29 @@ import {
   sameValueZeroEqual,
 } from "@fncts/base/data/Equatable/fast-equals";
 
+/**
+ * @tsplus static fncts.EquatableOps anything
+ */
+export const anything: any = Symbol.for("fncts.Equatable.anything");
+
+/**
+ * @tsplus static fncts.EquatableOps nothing
+ */
+export const nothing: any = Symbol.for("fncts.Equatable.nothing");
+
 const deepEqualsComparator = createComparator(
   createCircularEqualCreator((eq) => (a, b, meta) => {
-    const equalsContext: EqualsContext = { comparator: deepEquals };
+    const equalsContext: EqualsContext = {
+      comparator: (a, b) => {
+        if (a === anything || b === anything) {
+          return true;
+        } else if (a === nothing || b === nothing) {
+          return false;
+        }
+        return deepEquals(a, b);
+      },
+    };
+
     if (isEquatable(a)) {
       return a[Symbol.equals](b, equalsContext);
     } else if (isEquatable(b)) {
@@ -40,7 +60,14 @@ export function deepEquals<A>(a: A, b: unknown): boolean {
  */
 export function strictEquals<A>(a: A, b: unknown): boolean {
   const context: EqualsContext = {
-    comparator: strictEquals,
+    comparator: (a, b) => {
+      if (a === anything || b === anything) {
+        return true;
+      } else if (a === nothing || b === nothing) {
+        return false;
+      }
+      return strictEquals(a, b);
+    },
   };
   if (isEquatable(a)) {
     return a[Symbol.equals](b, context);

package/_src/data/Maybe/api.ts

@@ -154,7 +154,6 @@ export function orElse<B>(fb: Lazy<Maybe<B>>) {
  */
 export function partition<A>(p: Predicate<A>): (self: Maybe<A>) => readonly [Maybe<A>, Maybe<A>];
 export function partition<A, B extends A>(p: Refinement<A, B>): (self: Maybe<A>) => readonly [Maybe<A>, Maybe<B>];
-
 export function partition<A>(p: Predicate<A>) {
   return (self: Maybe<A>): readonly [Maybe<A>, Maybe<A>] => {
     self.concrete();

package/_src/data/Maybe/definition.ts

@@ -1,3 +1,5 @@
+import type { EqualsContext } from "../Equatable.js";
+
 import { isObject } from "../../util/predicates.js";
 
 export const enum MaybeTag {
@@ -42,7 +44,7 @@ export abstract class Maybe<A> {
  * @tsplus type fncts.Just
  * @tsplus companion fncts.JustOps
  */
-export class Just<A> extends Maybe<A> {
+export class Just<A> extends Maybe<A> implements Equatable {
   readonly _tag = MaybeTag.Just;
   constructor(
     readonly value: A,
@@ -50,8 +52,8 @@ export class Just<A> extends Maybe<A> {
   ) {
     super();
   }
-  [Symbol.equals](that: unknown): boolean {
-    return isMaybe(that) && that.isJust() && Equatable.strictEquals(this.value, that.value);
+  [Symbol.equals](that: unknown, context: EqualsContext): boolean {
+    return isMaybe(that) && that.isJust() && context.comparator(this.value, that.value);
   }
   get [Symbol.hash]() {
     return Hashable.combine(_justHash, Hashable.unknown(this.value));
@@ -62,7 +64,7 @@ export class Just<A> extends Maybe<A> {
  * @tsplus type fncts.Nothing
  * @tsplus companion fncts.NothingOps
  */
-export class Nothing extends Maybe<never> {
+export class Nothing extends Maybe<never> implements Equatable {
   readonly _tag = MaybeTag.Nothing;
   constructor(readonly trace?: string) {
     super();

package/_src/data/Showable/show.ts

@@ -721,7 +721,7 @@ export function showProperty(
             Pure.update((_: ShowContext): ShowContext => _.copy({ indentationLevel: _.indentationLevel - diff })),
           );
       } else if (isDefined(descriptor.get)) {
-        return Pure.succeedNow(tuple(descriptor, " ", `[${descriptor.set ? "Getter/Settter" : "Getter"}]`));
+        return Pure.succeedNow(tuple(descriptor, " ", `[${descriptor.set ? "Getter/Setter" : "Getter"}]`));
       } else if (isDefined(descriptor.set)) {
         return Pure.succeedNow(tuple(descriptor, " ", "Setter"));
       } else {

package/_src/util/PCGRandom.ts

@@ -132,6 +132,7 @@ export class PCGRandom {
       return this._next() & (max - 1); // fast path for power of 2
     }
 
+    // eslint-disable-next-line no-useless-assignment
     let num    = 0;
     const skew = (-max >>> 0) % max >>> 0;
     for (num = this._next(); num < skew; num = this._next()) {

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

@@ -90,9 +90,9 @@ export declare class Concat<A> extends ConcImplementation<A> {
     readonly right: ConcImplementation<A>;
     _A: () => A;
     readonly _tag = ConcTag.Concat;
-    length: number;
-    depth: number;
-    binary: boolean;
+    readonly length: number;
+    readonly depth: number;
+    readonly binary: boolean;
     constructor(left: ConcImplementation<A>, right: ConcImplementation<A>);
     get(n: number): A;
     forEach<B>(startIndex: number, f: (i: number, a: A) => B): void;
@@ -107,8 +107,8 @@ declare class AppendN<A> extends ConcImplementation<A> {
     readonly bufferUsed: number;
     readonly binary: boolean;
     readonly _tag = ConcTag.AppendN;
-    length: number;
-    depth: number;
+    readonly length: number;
+    readonly depth: number;
     left: Empty<never>;
     right: Empty<never>;
     constructor(start: ConcImplementation<A>, buffer: Array<unknown> | Uint8Array, bufferUsed: number, binary: boolean);

package/collection/immutable/List/definition.d.ts

@@ -1,24 +1,34 @@
+import { Equatable } from "@fncts/base/data/Equatable";
+import type { EqualsContext } from "@fncts/base/data/Equatable";
 export declare const ListTypeId: unique symbol;
 export type ListTypeId = typeof ListTypeId;
 /**
  * @tsplus type fncts.List.Cons
  * @tsplus companion fncts.ConsOps
  */
-export declare class Cons<A> implements Iterable<A> {
+export declare class Cons<A> implements Iterable<A>, Equatable {
     readonly head: A;
     tail: List<A>;
     readonly _tag = "Cons";
     readonly [ListTypeId]: ListTypeId;
     constructor(head: A, tail?: List<A>);
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
+    /**
+     * Iterates elements from this node through the tail.
+     */
     [Symbol.iterator](): Iterator<A>;
 }
 /**
  * @tsplus type fncts.List.Nil
  * @tsplus companion fncts.NilOps
  */
-export declare class Nil<A> implements Iterable<A> {
+export declare class Nil<A> implements Iterable<A>, Equatable {
     readonly _tag = "Nil";
     readonly [ListTypeId]: ListTypeId;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
+    /**
+     * Returns an iterator that is immediately done.
+     */
     [Symbol.iterator](): Iterator<A>;
 }
 /**

package/collection/immutable/Vector/definition.d.ts

@@ -1,7 +1,10 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import { Hashable } from "@fncts/base/data/Hashable";
 import { Equatable } from "@fncts/base/data/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Pure } from "@fncts/base/control/Pure/definition";
 import type { Node } from "@fncts/base/collection/immutable/Vector/internal";
+import type { EqualsContext } from "@fncts/base/data/Equatable";
+import type { ShowComputationExternal } from "@fncts/base/data/Showable";
 export declare const VectorVariance: unique symbol;
 export type VectorVariance = typeof VectorVariance;
 export declare const VectorTypeId: unique symbol;
@@ -19,7 +22,7 @@ export interface VectorF extends HKT {
  * @tsplus type fncts.Vector
  * @tsplus companion fncts.VectorOps
  */
-export declare class Vector<A> implements Iterable<A> {
+export declare class Vector<A> implements Iterable<A>, Equatable {
     /** @private */
     readonly bits: number;
     /** @private */
@@ -48,7 +51,8 @@ export declare class Vector<A> implements Iterable<A> {
     suffix: A[]);
     [Symbol.iterator](): Iterator<A>;
     get [Symbol.hash](): number;
-    [Symbol.equals](that: unknown): boolean;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
+    get [Symbol.showable](): ShowComputationExternal;
 }
 /**
  * @tsplus type fncts.Vector
@@ -68,6 +72,7 @@ export interface MutableVector<A> {
     [Symbol.iterator]: () => Iterator<A>;
     [Symbol.hash]: number;
     [Symbol.equals](that: unknown): boolean;
+    get [Symbol.showable](): ShowComputationExternal;
     /**
      * This property doesn't exist at run-time. It exists to prevent a
      * MutableVector from being assignable to a Vector.

package/collection/weak/IterableWeakMap.d.ts

@@ -14,9 +14,9 @@ export declare class IterableWeakMap<K extends object, V> implements Iterable<re
     clear(): void;
     forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: IterableWeakMap<K, V>): void;
     get size(): number;
-    [Symbol.iterator](this: this): IterableIterator<[K, V]>;
+    [Symbol.iterator](this: this): MapIterator<[K, V]>;
     get [Symbol.toStringTag](): string;
-    entries(this: this): IterableIterator<[K, V]>;
-    keys(this: this): IterableIterator<K>;
-    values(): IterableIterator<V>;
+    entries(this: this): MapIterator<[K, V]>;
+    keys(this: this): MapIterator<K>;
+    values(): MapIterator<V>;
 }

package/collection/weak/IterableWeakSet.d.ts

@@ -10,12 +10,12 @@ export declare class IterableWeakSet<A extends object> implements Iterable<A>, S
     add(this: this, value: A): this;
     delete(this: this, value: A): boolean;
     has(this: this, value: A): boolean;
-    keys(): IterableIterator<A>;
-    values(): IterableIterator<A>;
+    keys(): MapIterator<A>;
+    values(): MapIterator<A>;
     forEach(f: (value: A, value2: A, set: Set<A>) => void, thisArg?: Set<A>): void;
     clear(): void;
     get size(): number;
-    [Symbol.iterator](this: this): IterableIterator<A>;
+    [Symbol.iterator](this: this): MapIterator<A>;
     get [Symbol.toStringTag](): string;
-    entries(this: this): IterableIterator<[A, A]>;
+    entries(this: this): MapIterator<[A, A]>;
 }

package/data/Branded/definition.d.ts

@@ -1,5 +1,7 @@
+import { Equatable } from "@fncts/base/data/Equatable";
 import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
+import type { EqualsContext } from "@fncts/base/data/Equatable";
 import type { Union } from "@fncts/typelevel";
 declare const validSym: unique symbol;
 export declare namespace Brand {
@@ -27,10 +29,11 @@ export declare namespace Brand {
  * @tsplus companion fncts.ValidationOps
  * @tsplus derive nominal
  */
-export declare class Validation<in out A, in out K extends string> {
+export declare class Validation<in out A, in out K extends string> implements Equatable {
     readonly validate: Refinement<A, A & Brand.Valid<A, K>>;
     readonly name: K;
     constructor(validate: Refinement<A, A & Brand.Valid<A, K>>, name: K);
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus static fncts.ValidationOps __call

package/data/Equatable/api.d.ts

@@ -1,3 +1,13 @@
+/**
+ * @tsplus static fncts.EquatableOps anything
+ * @tsplus location "@fncts/base/data/Equatable/api"
+ */
+export declare const anything: any;
+/**
+ * @tsplus static fncts.EquatableOps nothing
+ * @tsplus location "@fncts/base/data/Equatable/api"
+ */
+export declare const nothing: any;
 /**
  * @tsplus static fncts.EquatableOps deepEquals
  * @tsplus location "@fncts/base/data/Equatable/api"

package/data/Equatable/fast-equals.d.ts

@@ -99,7 +99,7 @@ export declare function getNewCacheFallback(): Cache;
  *
  * @returns the new cache object
  */
-export declare const getNewCache: () => Cache;
+export declare const getNewCache: typeof getNewCacheFallback;
 /**
  * @function createCircularEqualCreator
  *

package/data/Maybe/definition.d.ts

@@ -1,6 +1,7 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import { Equatable } from "@fncts/base/data/Equatable";
 import { Hashable } from "@fncts/base/data/Hashable";
+import type { EqualsContext } from "../Equatable.js";
 export declare const enum MaybeTag {
     Just = "Just",
     Nothing = "Nothing"
@@ -34,19 +35,19 @@ export declare abstract class Maybe<A> {
  * @tsplus type fncts.Just
  * @tsplus companion fncts.JustOps
  */
-export declare class Just<A> extends Maybe<A> {
+export declare class Just<A> extends Maybe<A> implements Equatable {
     readonly value: A;
     readonly trace?: string | undefined;
     readonly _tag = MaybeTag.Just;
     constructor(value: A, trace?: string | undefined);
-    [Symbol.equals](that: unknown): boolean;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
     get [Symbol.hash](): number;
 }
 /**
  * @tsplus type fncts.Nothing
  * @tsplus companion fncts.NothingOps
  */
-export declare class Nothing extends Maybe<never> {
+export declare class Nothing extends Maybe<never> implements Equatable {
     readonly trace?: string | undefined;
     readonly _tag = MaybeTag.Nothing;
     constructor(trace?: string | undefined);

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@fncts/base",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "dependencies": {
-    "@fncts/typelevel": "0.0.22",
-    "uuid": "^11.1.0"
+    "@fncts/typelevel": "0.0.24",
+    "uuid": "^14.0.0"
   },
   "exports": {
     "./*": {