@fncts/base 0.0.34 → 0.0.35

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/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/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/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;

package/_src/data/Maybe/api.ts

@@ -95,10 +95,10 @@ export function partitionMap<A, B, C>(f: (a: A) => Either<B, C>) {
   return (self: Maybe<A>): readonly [Maybe<B>, Maybe<C>] => {
     self.concrete();
     if (self._tag === MaybeTag.Just) {
-      return f(self.value).match({
-        Left: (b) => [Just(b), Nothing()],
-        Right: (c) => [Nothing(), Just(c)],
-      });
+      return f(self.value).match(
+        (b) => [Just(b), Nothing()],
+        (c) => [Nothing(), Just(c)],
+      );
     } else {
       return [Nothing(), Nothing()];
     }

package/_src/data/Maybe/instances.ts

@@ -1,8 +1,6 @@
 import type * as P from "../../typeclass.js";
 import type { MaybeF } from "@fncts/base/data/Maybe/definition";
 
-import { MaybeJson } from "@fncts/base/json/MaybeJson";
-
 import { filter, filterMap, flatMap, foldLeft, foldRight, map, partition, partitionMap, zip, zipWith } from "./api.js";
 import { just } from "./constructors.js";
 
@@ -69,40 +67,3 @@ export function deriveGuard<A extends Maybe<any>>(
     return false;
   });
 }
-
-/**
- * @tsplus derive fncts.Decoder[fncts.Maybe]<_> 10
- */
-export function deriveDecoder<A extends Maybe<any>>(
-  ...[value]: [A] extends [Maybe<infer A>] ? [value: Decoder<A>] : never
-): Decoder<A> {
-  const label = `Maybe<${value.label}>`;
-  return Decoder(
-    (input) =>
-      MaybeJson.getDecoder(value)
-        .decode(input)
-        .map((decoded) => (decoded._tag === "Nothing" ? (Nothing() as A) : (Just(decoded.value) as A))),
-    label,
-  );
-}
-
-/**
- * @tsplus derive fncts.Encoder[fncts.Maybe]<_> 10
- */
-export function deriveEncoder<A extends Maybe<any>>(
-  ...[value]: [A] extends [Maybe<infer A>] ? [value: Encoder<A>] : never
-): Encoder<A> {
-  return Encoder((input) => {
-    Maybe.concrete(input);
-    if (input.isJust()) {
-      return {
-        _tag: "Just",
-        value: value.encode(input.value),
-      };
-    } else {
-      return {
-        _tag: "Nothing",
-      };
-    }
-  });
-}

package/_src/data/Showable/show.ts

@@ -129,7 +129,7 @@ export function show(value: unknown): string {
   return _show(value).unsafeRunStateResult(getShowContext());
 }
 
-export function showWithOptions(value: unknown, options: Partial<ShowOptions>): string {
+export function showWithOptions(value: unknown, options?: Partial<ShowOptions>): string {
   return _show(value).unsafeRunStateResult(getShowContext(options));
 }
 

package/_src/data/These/instances.ts

@@ -19,25 +19,3 @@ export function deriveGuard<A extends These<any, any>>(
     return false;
   });
 }
-
-/**
- * @tsplus derive fncts.Decoder[fncts.These]<_> 10
- */
-export function deriveDecoder<A extends These<any, any>>(
-  ...[left, right]: [A] extends [These<infer E, infer A>] ? [left: Decoder<E>, right: Decoder<A>] : never
-): Decoder<A> {
-  const label = `These<${left.label}, ${right.label}>`;
-  return Decoder(
-    (input) =>
-      TheseJson.getDecoder(left, right)
-        .decode(input)
-        .map((result) =>
-          result._tag === "Left"
-            ? (These.left(result.left) as A)
-            : result._tag === "Right"
-              ? (These.right(result.right) as A)
-              : (These.both(result.left, result.right) as A),
-        ),
-    label,
-  );
-}

package/_src/global.ts

@@ -107,10 +107,6 @@ import { Datum } from "@fncts/base/data/Datum/definition";
  * @tsplus global
  */
 import { DatumEither } from "@fncts/base/data/DatumEither/definition";
