@fncts/base 0.0.31 → 0.0.32

package/_mjs/typeclass/MonadExcept.mjs.map

@@ -1 +1 @@
-{"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"}
+{"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"}

package/_src/collection/compat/Array/api.ts

@@ -1,4 +1,5 @@
 import type { Eq } from "@fncts/base/typeclass";
+
 /**
  * @tsplus getter fncts.Array elem
  * @tsplus getter fncts.ReadonlyArray elem
@@ -15,6 +16,41 @@ export function elem<A>(self: ReadonlyArray<A>) {
     };
 }
 
+/**
+ * @tsplus pipeable fncts.Array filterMap
+ * @tsplus pipeable fncts.ReadonlyArray filterMap
+ */
+export function filterMap<A, B>(f: (a: A) => Maybe<B>) {
+  return (self: ReadonlyArray<A>): ReadonlyArray<B> => {
+    const out: Array<B> = [];
+    for (let i = 0; i < self.length; i++) {
+      const v = f(self[i]!);
+      Maybe.concrete(v);
+      if (v._tag === MaybeTag.Just) {
+        out.push(v.value);
+      }
+    }
+    return out;
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.Array filterMap
+ * @tsplus pipeable fncts.ReadonlyArray filterMap
+ */
+export function filterMapUndefined<A, B>(f: (a: A) => B | undefined) {
+  return (self: ReadonlyArray<A>): ReadonlyArray<B> => {
+    const out: Array<B> = [];
+    for (let i = 0; i < self.length; i++) {
+      const v = f(self[i]!);
+      if (v !== undefined) {
+        out.push(v);
+      }
+    }
+    return out;
+  };
+}
+
 /**
  * @tsplus fluent fncts.Array isEmpty
  * @tsplus fluent fncts.ReadonlyArray isEmpty
@@ -54,3 +90,18 @@ export function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B) {
     return out;
   };
 }
+
+/**
+ * @tsplus pipeable fncts.Array updateAt
+ * @tsplus pipeable fncts.ReadonlyArray updateAt
+ */
+export function updateAt<A>(i: number, a: A) {
+  return (self: ReadonlyArray<A>): ReadonlyArray<A> => {
+    if (i in self) {
+      const copy = self.slice();
+      copy[i]    = a;
+      return copy;
+    }
+    return self;
+  };
+}

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

@@ -864,10 +864,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(
-          (b) => left.append(b),
-          (c) => right.append(c),
-        );
+        eab.match({
+          Left: (b) => left.append(b),
+          Right: (c) => right.append(c),
+        });
         i++;
       }
     }

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

@@ -32,6 +32,38 @@ export function get(key: string) {
   };
 }
 
