@fncts/base 0.0.21 → 0.0.23

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

@@ -5,6 +5,9 @@ import type { Node } from "@fncts/base/collection/immutable/Vector/internal";
 import { foldLeftCb } from "@fncts/base/collection/immutable/Vector/internal";
 import { ForwardVectorIterator } from "@fncts/base/collection/immutable/Vector/internal";
 
+export const VectorVariance = Symbol.for("fncts.Vector.Variance");
+export type VectorVariance = typeof VectorVariance;
+
 export const VectorTypeId = Symbol.for("fncts.Vector");
 export type VectorTypeId = typeof VectorTypeId;
 
@@ -23,8 +26,10 @@ export interface VectorF extends HKT {
  * @tsplus companion fncts.VectorOps
  */
 export class Vector<A> implements Iterable<A> {
-  readonly _typeId: VectorTypeId = VectorTypeId;
-  readonly _A!: () => A;
+  readonly [VectorTypeId]: VectorTypeId = VectorTypeId;
+  declare [VectorVariance]: {
+    readonly _A: (_: never) => A;
+  };
   constructor(
     /** @private */
     readonly bits: number,
@@ -53,8 +58,10 @@ export class Vector<A> implements Iterable<A> {
  * @tsplus type fncts.MutableVector
  */
 export interface MutableVector<A> {
-  readonly _typeId: VectorTypeId;
-  readonly _A: () => A;
+  readonly [VectorTypeId]: VectorTypeId;
+  readonly [VectorVariance]: {
+    readonly _A: (_: never) => A;
+  };
   bits: number;
   offset: number;
   length: number;
@@ -72,7 +79,7 @@ export interface MutableVector<A> {
 }
 
 export function isVector(u: unknown): u is Vector<unknown> {
-  return hasTypeId(u, VectorTypeId);
+  return isObject(u) && VectorTypeId in u;
 }
 
 /**

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/Eval/definition.ts

@@ -1,3 +1,6 @@
+export const EvalVariance = Symbol.for("fncts.Eval.Variance");
+export type EvalVariance = typeof EvalVariance;
+
 export const EvalTypeId = Symbol.for("@fncts/control/Eval");
 export type EvalTypeId = typeof EvalTypeId;
 
@@ -12,8 +15,10 @@ export interface EvalF extends HKT {
  * @tsplus type fncts.control.Eval
  */
 export interface Eval<A> {
-  readonly _typeId: EvalTypeId;
-  readonly _A: () => A;
+  readonly [EvalTypeId]: EvalTypeId;
+  readonly [EvalVariance]: {
+    readonly _A: (_: never) => A;
+  };
 }
 
 /**
@@ -30,23 +35,30 @@ export const enum EvalTag {
 }
 
 export class Value<A> implements Eval<A> {
-  readonly _tag                = EvalTag.Value;
-  readonly _typeId: EvalTypeId = EvalTypeId;
-  readonly _A!: () => A;
+  readonly _tag                     = EvalTag.Value;
+  readonly [EvalTypeId]: EvalTypeId = EvalTypeId;
+  declare [EvalVariance]: {
+    readonly _A: (_: never) => A;
+  };
   constructor(readonly value: A) {}
 }
 
 export class Defer<A> implements Eval<A> {
-  readonly _typeId: EvalTypeId = EvalTypeId;
-  readonly _tag                = EvalTag.Defer;
+  readonly [EvalTypeId]: EvalTypeId = EvalTypeId;
+  declare [EvalVariance]: {
+    readonly _A: (_: never) => A;
+  };
+  readonly _tag = EvalTag.Defer;
   readonly _A!: () => A;
   constructor(readonly make: () => Eval<A>) {}
 }
 
 export class Chain<A, B> implements Eval<B> {
-  readonly _typeId: EvalTypeId = EvalTypeId;
-  readonly _tag                = EvalTag.Chain;
-  readonly _A!: () => B;
+  readonly [EvalTypeId]: EvalTypeId = EvalTypeId;
+  declare [EvalVariance]: {
+    readonly _A: (_: never) => B;
+  };
+  readonly _tag = EvalTag.Chain;
   constructor(readonly self: Eval<A>, readonly f: (a: A) => Eval<B>) {}
 }
 

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/control/Z/definition.ts

@@ -1,5 +1,3 @@
-import { hasTypeId } from "../../util/predicates.js";
-
 export interface ZF extends HKT {
   type: Z<this["W"], this["S"], this["S"], this["R"], this["E"], this["A"]>;
   variance: {
@@ -11,7 +9,10 @@ export interface ZF extends HKT {
   };
 }
 
-export const ZTypeId = Symbol.for("@principia/base/Z");
+export const ZVariance = Symbol.for("fncts.Z.Variance");
+export type ZVariance = typeof ZVariance;
+
+export const ZTypeId = Symbol.for("fncts.Z");
 export type ZTypeId = typeof ZTypeId;
 
 /**
@@ -28,13 +29,15 @@ export type ZTypeId = typeof ZTypeId;
  * @tsplus companion fncts.control.ZOps
  */
 export abstract class Z<W, S1, S2, R, E, A> {
-  readonly _typeId: ZTypeId = ZTypeId;
-  readonly _W!: () => W;
-  readonly _S1!: (_: S1) => void;
-  readonly _S2!: () => S2;
-  readonly _R!: () => R;
-  readonly _E!: () => E;
-  readonly _A!: () => A;
+  readonly [ZTypeId]: ZTypeId = ZTypeId;
+  declare [ZVariance]: {
+    readonly _W: (_: never) => W;
+    readonly _S1: (_: S1) => void;
+    readonly _S2: (_: never) => S2;
+    readonly _R: (_: never) => R;
+    readonly _E: (_: never) => E;
+    readonly _A: (_: never) => A;
+  };
 }
 
 /**
@@ -57,7 +60,7 @@ export function unifyZ<X extends Z<any, any, any, any, any, any>>(
  * @tsplus static fncts.control.ZOps isZ
  */
 export function isZ(u: unknown): u is Z<unknown, unknown, unknown, unknown, unknown, unknown> {
-  return hasTypeId(u, ZTypeId);
+  return isObject(u) && ZTypeId in u;
 }
 
 export const enum ZTag {
@@ -183,14 +186,14 @@ export function concrete(_: Z<any, any, any, any, any, any>): asserts _ is Concr
   //
 }
 
-export const ZErrorTypeId = Symbol.for("@principia/base/Z/ZError");
+export const ZErrorTypeId = Symbol.for("fncts.Z.ZError");
 export type ZErrorTypeId = typeof ZErrorTypeId;
 
 export class ZError<E> {
-  readonly _typeId: ZErrorTypeId = ZErrorTypeId;
+  readonly [ZErrorTypeId]: ZErrorTypeId = ZErrorTypeId;
   constructor(readonly cause: Cause<E>) {}
 }
 
 export function isZError(u: unknown): u is ZError<unknown> {
-  return hasTypeId(u, ZErrorTypeId);
+  return isObject(u) && ZErrorTypeId in u;
 }

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/CaseClass.ts

@@ -21,7 +21,7 @@ export interface CaseConstructor {
 }
 
 export function isCaseClass(u: unknown): u is CaseConstructor {
-  return hasTypeId(u, CaseClassTypeId);
+  return isObject(u) && CaseClassTypeId in u;
 }
 
 const hash0 = Hashable.string("fncts.CaseClass");

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

@@ -663,6 +663,30 @@ export function isInterrupted<E>(self: Cause<E>): boolean {
   return self.find((cause) => (cause.isInterrupt() ? Just(cause) : Nothing())).isJust();
 }
 
+/**
+ * Determines if the `Cause` contains only interruptions and not any `Die` or
+ * `Fail` causes.
+ * @tsplus getter fncts.Cause isInterruptedOnly
+ */
+export function isInterruptedOnly<E>(self: Cause<E>): boolean {
+  return self.fold({
+    Empty: () => true,
+    Fail: () => false,
+    Halt: () => false,
+    Interrupt: () => true,
+    Both: (left, right) => left && right,
+    Then: (left, right) => left && right,
+    Stackless: (value) => value,
+  });
+}
+
+/**
+ * @tsplus getter fncts.Cause isFailure
+ */
+export function isFailure<E>(self: Cause<E>): boolean {
+  return self.failureMaybe.isJust();
+}
+
 /**
  * A type-guard matching `Traced`
  *
@@ -711,9 +735,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

@@ -3,6 +3,9 @@ import { Hashable } from "../../typeclass.js";
 import { isObject } from "../../util/predicates.js";
 import { tuple } from "../function.js";
 
+export const CauseVariance = Symbol.for("fncts.Cause.Variance");
+export type CauseVariance = typeof CauseVariance;
+
 export const CauseTypeId = Symbol.for("fncts.Cause");
 export type CauseTypeId = typeof CauseTypeId;
 
@@ -38,9 +41,10 @@ const _emptyHash = Hashable.string("fncts.Cause");
  * @tsplus companion fncts.Cause.EmptyOps
  */
 export class Empty {
-  readonly _E!: () => never;
-
   readonly [CauseTypeId]: CauseTypeId = CauseTypeId;
+  declare [CauseVariance]: {
+    readonly _E: (_: never) => never;
+  };
   readonly _tag = CauseTag.Empty;
 
   get [Symbol.hash](): number {
@@ -71,9 +75,10 @@ export const _Empty = new Empty();
  * @tsplus companion fncts.Cause.FailOps
  */
 export class Fail<E> {
-  readonly _E!: () => E;
-
   readonly [CauseTypeId]: CauseTypeId = CauseTypeId;
+  declare [CauseVariance]: {
+    readonly _E: (_: never) => E;
+  };
   readonly _tag = CauseTag.Fail;
 
   constructor(readonly value: E, readonly trace: Trace) {}
@@ -108,9 +113,10 @@ export class Fail<E> {
  * @tsplus companion fncts.Cause.HaltOps
  */
 export class Halt {
-  readonly _E!: () => never;
-
   readonly [CauseTypeId]: CauseTypeId = CauseTypeId;
+  declare [CauseVariance]: {
+    readonly _E: (_: never) => never;
+  };
   readonly _tag = CauseTag.Halt;
 
   constructor(readonly value: unknown, readonly trace: Trace) {}
@@ -145,9 +151,10 @@ export class Halt {
  * @tsplus companion fncts.Cause.InterruptOps
  */
 export class Interrupt {
-  readonly _E!: () => never;
-
   readonly [CauseTypeId]: CauseTypeId = CauseTypeId;
+  declare [CauseVariance]: {
+    readonly _E: (_: never) => never;
+  };
   readonly _tag = CauseTag.Interrupt;
 
   constructor(readonly id: FiberId, readonly trace: Trace) {}
@@ -183,9 +190,10 @@ export class Interrupt {
  * @tsplus companion fncts.Cause.ThenOps
  */
 export class Then<E> {
-  readonly _E!: () => E;
-
   readonly [CauseTypeId]: CauseTypeId = CauseTypeId;
+  declare [CauseVariance]: {
+    readonly _E: (_: never) => E;
+  };
   readonly _tag = CauseTag.Then;
 
   constructor(readonly left: Cause<E>, readonly right: Cause<E>) {}
@@ -216,9 +224,10 @@ export class Then<E> {
  * @tsplus companion fncts.Cause.BothOps
  */
 export class Both<E> {
-  readonly _E!: () => E;
-
   readonly [CauseTypeId]: CauseTypeId = CauseTypeId;
+  declare [CauseVariance]: {
+    readonly _E: (_: never) => E;
+  };
   readonly _tag = CauseTag.Both;
 
   constructor(readonly left: Cause<E>, readonly right: Cause<E>) {}
@@ -249,9 +258,10 @@ export class Both<E> {
  * @tsplus companion fncts.Cause.StacklessOps
  */
 export class Stackless<E> {
-  readonly _E!: () => E;
-
   readonly [CauseTypeId]: CauseTypeId = CauseTypeId;
+  declare [CauseVariance]: {
+    readonly _E: (_: never) => E;
+  };
   readonly _tag = CauseTag.Stackless;
 
   constructor(readonly cause: Cause<E>, readonly stackless: boolean) {}
@@ -279,7 +289,7 @@ export class Unified {
  * -------------------------------------------------------------------------------------------------
  */
 
-function structuralSymmetric<Id, A>(
+function structuralSymmetric<A>(
   f: (x: Cause<A>, y: Cause<A>) => Eval<boolean>,
 ): (x: Cause<A>, y: Cause<A>) => Eval<boolean> {
   return (x, y) => f(x, y).zipWith(f(y, x), (a, b) => a || b);
@@ -477,14 +487,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/Datum/definition.ts

@@ -34,6 +34,7 @@ const initialHash     = Hashable.combine(datumHash, Hashable.string(DatumTag.Ini
  */
 export class Initial implements Hashable, Equatable {
   readonly _tag = DatumTag.Initial;
+  readonly [DatumTypeId]: DatumTypeId = DatumTypeId;
   get [Symbol.hash](): number {
     return initialHash;
   }
@@ -49,8 +50,8 @@ const pendingHash = Hashable.combine(datumHash, Hashable.string(DatumTag.Pending
  * @tsplus companion fncts.Datum.PendingOps
  */
 export class Pending implements Hashable, Equatable {
-  readonly _typeId: DatumTypeId = DatumTypeId;
-  readonly _tag                 = DatumTag.Pending;
+  readonly [DatumTypeId]: DatumTypeId = DatumTypeId;
+  readonly _tag = DatumTag.Pending;
   get [Symbol.hash](): number {
     return pendingHash;
   }
@@ -64,8 +65,8 @@ export class Pending implements Hashable, Equatable {
  * @tsplus companion fncts.Datum.RefreshOps
  */
 export class Refresh<A> implements Hashable, Equatable {
-  readonly _typeId: DatumTypeId = DatumTypeId;
-  readonly _tag                 = DatumTag.Refresh;
+  readonly [DatumTypeId]: DatumTypeId = DatumTypeId;
+  readonly _tag = DatumTag.Refresh;
   constructor(readonly value: A) {}
   get [Symbol.hash](): number {
     return Hashable.combine(Hashable.combine(datumHash, Hashable.string(this._tag)), Hashable.unknown(this.value));
@@ -80,8 +81,8 @@ export class Refresh<A> implements Hashable, Equatable {
  * @tsplus companion fncts.Datum.RepleteOps
  */
 export class Replete<A> implements Hashable, Equatable {
-  readonly _typeId: DatumTypeId = DatumTypeId;
-  readonly _tag                 = DatumTag.Replete;
+  readonly [DatumTypeId]: DatumTypeId = DatumTypeId;
+  readonly _tag = DatumTag.Replete;
   constructor(readonly value: A) {}
   get [Symbol.hash](): number {
     return Hashable.combine(Hashable.combine(datumHash, Hashable.string(this._tag)), Hashable.unknown(this.value));
@@ -95,5 +96,5 @@ export class Replete<A> implements Hashable, Equatable {
  * @tsplus static fncts.DatumOps is
  */
 export function isDatum(u: unknown): u is Datum<unknown> {
-  return hasTypeId(u, DatumTypeId);
+  return isObject(u) && DatumTypeId in u;
 }

package/_src/data/DatumEither/definition.ts

@@ -8,7 +8,6 @@ export interface DatumEitherF extends HKT {
 
 /**
  * @tsplus type fncts.DatumEither
- * @tsplus no-inherit fncts.Datum
  */
 export type DatumEither<E, A> = Datum<Either<E, A>>;
 

package/_src/data/DatumEither.ts

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

package/_src/data/DecodeError/definition.ts

@@ -1,10 +1,12 @@
-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;
 
 export abstract class DecodeError {
-  readonly _typeId: DecodeErrorTypeId = DecodeErrorTypeId;
+  readonly [DecodeErrorTypeId]: DecodeErrorTypeId = DecodeErrorTypeId;
   abstract render: Eval<RoseTree<string>>;
 }
 
@@ -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();