-/**
- * @tsplus global
- */
-import { Decoder } from "@fncts/base/data/Decoder/definition";
 /**
  * @tsplus global
  */
@@ -119,10 +115,6 @@ import { Duration } from "@fncts/base/data/Duration/definition";
  * @tsplus global
  */
 import { Either } from "@fncts/base/data/Either/definition";
-/**
- * @tsplus global
- */
-import { Encoder } from "@fncts/base/data/Encoder/definition";
 /**
  * @tsplus global
  */

package/_src/json/EitherJson.ts

@@ -19,10 +19,3 @@ export type EitherJson<E, A> = LeftJson<E> | RightJson<A>;
 export interface EitherJsonOps {}
 
 export const EitherJson: EitherJsonOps = {};
-
-/**
- * @tsplus static fncts.EitherJsonOps getDecoder
- */
-export function getDecoder<E, A>(left: Decoder<E>, right: Decoder<A>): Decoder<EitherJson<E, A>> {
-  return Derive();
-}

package/_src/json/MaybeJson.ts

@@ -18,10 +18,3 @@ export type MaybeJson<A> = NothingJson | JustJson<A>;
 export interface MaybeJsonOps {}
 
 export const MaybeJson: MaybeJsonOps = {};
-
-/**
- * @tsplus static fncts.MaybeJsonOps getDecoder
- */
-export function getDecoder<A>(value: Decoder<A>): Decoder<MaybeJson<A>> {
-  return Derive();
-}

package/_src/json/TheseJson.ts

@@ -22,10 +22,3 @@ export type TheseJson<E, A> = LeftJson<E> | RightJson<A> | BothJson<E, A>;
 export interface TheseJsonOps {}
 
 export const TheseJson: TheseJsonOps = {};
-
-/**
- * @tsplus static fncts.TheseJsonOps getDecoder
- */
-export function getDecoder<E, A>(left: Decoder<E>, right: Decoder<A>): Decoder<TheseJson<E, A>> {
-  return Derive();
-}

package/_src/optics/Optional/definition.ts

@@ -42,10 +42,10 @@ export function makePOptional<S, T, A, B>(F: POptionalMin<S, T, A, B>): POptiona
     modifyMaybe: (f) => (s) => getMaybe(s).map((a) => pipe(s, F.set(f(a)))),
     ...PTraversal<S, T, A, B>({
       modifyA: (A) => (f) => (s) =>
-        F.getOrModify(s).match({
-          Left: (t) => A.pure(t),
-          Right: (a) => f(a).pipe(A.map((b) => s.pipe(F.set(b)))),
-        }),
+        F.getOrModify(s).match(
+          (t) => A.pure(t),
+          (a) => f(a).pipe(A.map((b) => s.pipe(F.set(b)))),
+        ),
     }),
   };
 }

package/_src/optics/Prism/definition.ts

@@ -34,7 +34,7 @@ export function makePPrism<S, T, A, B>(F: PPrismMin<S, T, A, B>): PPrism<S, T, A
     reverseGet: F.reverseGet,
     ...POptional({
       getOrModify: F.getOrModify,
-      set: (b) => (s) => F.getOrModify(s).match({ Left: identity, Right: () => F.reverseGet(b) }),
+      set: (b) => (s) => F.getOrModify(s).match(identity, () => F.reverseGet(b)),
     }),
   };
 }

package/_src/typeclass/MonadExcept.ts

