@fncts/base 0.0.33 → 0.0.35

package/_mjs/optics/Prism/definition.mjs

@@ -12,10 +12,7 @@ function makePPrism_1(F) {
     reverseGet: F.reverseGet,
     ...tsplus_module_2.makePOptional({
       getOrModify: F.getOrModify,
-      set: b => s => tsplus_module_1.match({
-        Left: identity,
-        Right: () => F.reverseGet(b)
-      })(F.getOrModify(s))
+      set: b => s => tsplus_module_1.match(identity, () => F.reverseGet(b))(F.getOrModify(s))
     })
   };
 }

package/_mjs/optics/Prism/definition.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"definition.mjs","names":["makePPrism","makePPrism_1","identity","POptional","PPrism","F","reverseGet","tsplus_module_2","makePOptional","getOrModify","set","b","s","tsplus_module_1","match","Left","Right","Prism","makePrism"],"sources":["../../../_src/optics/Prism/definition.ts"],"sourcesContent":[null],"mappings":";;aA+BgBA,UAAU,GAAAC,YAAA;AA7B1B,SAASC,QAAQ,QAAQ,2BAA2B;AACpD,SAASC,SAAS,QAAQ,6BAA6B;AAkBvD,OAAO,MAAMC,MAAM,GAAc,EAAE;AAOnC;;;AAGA,SAAAH,aAAuCI,CAAwB;EAC7D,OAAO;IACLC,UAAU,EAAED,CAAC,CAACC,UAAU;IACxB,GAAGC,eAAA,CAAAC,aAAA,CAAU;MACXC,WAAW,EAAEJ,CAAC,CAACI,WAAW;MAC1BC,GAAG,EAAGC,CAAC,IAAMC,CAAC,IAAKC,eAAA,CAAAC,KAAA,CAAuB;QAAEC,IAAI,EAAEb,QAAQ;QAAEc,KAAK,EAAEA,CAAA,KAAMX,CAAC,CAACC,UAAU,CAACK,CAAC;MAAC,CAAE,EAAvEN,CAAC,CAACI,WAAW,CAACG,CAAC,CAAC;KACpC;GACF;AACH;AAYA,OAAO,MAAMK,KAAK,GAAa,EAAE;AAEjC;;;AAGA,OAAM,SAAUC,SAASA,CAAOb,CAAwB;EACtD,OAAOJ,YAAA,CAAOI,CAAC,CAAC;AAClB"}
+{"version":3,"file":"definition.mjs","names":["makePPrism","makePPrism_1","identity","POptional","PPrism","F","reverseGet","tsplus_module_2","makePOptional","getOrModify","set","b","s","tsplus_module_1","match","Prism","makePrism"],"sources":["../../../_src/optics/Prism/definition.ts"],"sourcesContent":[null],"mappings":";;aA+BgBA,UAAU,GAAAC,YAAA;AA7B1B,SAASC,QAAQ,QAAQ,2BAA2B;AACpD,SAASC,SAAS,QAAQ,6BAA6B;AAkBvD,OAAO,MAAMC,MAAM,GAAc,EAAE;AAOnC;;;AAGA,SAAAH,aAAuCI,CAAwB;EAC7D,OAAO;IACLC,UAAU,EAAED,CAAC,CAACC,UAAU;IACxB,GAAGC,eAAA,CAAAC,aAAA,CAAU;MACXC,WAAW,EAAEJ,CAAC,CAACI,WAAW;MAC1BC,GAAG,EAAGC,CAAC,IAAMC,CAAC,IAAKC,eAAA,CAAAC,KAAA,CAAuBZ,QAAQ,EAAE,MAAMG,CAAC,CAACC,UAAU,CAACK,CAAC,CAAC,EAAtDN,CAAC,CAACI,WAAW,CAACG,CAAC,CAAC;KACpC;GACF;AACH;AAYA,OAAO,MAAMG,KAAK,GAAa,EAAE;AAEjC;;;AAGA,OAAM,SAAUC,SAASA,CAAOX,CAAwB;EACtD,OAAOJ,YAAA,CAAOI,CAAC,CAAC;AAClB"}

package/_mjs/typeclass/MonadExcept.mjs

