@fncts/base 0.0.21 → 0.0.22

package/_src/collection/immutable.ts

@@ -1,5 +1,6 @@
 // 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";

package/_src/collection/mutable/HashMap.ts

@@ -13,7 +13,7 @@
  */
 
 import { copyOfArray, improveHash, tableSizeFor } from "@fncts/base/collection/mutable/internal";
-import { HashEq } from "@fncts/base/typeclass/HashEq";
+import { HashEq } from "@fncts/base/data/HashEq";
 import { assert } from "@fncts/base/util/assert";
 
 const DEFAULT_INITIAL_CAPACITY = 16;
@@ -83,7 +83,7 @@ export class HashMap<K, V> implements Iterable<readonly [K, V]> {
       let prev: Node<K, V> | undefined = undefined;
       let nd: Node<K, V> | undefined   = n;
       while (nd) {
-        if (hash === nd.hash && this.config.equals(key, nd.key)) {
+        if (hash === nd.hash && this.config.equals(nd.key)(key)) {
           previousNode = prev;
           foundNode    = nd;
           break;
@@ -161,7 +161,7 @@ export class HashMap<K, V> implements Iterable<readonly [K, V]> {
       const old = n;
       let prev: Node<K, V> | undefined = undefined;
       while (n !== undefined && n.hash <= hash) {
-        if (n.hash === hash && this.config.equals(key, n.key)) {
+        if (n.hash === hash && this.config.equals(n.key)(key)) {
           const old = n.value;
           n.value   = value;
           if (getOld) return Just(old);
@@ -189,7 +189,7 @@ export class HashMap<K, V> implements Iterable<readonly [K, V]> {
     const nd  = this.table[idx];
     if (nd === undefined) {
       return undefined;
-    } else if (nd.hash === hash && this.config.equals(nd.key, key)) {
+    } else if (nd.hash === hash && this.config.equals(key)(nd.key)) {
       this.table[idx]   = nd.next;
       this.contentSize -= 1;
       return nd;
@@ -197,7 +197,7 @@ export class HashMap<K, V> implements Iterable<readonly [K, V]> {
       let prev = nd;
       let next = nd.next;
       while (next && next.hash <= hash) {
-        if (next.hash === hash && this.config.equals(next.key, key)) {
+        if (next.hash === hash && this.config.equals(key)(next.key)) {
           prev.next         = next.next;
           this.contentSize -= 1;
           return next;
@@ -278,10 +278,10 @@ 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) {}
 
-  findNode(k: K, h: number, equals: (x: K, y: K) => boolean): 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;
     while (n) {
-      if (h === n.hash && equals(k, n.key)) {
+      if (h === n.hash && equals(n.key)(k)) {
         return n;
       } else {
         n = n.next;

package/_src/collection/mutable/HashSet.ts

@@ -13,7 +13,7 @@
  */
 
 import { copyOfArray, improveHash, tableSizeFor } from "@fncts/base/collection/mutable/internal";
-import { HashEq } from "@fncts/base/typeclass/HashEq";
+import { HashEq } from "@fncts/base/data/HashEq";
 import { assert } from "@fncts/base/util/assert";
 
 const DEFAULT_INITIAL_CAPACITY = 16;
@@ -80,7 +80,7 @@ export class HashSet<A> implements Iterable<A> {
       const old                     = n;
       let prev: Node<A> | undefined = undefined;
       while (n !== undefined && n.hash <= hash) {
-        if (n.hash === hash && this.config.equals(elem, n.key)) {
+        if (n.hash === hash && this.config.equals(n.key)(elem)) {
           return false;
         }
         prev = n;
@@ -101,7 +101,7 @@ export class HashSet<A> implements Iterable<A> {
     const n   = this.table[idx];
     if (n === undefined) {
       return false;
-    } else if (n.hash === hash && this.config.equals(n.key, elem)) {
+    } else if (n.hash === hash && this.config.equals(elem)(n.key)) {
       this.table[idx]   = n.next;
       this.contentSize -= 1;
       return true;
@@ -109,7 +109,7 @@ export class HashSet<A> implements Iterable<A> {
       let prev = n;
       let next = n.next;
       while (next && next.hash <= hash) {
-        if (next.hash === hash && this.config.equals(next.key, elem)) {
+        if (next.hash === hash && this.config.equals(elem)(next.key)) {
           prev.next         = next.next;
           this.contentSize -= 1;
           return true;
@@ -190,11 +190,11 @@ export class HashSet<A> implements Iterable<A> {
 class Node<K> {
   constructor(public key: K, public hash: number, public next: Node<K> | undefined) {}
 
-  findNode(k: K, h: number, equals: (x: K, y: K) => boolean): 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
     let n: Node<K> | undefined = this;
     while (n) {
-      if (h === n.hash && equals(k, n.key)) {
+      if (h === n.hash && equals(n.key)(k)) {
         return n;
       } else {
         n = n.next;

package/_src/control/Z/api.ts

@@ -18,18 +18,18 @@ export function ap<W, S, A, R1, E1>(fb: Z<W, S, S, R1, E1, A>) {
 }
 
 /**
- * @tsplus pipeable fncts.control.Z apFirst
+ * @tsplus pipeable fncts.control.Z zipLeft
  */
-export function apFirst<W, S, R1, E1, B>(fb: Z<W, S, S, R1, E1, B>) {
+export function zipLeft<W, S, R1, E1, B>(fb: Z<W, S, S, R1, E1, B>) {
   return <R, E, A>(fa: Z<W, S, S, R, E, A>): Z<W, S, S, R & R1, E | E1, A> => {
     return fa.crossWith(fb, (a, _) => a);
   };
 }
 
 /**
- * @tsplus pipeable fncts.control.Z apSecond
+ * @tsplus pipeable fncts.control.Z zipRight
  */
-export function apSecond<W, S, R1, E1, B>(fb: Z<W, S, S, R1, E1, B>) {
+export function zipRight<W, S, R1, E1, B>(fb: Z<W, S, S, R1, E1, B>) {
   return <R, E, A>(fa: Z<W, S, S, R, E, A>): Z<W, S, S, R & R1, E | E1, B> => {
     return fa.crossWith(fb, (_, b) => b);
   };

package/_src/data/Branded.ts

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

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

@@ -5,10 +5,10 @@ import { Fail, Halt, Interrupt, Stackless, Then } from "../definition.js";
  */
 export function linearize<E>(self: Cause<E>): HashSet<Cause<E>> {
   return self.fold({
-    Empty: () => HashSet.makeDefault<Cause<E>>(),
-    Fail: (e, trace) => HashSet.makeDefault<Cause<E>>().add(Fail(e, trace)),
-    Halt: (t, trace) => HashSet.makeDefault<Cause<E>>().add(Halt(t, trace)),
-    Interrupt: (fiberId, trace) => HashSet.makeDefault<Cause<E>>().add(Interrupt(fiberId, trace)),
+    Empty: () => HashSet.empty<Cause<E>>(),
+    Fail: (e, trace) => HashSet.empty<Cause<E>>().add(Fail(e, trace)),
+    Halt: (t, trace) => HashSet.empty<Cause<E>>().add(Halt(t, trace)),
+    Interrupt: (fiberId, trace) => HashSet.empty<Cause<E>>().add(Interrupt(fiberId, trace)),
     Then: (l, r) => l.flatMap((l) => r.map((r) => Then(l, r))),
     Both: (l, r) => l.union(r),
     Stackless: (cause, stackless) => cause.map((c) => Stackless(c, stackless)),

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

@@ -1,6 +1,6 @@
 import type { Cause, Fail, Halt, Interrupt } from "../definition.js";
 
-import { showWithOptions } from "../../../typeclass/Showable.js";
+import { showWithOptions } from "../../../data/Showable.js";
 import { CauseTag, Unified } from "../definition.js";
 
 function unifyFail<E>(fail: Fail<E>): Unified {

package/_src/data/Cause/api.ts

@@ -711,9 +711,7 @@ export function interruptOption<E>(self: Cause<E>): Maybe<FiberId> {
  * @tsplus getter fncts.Cause interruptors
  */
 export function interruptors<E>(self: Cause<E>): HashSet<FiberId> {
-  return self.foldLeft(HashSet.makeDefault(), (s, c) =>
-    c._tag === CauseTag.Interrupt ? Just(s.add(c.id)) : Nothing(),
-  );
+  return self.foldLeft(HashSet.empty(), (s, c) => (c._tag === CauseTag.Interrupt ? Just(s.add(c.id)) : Nothing()));
 }
 
 /**

package/_src/data/Cause/definition.ts

@@ -477,14 +477,14 @@ function stepLoop<A>(
 }
 
 function step<A>(cause: Cause<A>): readonly [HashSet<Cause<A>>, List<Cause<A>>] {
-  return stepLoop(cause, Nil(), HashSet.makeDefault(), Nil());
+  return stepLoop(cause, Nil(), HashSet.empty(), Nil());
 }
 
 function flattenLoop<A>(causes: List<Cause<A>>, flattened: List<HashSet<Cause<A>>>): List<HashSet<Cause<A>>> {
   // eslint-disable-next-line no-constant-condition
   while (1) {
     const [parallel, sequential] = causes.foldLeft(
-      tuple(HashSet.makeDefault<Cause<A>>(), List.empty<Cause<A>>()),
+      tuple(HashSet.empty<Cause<A>>(), List.empty<Cause<A>>()),
       ([parallel, sequential], cause) => {
         const [set, seq] = step(cause);
         return tuple(parallel.union(set), sequential.concat(seq));

package/_src/data/Const/api.ts

@@ -5,7 +5,7 @@ import { Const } from "./definition.js";
  */
 export function map<A, B>(_f: (a: A) => B) {
   return <E>(self: Const<E, A>): Const<E, B> => {
-    return new Const(self.getConst);
+    return self.unsafeCoerce();
   };
 }
 

package/_src/data/Const/instances.ts

@@ -9,8 +9,8 @@ import { Const } from "@fncts/base/data/Const/definition";
 export function getApply<E>(S: P.Semigroup<E>) {
   return HKT.instance<P.Apply<ConstF, HKT.Fix<"E", E>>>({
     map: (f) => (fa) => fa.map(f),
-    zip: (that) => (self) => Const(S.combine(self.getConst, that.getConst)),
-    zipWith: (that, _f) => (self) => Const(S.combine(self.getConst, that.getConst)),
+    zip: (that) => (self) => Const(S.combine(that.getConst)(self.getConst)),
+    zipWith: (that, _f) => (self) => Const(S.combine(that.getConst)(self.getConst)),
   });
 }
 

package/_src/data/Datum/api.ts

@@ -1,6 +1,6 @@
 import type { DatumF } from "@fncts/base/data/Datum/definition";
+import type { Eq } from "@fncts/base/data/Eq";
 import type * as P from "@fncts/base/typeclass";
-import type { Eq } from "@fncts/base/typeclass/Eq";
 
 import { DatumTag, Initial, Pending, Refresh, Replete } from "@fncts/base/data/Datum/definition";
 import { Zipped } from "@fncts/base/data/Zipped";
@@ -105,18 +105,16 @@ export function elem<A>(a: A, /** @tsplus auto */ E: Eq<A>) {
     return self.match({
       Initial: () => false,
       Pending: () => false,
-      Refresh: (value) => E.equals(a, value),
-      Replete: (value) => E.equals(a, value),
+      Refresh: (value) => E.equals(value)(a),
+      Replete: (value) => E.equals(value)(a),
     });
   };
 }
 
 /**
- * @tsplus pipeable fncts.Datum exists
+ * @tsplus pipeable fncts.Datum some
  */
-export function exists<A, B extends A>(p: Refinement<A, B>): (self: Datum<A>) => self is Datum<B>;
-export function exists<A>(p: Predicate<A>): (self: Datum<A>) => boolean;
-export function exists<A>(p: Predicate<A>) {
+export function some<A>(p: Predicate<A>) {
   return (self: Datum<A>): boolean => {
     return self.match({
       Initial: () => false,

package/_src/data/DecodeError/definition.ts

@@ -1,4 +1,6 @@
-import { show } from "@fncts/base/typeclass/Showable";
+import type { Literal } from "@fncts/typelevel/Any";
+
+import { show } from "@fncts/base/data/Showable";
 
 export const DecodeErrorTypeId = Symbol.for("fncts.DecodeError");
 export type DecodeErrorTypeId = typeof DecodeErrorTypeId;
@@ -140,7 +142,7 @@ export class PrimitiveError extends DecodeError {
   render = Eval(RoseTree(cannotDecode(this.actual, this.name)));
 }
 
-export class LiteralError<A extends string | number | boolean> extends DecodeError {
+export class LiteralError<A extends Literal> extends DecodeError {
   readonly _tag = "Literal";
   constructor(readonly actual: unknown, readonly literals: Vector<A>) {
     super();