@@ -24,5 +24,5 @@ export function absolve<F extends HKT, FC = HKT.None>(
 export function absolve<F>(
   F: MonadExcept<HKT.F<F>>,
 ): <E, A, E1>(fa: HKT.FK2<F, E, Either<E1, A>>) => HKT.FK2<F, HKT.Mix<HKT.F<F>, "E", [E, E1]>, A> {
-  return F.flatMap((r) => r.match({ Left: F.fail, Right: F.pure }));
+  return F.flatMap((r) => r.match(F.fail, F.pure));
 }

package/data/Either/destructors.d.ts

@@ -3,7 +3,4 @@ import { Either } from "@fncts/base/data/Either/definition";
  * @tsplus pipeable fncts.Either match
  * @tsplus location "@fncts/base/data/Either/destructors"
  */
-export declare function match<E, A, B, C>(cases: {
-    Left: (e: E) => B;
-    Right: (a: A) => C;
-}): (self: Either<E, A>) => B | C;
+export declare function match<E, A, B, C>(onLeft: (e: E) => B, onRight: (a: A) => C): (self: Either<E, A>) => B | C;

package/data/Either/instances.d.ts

@@ -1,7 +1,6 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { Guard } from "@fncts/base/data/Guard";
-import { Decoder } from "@fncts/base/data/Decoder/definition";
 import type { EitherF } from "@fncts/base/data/Either/definition.js";
 import { Either } from "@fncts/base/data/Either/definition";
 import * as P from "../../typeclass.js";
@@ -30,8 +29,3 @@ export declare function getFilerable<E>(/** @tsplus auto */ ME: P.Monoid<E>): P.
  * @tsplus location "@fncts/base/data/Either/instances"
  */
 export declare function deriveGuard<A extends Either<any, any>>(...[left, right]: [A] extends [Either<infer E, infer A>] ? [left: Guard<E>, right: Guard<A>] : never): Guard<A>;
-/**
- * @tsplus derive fncts.Decoder[fncts.Either]<_> 10
- * @tsplus location "@fncts/base/data/Either/instances"
- */
-export declare 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>;

package/data/Guard/api.d.ts

@@ -3,7 +3,6 @@ import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { Encoder } from "@fncts/base/data/Encoder/definition";
 import type { Brand, Validation } from "@fncts/base/data/Branded";
 import type { Check } from "@fncts/typelevel";
 import type { Literal } from "@fncts/typelevel/Any";
@@ -232,7 +231,7 @@ export declare function validation<A, B extends ReadonlyArray<Validation<A, any>
  */
 export declare 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>;
+}] : never): Guard<A>;
 /**
  * @tsplus static fncts.GuardOps tuple
  * @tsplus location "@fncts/base/data/Guard/api"

package/data/Maybe/instances.d.ts

@@ -1,7 +1,5 @@
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Guard } from "@fncts/base/data/Guard";
-import { Decoder } from "@fncts/base/data/Decoder/definition";
-import { Encoder } from "@fncts/base/data/Encoder/definition";
 import type * as P from "../../typeclass.js";
 import type { MaybeF } from "@fncts/base/data/Maybe/definition";
 /**
@@ -39,13 +37,3 @@ export declare const Filterable: P.Filterable<MaybeF, import("@fncts/typelevel/H
  * @tsplus location "@fncts/base/data/Maybe/instances"
  */
 export declare function deriveGuard<A extends Maybe<any>>(...[guard]: [A] extends [Maybe<infer A>] ? [guard: Guard<A>] : never): Guard<A>;
-/**
- * @tsplus derive fncts.Decoder[fncts.Maybe]<_> 10
- * @tsplus location "@fncts/base/data/Maybe/instances"
- */
-export declare function deriveDecoder<A extends Maybe<any>>(...[value]: [A] extends [Maybe<infer A>] ? [value: Decoder<A>] : never): Decoder<A>;
-/**
- * @tsplus derive fncts.Encoder[fncts.Maybe]<_> 10
- * @tsplus location "@fncts/base/data/Maybe/instances"
- */
-export declare function deriveEncoder<A extends Maybe<any>>(...[value]: [A] extends [Maybe<infer A>] ? [value: Encoder<A>] : never): Encoder<A>;

package/data/Showable/show.d.ts