@@ -1,9 +1,6 @@
 import * as tsplus_module_1 from "@fncts/base/data/Either/destructors";
 export const MonadExcept = {};
 export function absolve(F) {
-  return F.flatMap(r => tsplus_module_1.match({
-    Left: F.fail,
-    Right: F.pure
-  })(r));
+  return F.flatMap(r => tsplus_module_1.match(F.fail, F.pure)(r));
 }
 //# sourceMappingURL=MonadExcept.mjs.map

package/_mjs/typeclass/MonadExcept.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"MonadExcept.mjs","names":["MonadExcept","absolve","F","flatMap","r","tsplus_module_1","match","Left","fail","Right","pure"],"sources":["../../_src/typeclass/MonadExcept.ts"],"sourcesContent":[null],"mappings":";AAaA,OAAO,MAAMA,WAAW,GAAmB,EAAE;AAU7C,OAAM,SAAUC,OAAOA,CACrBC,CAAwB;EAExB,OAAOA,CAAC,CAACC,OAAO,CAAEC,CAAC,IAAKC,eAAA,CAAAC,KAAA,CAAQ;IAAEC,IAAI,EAAEL,CAAC,CAACM,IAAI;IAAEC,KAAK,EAAEP,CAAC,CAACQ;EAAI,CAAE,EAAvCN,CAAC,CAAuC,CAAC;AACnE"}
+{"version":3,"file":"MonadExcept.mjs","names":["MonadExcept","absolve","F","flatMap","r","tsplus_module_1","match","fail","pure"],"sources":["../../_src/typeclass/MonadExcept.ts"],"sourcesContent":[null],"mappings":";AAaA,OAAO,MAAMA,WAAW,GAAmB,EAAE;AAU7C,OAAM,SAAUC,OAAOA,CACrBC,CAAwB;EAExB,OAAOA,CAAC,CAACC,OAAO,CAAEC,CAAC,IAAKC,eAAA,CAAAC,KAAA,CAAQJ,CAAC,CAACK,IAAI,EAAEL,CAAC,CAACM,IAAI,EAAtBJ,CAAC,CAAsB,CAAC;AAClD"}

package/_src/collection/immutable/Conc/api.ts

@@ -874,10 +874,10 @@ export function partitionMapWithIndex<A, B, C>(f: (i: number, a: A) => Either<B,
       const array = result.value;
       for (let j = 0; j < array.length; j++) {
         const eab = f(i, array[j]!);
-        eab.match({
-          Left: (b) => left.append(b),
-          Right: (c) => right.append(c),
-        });
+        eab.match(
+          (b) => left.append(b),
+          (c) => right.append(c),
+        );
         i++;
       }
     }

package/_src/collection/immutable/HashMap/api.ts