+/**
+ * @tsplus pipeable fncts.Dictionary set
+ */
+export function set<A>(key: string, value: A) {
+  return (self: Dictionary<A>): Dictionary<A> => {
+    return Dictionary({ ...self.toRecord, [key]: value });
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.Dictionary remove
+ */
+export function remove(key: string) {
+  return <A>(self: Dictionary<A>): Dictionary<A> => {
+    const out = { ...self.toRecord };
+    delete out[key];
+    return Dictionary(out);
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.Dictionary update
+ */
+export function update<A>(key: string, f: (a: Maybe<A>) => Maybe<A>) {
+  return (self: Dictionary<A>): Dictionary<A> => {
+    return f(self.get(key)).match(
+      () => self.remove(key),
+      (a) => self.set(key, a),
+    );
+  };
+}
+
 /**
  * @tsplus getter fncts.Dictionary keys
  */
@@ -64,6 +96,14 @@ export function mapWithIndex<A, B>(f: (k: string, a: A) => B) {
   };
 }
 
+/**
+ * @tsplus static fncts.DictionaryOps __call
+ * @tsplus macro identity
+ */
+export function fromRecord<A>(self: Record<string, A>): Dictionary<A> {
+  return Dictionary.get(self);
+}
+
 /**
  * @tsplus getter fncts.Dictionary toRecord
  * @tsplus macro identity

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(
-        (a) => {
+      f(k, v).match({
+        Left: (a) => {
           left.set(k, a);
         },
-        (b) => {
+        Right: (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(
-        (b) => {
+      f(v).match({
+        Left: (b) => {
           left.add(b);
         },
-        (c) => {
+        Right: (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(
-                (b1) => {
+              eb.match({
+                Left: (b1) => {
                   r[0].push(b1);
                   return r;
                 },
-                (b2) => {
+                Right: (b2) => {
                   r[1].push(b2);
                   return r;
                 },
-              ),
+              }),
             ),
           ),
         )

package/_src/collection/mutable/ArrayDeque.ts

@@ -0,0 +1,231 @@
+const STABLE_SIZE          = 128;
+const DEFAULT_INITIAL_SIZE = 16;
+
+/**
+ * @tsplus type fncts.MutableArrayDeque
+ * @tsplus companion fncts.MutableArrayDeque
+ */
+export class ArrayDeque<A> {
+  constructor(protected array: Array<A>, private start: number, private end: number) {}
+
+  static empty<A>(initialSize = DEFAULT_INITIAL_SIZE): ArrayDeque<A> {
+    return new ArrayDeque(new Array(initialSize), 0, 0);
+  }
+
+  protected requireBounds(idx: number, until: number = this.length) {
+    if (idx < 0 || idx > until) throw new IndexOutOfBoundsError(`${idx} is out of bounds (min 0, max ${until - 1})`);
+  }
+
+  get(idx: number): A {
+    this.requireBounds(idx);
+    return this._get(idx);
+  }
+
+  update(idx: number, elem: A): void {
+    this.requireBounds(idx);
+    this._set(idx, elem);
+  }
+
+  addOne(elem: A): this {
+    this.ensureSize(this.length + 1);
+    return this.appendAssumingCapacity(elem);
+  }
+
+  prepend(elem: A): this {
+    this.ensureSize(this.length + 1);
+    return this.prependAssumingCapacity(elem);
+  }
+
+  insert(idx: number, elem: A): void {
+    this.requireBounds(idx, this.length + 1);
+    const n = this.length;
+    if (idx === 0) {
+      this.prepend(elem);
+    } else if (idx === n) {
+      this.addOne(elem);
+    } else {
+      const finalLength = n + 1;
+      if (this.mustGrow(finalLength)) {
+        const array2 = new Array(finalLength);
+        this.copySliceToArray(0, array2, 0, idx);
+        array2[idx] = elem;
+        this.copySliceToArray(idx, array2, idx + 1, n);
+        this.reset(array2, 0, finalLength);
+      } else if (n <= idx * 2) {
+        let i = n - 1;
+        for (; i >= idx; i--) {
+          this._set(i + 1, this._get(i));
+        }
+        this.end = this.end_plus(1);
+        i       += 1;
+        this._set(i, elem);
+      } else {
+        let i = 0;
+        for (; i < idx; i++) {
+          this._set(i - 1, this._get(1));
+        }
+        this.start = this.start_minus(1);
+        this._set(i, elem);
+      }
+    }
+  }
+
+  remove(idx: number, count: number): void {
+    if (count > 0) {
+      this.requireBounds(idx);
+      const n           = this.length;
+      const removals    = Math.min(n - idx, count);
+      const finalLength = n - removals;
+      const suffixStart = idx + removals;
+      if (this.shouldShrink(finalLength)) {
+        const array2 = new Array(finalLength);
+        this.copySliceToArray(0, array2, 0, idx);
+        this.copySliceToArray(suffixStart, array2, idx, n);
+        this.reset(array2, 0, finalLength);
+      } else if (2 * idx <= finalLength) {
+        let i = suffixStart - 1;
+        for (; i >= removals; i--) {
+          this._set(i, this._get(i - removals));
+        }
+        for (; i >= 0; i--) {
+          this._set(i, null!);
+        }
+        this.start = this.start_plus(removals);
+      } else {
+        let i = idx;
+        for (; i < finalLength; i++) {
+          this._set(i, this._get(i + removals));
+        }
+        for (; i < n; i++) {
+          this._set(i, null!);
+        }
+        this.end = this.end_minus(removals);
+      }
+    } else if (count < 0) {
+      throw new Error(`Removing negative number of elements ${count}`);
+    }
+  }
+
+  removeHead(resizeInternalRepr = false): A {
+    if (this.isEmpty) throw new NoSuchElementError("empty collection");
+    else return this.removeHeadAssumingNonEmpty(resizeInternalRepr);
+  }
+
+  removeHeadOption(resizeInternalRepr = false): Maybe<A> {
+    if (this.isEmpty) return Nothing();
+    else return Just(this.removeHeadAssumingNonEmpty(resizeInternalRepr));
+  }
+
+  removeLastOption(resizeInternalRepr = false): Maybe<A> {
+    if (this.isEmpty) return Nothing();
+    else return Just(this.removeLastAssumingNonEmpty(resizeInternalRepr));
+  }
+
+  get isEmpty(): boolean {
+    return this.length === 0;
+  }
+
+  private removeHeadAssumingNonEmpty(resizeInternalRepr = false): A {
+    const elem             = this.array[this.start];
+    this.array[this.start] = null!;
+    this.start             = this.start_plus(1);
+    if (resizeInternalRepr) this.resize(this.length);
+    return elem!;
+  }
+
+  private removeLastAssumingNonEmpty(resizeInternalRepr = false): A {
+    this.end             = this.end_minus(1);
+    const elem           = this.array[this.end];
+    this.array[this.end] = null!;
+    if (resizeInternalRepr) this.resize(this.length);
+    return elem!;
+  }
+
+  protected prependAssumingCapacity(elem: A): this {
+    this.start             = this.start_minus(1);
+    this.array[this.start] = elem;
+    return this;
+  }
+
+  protected appendAssumingCapacity(elem: A): this {
+    this.array[this.end] = elem;
+    this.end             = this.end_plus(1);
+    return this;
+  }
+
+  private ensureSize(hint: number) {
+    if (hint > this.length && this.mustGrow(hint)) {
+      this.resize(hint);
+    }
+  }
+
+  private resize(len: number) {
+    const n      = this.length;
+    const array2 = this.copySliceToArray(0, new Array(len), 0, n);
+    this.reset(array2, 0, n);
+  }
+
+  private reset(array: Array<A>, start: number, end: number) {
+    this.requireBounds(start, array.length);
+    this.requireBounds(end, array.length);
+    this.array = array;
+    this.start = start;
+    this.end   = end;
+  }
+
+  private mustGrow(len: number) {
+    return len >= this.array.length;
+  }
+
+  protected start_plus(idx: number) {
+    return (this.start + idx) & (this.array.length - 1);
+  }
+
+  private start_minus(idx: number) {
+    return (this.start - idx) & (this.array.length - 1);
+  }
+
+  private end_plus(idx: number) {
+    return (this.end + idx) & (this.array.length - 1);
+  }
+
+  private end_minus(idx: number) {
+    return (this.end - idx) & (this.array.length - 1);
+  }
+
+  private _get(idx: number): A {
+    return this.array[this.start_plus(idx)]!;
+  }
+
+  private _set(idx: number, a: A): void {
+    this.array[this.start_plus(idx)] = a;
+  }
+
+  get length() {
+    return this.end_minus(this.start);
+  }
+
+  copySliceToArray(srcStart: number, dest: Array<A>, destStart: number, maxItems: number): Array<A> {
+    this.requireBounds(destStart, dest.length + 1);
+    const toCopy = Math.min(maxItems, Math.min(this.length - srcStart, dest.length - destStart));
+    if (toCopy > 0) {
+      this.requireBounds(srcStart);
+      const startIdx = this.start_plus(srcStart);
+      const block1   = Math.min(toCopy, this.array.length - startIdx);
+      copyArray(this.array, startIdx, dest, destStart, block1);
+      const block2 = toCopy - block1;
+      if (block2 > 0) copyArray(this.array, 0, dest, destStart + block1, block2);
+    }
+    return dest;
+  }
+
+  private shouldShrink(len: number) {
+    return this.array.length > STABLE_SIZE && this.array.length - len - (len >> 1) > len;
+  }
+}
+
+function copyArray<A>(src: Array<A>, srcPos: number, dest: Array<A>, destPos: number, length: number): void {
+  for (let i = srcPos, j = 0; j < length; i++, j++) {
+    dest[destPos + j] = src[i]!;
+  }
+}

package/_src/collection/mutable/Queue.ts

@@ -0,0 +1,14 @@
+import { ArrayDeque } from "@fncts/base/collection/mutable/ArrayDeque";
+
+/**
+ * @tsplus type fncts.MutableQueue
+ * @tsplus companion fncts.MutableQueue
+ */
+export class Queue<A> extends ArrayDeque<A> {
+  enqueue(elem: A): this {
+    return this.addOne(elem);
+  }
+  dequeue(): A {
+    return this.removeHead();
+  }
+}

package/_src/collection/mutable.ts

@@ -1,6 +1,8 @@
 // codegen:start { preset: type-barrel, include: ./mutable/*.ts }
+export type {} from "./mutable/ArrayDeque.js";
 export type {} from "./mutable/HashMap.js";
 export type {} from "./mutable/HashSet.js";
 export type {} from "./mutable/internal.js";
 export type {} from "./mutable/ListBuffer.js";
+export type {} from "./mutable/Queue.js";
 // codegen:end

package/_src/control/InterruptiblePromise.ts

@@ -0,0 +1,23 @@
+/**
+ * @tsplus type fncts.InterruptiblePromise
+ * @tsplus companion fncts.InterruptiblePromiseOps
+ */
+export interface InterruptiblePromise<A> extends Promise<A> {
+  interrupt: () => void;
+}
+
+/**
+ * @tsplus static fncts.InterruptiblePromiseOps __call
+ */
+export function make<A>(
+  executor: (resolve: (value: A | PromiseLike<A>) => void, reject: (reason?: unknown) => void) => (() => void) | void,
+): InterruptiblePromise<A> {
+  const promise: InterruptiblePromise<A> = new Promise((resolve, reject) => {
+    const canceller   = executor(resolve, reject);
+    promise.interrupt = () => {
+      canceller?.();
+      reject(new InterruptedException());
+    };
+  }) as InterruptiblePromise<A>;
+  return promise;
+}

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(Pure.failNow, Pure.succeedNow));
+  return fa.flatMap((ea) => ea.match({ Left: Pure.failNow, Right: Pure.succeedNow }));
 }
 
 /**
@@ -350,7 +350,10 @@ 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(onFailure, Pure.failCauseNow), onSuccess);
+    return fa.matchCausePure(
+      (cause) => cause.failureOrCause.match({ Left: onFailure, Right: Pure.failCauseNow }),
+      onSuccess,
+    );
   };
 }
 
@@ -378,7 +381,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((e) => onFailure(ws, e), Pure.failCauseNow),
+      (ws, cause) => cause.failureOrCause.match({ Left: (e) => onFailure(ws, e), Right: Pure.failCauseNow }),
       onSuccess,
     );
   };
@@ -428,7 +431,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(Pure.failNow, ([a, s2]) => Pure.succeedNow(a).mapState(() => s2)));
+    .flatMap((r) => r.match({ Left: Pure.failNow, Right: ([a, s2]) => Pure.succeedNow(a).mapState(() => s2) }));
 }
 
 /**

package/_src/data/Cause/api.ts

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

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(
-          (b) => [Refresh(b), Initial()],
-          (c) => [Initial(), Refresh(c)],
-        ),
+        f(a).match({
+          Left: (b) => [Refresh(b), Initial()],
+          Right: (c) => [Initial(), Refresh(c)],
+        }),
       Replete: (a) =>
-        f(a).match(
-          (b) => [Replete(b), Initial()],
-          (c) => [Initial(), Replete(c)],
-        ),
+        f(a).match({
+          Left: (b) => [Replete(b), Initial()],
+          Right: (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(
-          (b) => [DatumEither.refreshRight(b), DatumEither.initial()],
-          (c) => [DatumEither.initial(), DatumEither.refreshRight(c)],
-        ),
+        f(a).match({
+          Left: (b) => [DatumEither.refreshRight(b), DatumEither.initial()],
+          Right: (c) => [DatumEither.initial(), DatumEither.refreshRight(c)],
+        }),
       RepleteLeft: () => [self.unsafeCoerce(), self.unsafeCoerce()],
       RepleteRight: (a) =>
-        f(a).match(
-          (b) => [DatumEither.repleteRight(b), DatumEither.initial()],
-          (c) => [DatumEither.initial(), DatumEither.repleteRight(c)],
-        ),
+        f(a).match({
+          Left: (b) => [DatumEither.repleteRight(b), DatumEither.initial()],
+          Right: (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(
-    (e) => Just(e),
-    (_a) => Nothing(),
-  );
+  return self.match({
+    Left: (e) => Just(e),
+    Right: (_a) => Nothing(),
+  });
 }
 
 /**
  * @tsplus getter fncts.Either getRight
  */
 export function getRight<E, A>(self: Either<E, A>): Maybe<A> {
-  return self.match(
-    (_e) => Nothing(),
-    (a) => Just(a),
-  );
+  return self.match({
+    Left: (_e) => Nothing(),
+    Right: (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(orElse, identity);
+    return self.match({ Left: orElse, Right: 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(identity, identity);
+  return self.match({ Left: identity, Right: 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(
-        (e) => G.pure(Left(e)),
-        (a) => f(a).pipe(G.map((b) => Right(b))),
-      );
+      self.match({
+        Left: (e) => G.pure(Left(e)),
+        Right: (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(
-    () => Nothing(),
-    (a) => Just(a),
-  );
+  return self.match({
+    Left: () => Nothing(),
+    Right: (a) => Just(a),
+  });
 }
 
 // codegen:start { preset: barrel, include: api/*.ts }