@@ -50,6 +50,6 @@ export interface ShowComputationComplex {
 export declare function showComputationComplex(args: Omit<ShowComputationComplex, "_tag">): ShowComputationComplex;
 export type ShowComputationExternal = ShowComputationPrimitive | ShowComputationComplex;
 export declare function show(value: unknown): string;
-export declare function showWithOptions(value: unknown, options: Partial<ShowOptions>): string;
+export declare function showWithOptions(value: unknown, options?: Partial<ShowOptions>): string;
 export declare function _show(value: unknown): ShowComputation;
 export declare function showProperty(value: object, key: PropertyKey, type: number, desc?: PropertyDescriptor): ShowComputation;

package/data/These/instances.d.ts

@@ -1,13 +1,7 @@
 import { These } from "@fncts/base/data/These";
 import { Guard } from "@fncts/base/data/Guard";
-import { Decoder } from "@fncts/base/data/Decoder/definition";
 /**
  * @tsplus derive fncts.Guard[fncts.These]<_> 10
  * @tsplus location "@fncts/base/data/These/instances"
  */
 export declare function deriveGuard<A extends These<any, any>>(...[left, right]: [A] extends [These<infer E, infer A>] ? [left: Guard<E>, right: Guard<A>] : never): Guard<A>;
-/**
- * @tsplus derive fncts.Decoder[fncts.These]<_> 10
- * @tsplus location "@fncts/base/data/These/instances"
- */
-export declare function deriveDecoder<A extends These<any, any>>(...[left, right]: [A] extends [These<infer E, infer A>] ? [left: Decoder<E>, right: Decoder<A>] : never): Decoder<A>;

package/global.d.ts

@@ -102,10 +102,6 @@ import { Datum } from "@fncts/base/data/Datum/definition";
  * @tsplus global
  */
 import { DatumEither } from "@fncts/base/data/DatumEither/definition";
-/**
- * @tsplus global
- */
-import { Decoder } from "@fncts/base/data/Decoder/definition";
 /**
  * @tsplus global
  */
@@ -114,10 +110,6 @@ import { Duration } from "@fncts/base/data/Duration/definition";
  * @tsplus global
  */
 import { Either } from "@fncts/base/data/Either/definition";
-/**
- * @tsplus global
- */
-import { Encoder } from "@fncts/base/data/Encoder/definition";
 /**
  * @tsplus global
  */

package/json/EitherJson.d.ts

@@ -1,4 +1,3 @@
-import { Decoder } from "@fncts/base/data/Decoder/definition";
 export interface RightJson<A> {
     readonly _tag: "Right";
     readonly right: A;
@@ -17,8 +16,3 @@ export type EitherJson<E, A> = LeftJson<E> | RightJson<A>;
 export interface EitherJsonOps {
 }
 export declare const EitherJson: EitherJsonOps;
-/**
- * @tsplus static fncts.EitherJsonOps getDecoder
- * @tsplus location "@fncts/base/json/EitherJson"
- */
-export declare function getDecoder<E, A>(left: Decoder<E>, right: Decoder<A>): Decoder<EitherJson<E, A>>;

package/json/MaybeJson.d.ts

@@ -1,4 +1,3 @@
-import { Decoder } from "@fncts/base/data/Decoder/definition";
 export interface NothingJson {
     readonly _tag: "Nothing";
 }
@@ -16,8 +15,3 @@ export type MaybeJson<A> = NothingJson | JustJson<A>;
 export interface MaybeJsonOps {
 }
 export declare const MaybeJson: MaybeJsonOps;
-/**
- * @tsplus static fncts.MaybeJsonOps getDecoder
- * @tsplus location "@fncts/base/json/MaybeJson"
- */
-export declare function getDecoder<A>(value: Decoder<A>): Decoder<MaybeJson<A>>;

package/json/TheseJson.d.ts

@@ -1,4 +1,3 @@
-import { Decoder } from "@fncts/base/data/Decoder/definition";
 export interface LeftJson<E> {
     readonly _tag: "Left";
     readonly left: E;
@@ -19,8 +18,3 @@ export type TheseJson<E, A> = LeftJson<E> | RightJson<A> | BothJson<E, A>;
 export interface TheseJsonOps {
 }
 export declare const TheseJson: TheseJsonOps;
-/**
- * @tsplus static fncts.TheseJsonOps getDecoder
- * @tsplus location "@fncts/base/json/TheseJson"
- */
-export declare function getDecoder<E, A>(left: Decoder<E>, right: Decoder<A>): Decoder<TheseJson<E, A>>;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@fncts/base",
-  "version": "0.0.34",
+  "version": "0.0.35",
   "dependencies": {
-    "@fncts/typelevel": "0.0.17",
+    "@fncts/typelevel": "0.0.18",
     "uuid": "^9.0.1"
   },
   "exports": {