@@ -476,14 +476,14 @@ export function partitionMapWithIndex<K, V, A, B>(f: (i: K, a: V) => Either<A, B
     const left  = makeWith<K, A>(self.config).beginMutation;
     const right = makeWith<K, B>(self.config).beginMutation;
     self.forEachWithIndex((k, v) => {
-      f(k, v).match({
-        Left: (a) => {
+      f(k, v).match(
+        (a) => {
           left.set(k, a);
         },
-        Right: (b) => {
+        (b) => {
           right.set(k, b);
         },
-      });
+      );
     });
     return [left.endMutation, right.endMutation];
   };

package/_src/collection/immutable/HashSet/api.ts

@@ -300,14 +300,14 @@ export function partitionMapWith<B, C>(
     const right = beginMutation(emptyWith(C));
     const left  = beginMutation(emptyWith(B));
     fa.forEach((v) => {
-      f(v).match({
-        Left: (b) => {
+      f(v).match(
+        (b) => {
           left.add(b);
         },
-        Right: (c) => {
+        (c) => {
           right.add(c);
         },
-      });
+      );
     });
     return [endMutation(left), endMutation(right)];
   };

package/_src/collection/immutable/ImmutableArray/api.ts

@@ -1430,16 +1430,16 @@ export function _wiltWithIndex<A>(self: ImmutableArray<A>) {
         .foldLeftWithIndex(G.pure([[] as Array<B>, [] as Array<B2>] as const), (i, fbs, a) =>
           f(i, a).pipe(
             G.zipWith(fbs, (eb, r) =>
-              eb.match({
-                Left: (b1) => {
+              eb.match(
+                (b1) => {
                   r[0].push(b1);
                   return r;
                 },
-                Right: (b2) => {
+                (b2) => {
                   r[1].push(b2);
                   return r;
                 },
-              }),
+              ),
             ),
           ),
         )

package/_src/collection/immutable/ImmutableArray/instances.ts

@@ -1,7 +1,5 @@
 import type { ImmutableArrayF } from "@fncts/base/collection/immutable/ImmutableArray/definition";
-import type { DecodeError } from "@fncts/base/data/DecodeError";
 import type * as P from "@fncts/base/typeclass";
-import type { Check } from "@fncts/typelevel/Check";
 
 import {
   alignWith,

package/_src/control/Pure/api.ts

@@ -8,7 +8,7 @@ import { identity, tuple } from "../../data/function.js";
 export function absolve<W, S1, S2, R, E, E1, A>(
   fa: Pure<W, S1, S2, R, E, Either<E1, A>>,
 ): Pure<W, S1, S2, R, E | E1, A> {
-  return fa.flatMap((ea) => ea.match({ Left: Pure.failNow, Right: Pure.succeedNow }));
+  return fa.flatMap((ea) => ea.match(Pure.failNow, Pure.succeedNow));
 }
 
 /**
@@ -350,10 +350,7 @@ export function matchPure<S5, S2, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(
   onSuccess: (a: A) => Pure<W2, S2, S4, R2, E2, C>,
 ) {
   return <W, S1, R>(fa: Pure<W, S1, S2, R, E, A>): Pure<W | W1 | W2, S1 & S5, S3 | S4, R | R1 | R2, E1 | E2, B | C> => {
-    return fa.matchCausePure(
-      (cause) => cause.failureOrCause.match({ Left: onFailure, Right: Pure.failCauseNow }),
-      onSuccess,
-    );
+    return fa.matchCausePure((cause) => cause.failureOrCause.match(onFailure, Pure.failCauseNow), onSuccess);
   };
 }
 
@@ -381,7 +378,7 @@ export function matchLogPure<W, S5, S2, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2,
 ) {
   return <S1, R>(fa: Pure<W, S1, S2, R, E, A>): Pure<W | W1 | W2, S1 & S5, S3 | S4, R | R1 | R2, E1 | E2, B | C> => {
     return fa.matchLogCausePure(
-      (ws, cause) => cause.failureOrCause.match({ Left: (e) => onFailure(ws, e), Right: Pure.failCauseNow }),
+      (ws, cause) => cause.failureOrCause.match((e) => onFailure(ws, e), Pure.failCauseNow),
       onSuccess,
     );
   };
@@ -431,7 +428,7 @@ export function modifyEither<S1, S2, E, A>(
 ): Pure<never, S1, S2, never, E, A> {
   return Pure.get<S1>()
     .map(f)
-    .flatMap((r) => r.match({ Left: Pure.failNow, Right: ([a, s2]) => Pure.succeedNow(a).mapState(() => s2) }));
+    .flatMap((r) => r.match(Pure.failNow, ([a, s2]) => Pure.succeedNow(a).mapState(() => s2)));
 }
 
 /**

package/_src/control.ts

@@ -2,7 +2,5 @@
 // codegen:start { preset: type-barrel, include: ./control/*.ts }
 export type {} from "./control/Pure.js";
 export type {} from "./control/LazyValue.js";
-export type {} from "./control/InterruptiblePromise.js";
 export type {} from "./control/Eval.js";
-export type {} from "./control/CompletablePromise.js";
 // codegen:end

package/_src/data/Cause/api.ts

@@ -339,10 +339,10 @@ export function flipCauseEither<E, A>(self: Cause<Either<E, A>>): Either<Cause<E
           result = Either.left(c);
           break pushing;
         case CauseTag.Fail:
-          result = c.value.match({
-            Left: (l) => Either.left(Cause.fail(l, Trace.none)),
-            Right: (r) => Either.right(r),
-          });
+          result = c.value.match(
+            (l) => Either.left(Cause.fail(l, Trace.none)),
+            (r) => Either.right(r),
+          );
           break pushing;
         case CauseTag.Sequential:
           stack.push(new FCEStackFrameThenLeft(c));
@@ -898,10 +898,10 @@ function sequenceCauseEitherEval<E, A>(self: Cause<Either<E, A>>): Eval<Either<C
     }
     case CauseTag.Fail: {
       return Eval.now(
-        self.value.match({
-          Left: (e) => Either.left(Cause.fail(e, Trace.none)),
-          Right: (a) => Either.right(a),
-        }),
+        self.value.match(
+          (e) => Either.left(Cause.fail(e, Trace.none)),
+          (a) => Either.right(a),
+        ),
       );
     }
     case CauseTag.Halt: {

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/Datum/api.ts

@@ -336,15 +336,15 @@ export function partitionMap<A, B, C>(f: (a: A) => Either<B, C>) {
       Initial: () => [Initial(), Initial()],
       Pending: () => [Pending(), Pending()],
       Refresh: (a) =>
-        f(a).match({
-          Left: (b) => [Refresh(b), Initial()],
-          Right: (c) => [Initial(), Refresh(c)],
-        }),
+        f(a).match(
+          (b) => [Refresh(b), Initial()],
+          (c) => [Initial(), Refresh(c)],
+        ),
       Replete: (a) =>
-        f(a).match({
-          Left: (b) => [Replete(b), Initial()],
-          Right: (c) => [Initial(), Replete(c)],
-        }),
+        f(a).match(
+          (b) => [Replete(b), Initial()],
+          (c) => [Initial(), Replete(c)],
+        ),
     });
   };
 }

package/_src/data/DatumEither/api.ts

@@ -303,16 +303,16 @@ export function partitionMap<A, B, C>(f: (a: A) => Either<B, C>) {
       Pending: () => [self.unsafeCoerce(), self.unsafeCoerce()],
       RefreshLeft: () => [self.unsafeCoerce(), self.unsafeCoerce()],
       RefreshRight: (a) =>
-        f(a).match({
-          Left: (b) => [DatumEither.refreshRight(b), DatumEither.initial()],
-          Right: (c) => [DatumEither.initial(), DatumEither.refreshRight(c)],
-        }),
+        f(a).match(
+          (b) => [DatumEither.refreshRight(b), DatumEither.initial()],
+          (c) => [DatumEither.initial(), DatumEither.refreshRight(c)],
+        ),
       RepleteLeft: () => [self.unsafeCoerce(), self.unsafeCoerce()],
       RepleteRight: (a) =>
-        f(a).match({
-          Left: (b) => [DatumEither.repleteRight(b), DatumEither.initial()],
-          Right: (c) => [DatumEither.initial(), DatumEither.repleteRight(c)],
-        }),
+        f(a).match(
+          (b) => [DatumEither.repleteRight(b), DatumEither.initial()],
+          (c) => [DatumEither.initial(), DatumEither.repleteRight(c)],
+        ),
     });
   };
 }

package/_src/data/Either/api.ts

@@ -97,20 +97,20 @@ export function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>
  * @tsplus getter fncts.Either getLeft
  */
 export function getLeft<E, A>(self: Either<E, A>): Maybe<E> {
-  return self.match({
-    Left: (e) => Just(e),
-    Right: (_a) => Nothing(),
-  });
+  return self.match(
+    (e) => Just(e),
+    (_a) => Nothing(),
+  );
 }
 
 /**
  * @tsplus getter fncts.Either getRight
  */
 export function getRight<E, A>(self: Either<E, A>): Maybe<A> {
-  return self.match({
-    Left: (_e) => Nothing(),
-    Right: (a) => Just(a),
-  });
+  return self.match(
+    (_e) => Nothing(),
+    (a) => Just(a),
+  );
 }
 
 /**
@@ -118,7 +118,7 @@ export function getRight<E, A>(self: Either<E, A>): Maybe<A> {
  */
 export function getOrElse<E, B>(orElse: (e: E) => B) {
   return <A>(self: Either<E, A>): A | B => {
-    return self.match({ Left: orElse, Right: identity });
+    return self.match(orElse, identity);
   };
 }
 
@@ -172,7 +172,7 @@ export function mapLeft<E1, E2>(f: (e: E1) => E2) {
  * @tsplus getter fncts.Either value
  */
 export function merge<E, A>(self: Either<E, A>): E | A {
-  return self.match({ Left: identity, Right: identity });
+  return self.match(identity, identity);
 }
 
 /**
@@ -201,10 +201,10 @@ export function _traverse<E, A>(self: Either<E, A>) {
     <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>,
     ): HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, Either<E, B>> =>
-      self.match({
-        Left: (e) => G.pure(Left(e)),
-        Right: (a) => f(a).pipe(G.map((b) => Right(b))),
-      });
+      self.match(
+        (e) => G.pure(Left(e)),
+        (a) => f(a).pipe(G.map((b) => Right(b))),
+      );
 }
 
 export const traverse_: P.Traversable<EitherF>["traverse"] = (A) => (f) => (self) => self.traverse(A)(f);
@@ -288,10 +288,10 @@ export function partition<E, A>(p: Predicate<A>, /** @tsplus auto */ M: P.Monoid
  * @tsplus getter fncts.Either toMaybe
  */
 export function toMaybe<E, A>(self: Either<E, A>): Maybe<A> {
-  return self.match({
-    Left: () => Nothing(),
-    Right: (a) => Just(a),
-  });
+  return self.match(
+    () => Nothing(),
+    (a) => Just(a),
+  );
 }
 
 /* eslint-disable simple-import-sort/exports */

package/_src/data/Either/definition.ts

@@ -26,10 +26,11 @@ type IOTypeId = typeof IOTypeId;
  * @tsplus type fncts.Either
  * @tsplus companion fncts.EitherOps
  */
-export class Either<E, A> {
+export abstract class Either<E, A> {
   readonly [EitherTypeId]: EitherTypeId = EitherTypeId;
   readonly [IOTypeId]: IOTypeId         = IOTypeId;
   readonly trace?: string | undefined   = undefined;
+  readonly _ioOpCode                    = null;
   declare [EitherVariance]: {
     readonly _E: (_: never) => E;
     readonly _A: (_: never) => A;

package/_src/data/Either/destructors.ts

@@ -3,14 +3,14 @@ import { EitherTag } from "./definition.js";
 /**
  * @tsplus pipeable fncts.Either match
  */
-export function match<E, A, B, C>(cases: { Left: (e: E) => B; Right: (a: A) => C }) {
+export function match<E, A, B, C>(onLeft: (e: E) => B, onRight: (a: A) => C) {
   return (self: Either<E, A>): B | C => {
     self.concrete();
     switch (self._tag) {
       case EitherTag.Left:
-        return cases.Left(self.left);
+        return onLeft(self.left);
       case EitherTag.Right:
-        return cases.Right(self.right);
+        return onRight(self.right);
     }
   };
 }

package/_src/data/Either/instances.ts

@@ -2,7 +2,6 @@ import type { EitherF } from "@fncts/base/data/Either/definition.js";
 
 import { map } from "@fncts/base/data/Either/api";
 import { concrete, Either, EitherTag, Right } from "@fncts/base/data/Either/definition";
-import { EitherJson } from "@fncts/base/json/EitherJson";
 
 import * as P from "../../typeclass.js";
 
@@ -20,18 +19,18 @@ export function getEq<E, A>(EE: P.Eq<E>, EA: P.Eq<A>): P.Eq<Either<E, A>> {
   return P.Eq({
     equals: (y) => (x) =>
       x === y ||
-      x.match({
-        Left: (e1) =>
-          y.match({
-            Left: (e2) => EE.equals(e2)(e1),
-            Right: () => false,
-          }),
-        Right: (a1) =>
-          y.match({
-            Left: () => false,
-            Right: (a2) => EA.equals(a2)(a1),
-          }),
-      }),
+      x.match(
+        (e1) =>
+          y.match(
+            (e2) => EE.equals(e2)(e1),
+            () => false,
+          ),
+        (a1) =>
+          y.match(
+            () => false,
+            (a2) => EA.equals(a2)(a1),
+          ),
+      ),
   });
 }
 
@@ -115,21 +114,3 @@ export function deriveGuard<A extends Either<any, any>>(
     return false;
   });
 }
-
-/**
- * @tsplus derive fncts.Decoder[fncts.Either]<_> 10
- */
-export function deriveDecoder<A extends Either<any, any>>(
-  ...[left, right]: [A] extends [Either<infer E, infer A>] ? [left: Decoder<E>, right: Decoder<A>] : never
-): Decoder<A> {
-  const jsonDecoder = EitherJson.getDecoder(left, right);
-  return Decoder(
-    (u) =>
-      jsonDecoder
-        .decode(u)
-        .map((result) =>
-          result._tag === "Left" ? (Either.left(result.left) as A) : (Either.right(result.right) as A),
-        ),
-    `Either<${left.label}, ${right.label}>`,
-  );
-}

package/_src/data/EitherT/api.ts

@@ -122,10 +122,10 @@ export function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>) {
   >) =>
     F.flatMap(
       (either) =>
-        either.match({
-          Left: (e) => F.pure(Either.left(e)),
-          Right: (a) => f(a),
-        }) as HKT.Kind<
+        either.match(
+          (e) => F.pure(Either.left(e)),
+          (a) => f(a),
+        ) as HKT.Kind<
           F,
           FC,
           HKT.Intro<F, "K", K, K1>,
@@ -225,9 +225,9 @@ export function orElse<F>(F: P.Monad<HKT.F1<F>>) {
     that: Lazy<HKT.FK1<F, Either<E1, B>>>,
   ): ((self: HKT.FK1<F, Either<E, A>>) => HKT.FK1<F, Either<E | E1, A | B>>) =>
     F.flatMap((either) =>
-      either.match({
-        Left: () => that(),
-        Right: () => F.pure(either),
-      }),
+      either.match(
+        () => that(),
+        () => F.pure(either),
+      ),
     );
 }

package/_src/data/Exit/api.ts

@@ -223,9 +223,9 @@ export function value<E, A>(self: Exit<E, A>): A | undefined {
 /**
  * Returns the Exit's Success value if it exists, or throws the pretty-printed Cause if it doesn't
  *
- * @tsplus getter fncts.Exit valueOrThrow
+ * @tsplus getter fncts.Exit getOrThrow
  */
-export function valueOrThrow<E, A>(self: Exit<E, A>): A {
+export function getOrThrow<E, A>(self: Exit<E, A>): A {
   if (self.isFailure()) {
     throw new IOError(self.cause);
   }

package/_src/data/Exit/constructors.ts

@@ -18,7 +18,7 @@ export function fail<E = never, A = never>(e: E, __tsplusTrace?: string): Exit<E
  * @tsplus static fncts.ExitOps fromEither
  */
 export function fromEither<E = never, A = never>(e: Either<E, A>): Exit<E, A> {
-  return e.match({ Left: fail, Right: succeed });
+  return e.match(fail, succeed);
 }
 
 /**

package/_src/data/Exit/definition.ts

@@ -35,6 +35,7 @@ const _successHash = Hashable.string("fncts.Exit.Success");
  */
 export class Failure<E> {
   readonly [ExitTypeId]: ExitTypeId = ExitTypeId;
+  readonly _ioOpCode                = null;
   declare [ExitVariance]: {
     readonly _E: (_: never) => E;
     readonly _A: (_: never) => never;
@@ -60,6 +61,7 @@ export class Failure<E> {
  */
 export class Success<A> implements P.Hashable, P.Equatable {
   readonly [ExitTypeId]: ExitTypeId = ExitTypeId;
+  readonly _ioOpCode                = null;
   declare [ExitVariance]: {
     readonly _E: (_: never) => never;
     readonly _A: (_: never) => A;

package/_src/data/Guard/api.ts

@@ -5,7 +5,7 @@ import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
 
 import { Guard } from "@fncts/base/data/Guard/definition";
 import { AssertionError } from "@fncts/base/util/assert";
-import { isNull, isUndefined } from "@fncts/base/util/predicates";
+import { isArray, isNull, isUndefined } from "@fncts/base/util/predicates";
 
 /**
  * @tsplus pipeable fncts.Guard __call
@@ -441,8 +441,11 @@ export function validation<A, B extends ReadonlyArray<Validation<A, any>>>(...va
  */
 export function deriveTuple<A extends ReadonlyArray<unknown>>(
   ...[components]: Check<Check.IsTuple<A>> extends Check.True ? [components: { [K in keyof A]: Guard<A[K]> }] : never
-): Encoder<A> {
-  return Encoder((inp) => {
+): Guard<A> {
+  return Guard((inp): inp is A => {
+    if (!isArray(inp)) {
+      return false;
+    }
     for (let i = 0; i < inp.length; i++) {
       if (!components[i]!.is(inp[i])) {
         return false;