@fncts/io 0.0.38 → 0.0.40

package/_src/IO.ts

@@ -1,68 +1,72 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: IO/*.ts }
-export * from "./IO/api.js";
-export * from "./IO/definition.js";
 export * from "./IO/runtime.js";
+export * from "./IO/definition.js";
+export * from "./IO/api.js";
 // codegen:end
 
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: IO/api/*.ts }
-export * from "./IO/api/acquireRelease.js";
-export * from "./IO/api/acquireReleaseExit.js";
-export * from "./IO/api/acquireReleaseInterruptible.js";
-export * from "./IO/api/acquireReleaseInterruptibleExit.js";
-export * from "./IO/api/addFinalizer.js";
-export * from "./IO/api/addFinalizerExit.js";
-export * from "./IO/api/all.js";
-export * from "./IO/api/asyncInterrupt.js";
-export * from "./IO/api/asyncIO.js";
-export * from "./IO/api/blocking.js";
-export * from "./IO/api/bracket.js";
-export * from "./IO/api/bracketExit.js";
-export * from "./IO/api/clockWith.js";
-export * from "./IO/api/concurrency.js";
-export * from "./IO/api/concurrentFinalizers.js";
-export * from "./IO/api/consoleWith.js";
-export * from "./IO/api/daemonChildren.js";
-export * from "./IO/api/delay.js";
-export * from "./IO/api/descriptor.js";
-export * from "./IO/api/disconnect.js";
-export * from "./IO/api/ensuringChildren.js";
-export * from "./IO/api/environment.js";
-export * from "./IO/api/foreachConcurrent.js";
-export * from "./IO/api/foreachExec.js";
-export * from "./IO/api/fork.js";
-export * from "./IO/api/forkAll.js";
-export * from "./IO/api/forkDaemon.js";
-export * from "./IO/api/forkIn.js";
-export * from "./IO/api/forkScoped.js";
-export * from "./IO/api/fulfill.js";
-export * from "./IO/api/interrupt.js";
-export * from "./IO/api/memoize.js";
-export * from "./IO/api/once.js";
-export * from "./IO/api/onTermination.js";
-export * from "./IO/api/provideLayer.js";
-export * from "./IO/api/provideScope.js";
-export * from "./IO/api/provideSomeLayer.js";
-export * from "./IO/api/race.js";
-export * from "./IO/api/raceFirst.js";
-export * from "./IO/api/raceWith.js";
-export * from "./IO/api/randomWith.js";
-export * from "./IO/api/repeat.js";
-export * from "./IO/api/retry.js";
-export * from "./IO/api/schedule.js";
-export * from "./IO/api/scope.js";
+export * from "./IO/api/zipConcurrent.js";
+export * from "./IO/api/withFinalizerExit.js";
+export * from "./IO/api/withFinalizer.js";
+export * from "./IO/api/withEarlyRelease.js";
+export * from "./IO/api/withChildren.js";
+export * from "./IO/api/whenRef.js";
+export * from "./IO/api/whenFiberRef.js";
+export * from "./IO/api/transplant.js";
+export * from "./IO/api/timeout.js";
+export * from "./IO/api/supervised.js";
+export * from "./IO/api/stateful.js";
+export * from "./IO/api/sleep.js";
+export * from "./IO/api/sequenceT.js";
 export * from "./IO/api/scoped.js";
 export * from "./IO/api/scopeWith.js";
-export * from "./IO/api/sequenceT.js";
-export * from "./IO/api/sleep.js";
-export * from "./IO/api/stateful.js";
-export * from "./IO/api/supervised.js";
-export * from "./IO/api/timeout.js";
-export * from "./IO/api/transplant.js";
-export * from "./IO/api/whenFiberRef.js";
-export * from "./IO/api/whenRef.js";
-export * from "./IO/api/withChildren.js";
-export * from "./IO/api/withEarlyRelease.js";
-export * from "./IO/api/withFinalizer.js";
-export * from "./IO/api/withFinalizerExit.js";
-export * from "./IO/api/zipConcurrent.js";
+export * from "./IO/api/scope.js";
+export * from "./IO/api/schedule.js";
+export * from "./IO/api/retry.js";
+export * from "./IO/api/repeat.js";
+export * from "./IO/api/randomWith.js";
+export * from "./IO/api/raceWith.js";
+export * from "./IO/api/raceFirst.js";
+export * from "./IO/api/race.js";
+export * from "./IO/api/provideSomeRuntime.js";
+export * from "./IO/api/provideSomeLayer.js";
+export * from "./IO/api/provideScope.js";
+export * from "./IO/api/provideLayer.js";
+export * from "./IO/api/patchFiberRefs.js";
+export * from "./IO/api/once.js";
+export * from "./IO/api/onTermination.js";
+export * from "./IO/api/memoize.js";
+export * from "./IO/api/interrupt.js";
+export * from "./IO/api/fulfill.js";
+export * from "./IO/api/forkScoped.js";
+export * from "./IO/api/forkIn.js";
+export * from "./IO/api/forkDaemon.js";
+export * from "./IO/api/forkAll.js";
+export * from "./IO/api/fork.js";
+export * from "./IO/api/foreachExec.js";
+export * from "./IO/api/foreachConcurrent.js";
+export * from "./IO/api/environment.js";
+export * from "./IO/api/ensuringChildren.js";
+export * from "./IO/api/disconnect.js";
+export * from "./IO/api/descriptor.js";
+export * from "./IO/api/delay.js";
+export * from "./IO/api/daemonChildren.js";
+export * from "./IO/api/consoleWith.js";
+export * from "./IO/api/concurrentFinalizers.js";
+export * from "./IO/api/concurrency.js";
+export * from "./IO/api/clockWith.js";
+export * from "./IO/api/bracketExit.js";
+export * from "./IO/api/bracket.js";
+export * from "./IO/api/blocking.js";
+export * from "./IO/api/asyncInterrupt.js";
+export * from "./IO/api/asyncIO.js";
+export * from "./IO/api/all.js";
+export * from "./IO/api/addFinalizerExit.js";
+export * from "./IO/api/addFinalizer.js";
+export * from "./IO/api/acquireReleaseInterruptibleExit.js";
+export * from "./IO/api/acquireReleaseInterruptible.js";
+export * from "./IO/api/acquireReleaseExit.js";
+export * from "./IO/api/acquireRelease.js";
 // codegen:end

package/_src/IOEnv.ts

@@ -1,5 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./IOEnv/*.ts }
-export * from "./IOEnv/definition.js";
-export * from "./IOEnv/live.js";
 export * from "./IOEnv/services.js";
+export * from "./IOEnv/live.js";
+export * from "./IOEnv/definition.js";
 // codegen:end

package/_src/InterruptStatus.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: InterruptStatus/*.ts }
-export * from "./InterruptStatus/constructors.js";
 export * from "./InterruptStatus/definition.js";
+export * from "./InterruptStatus/constructors.js";
 // codegen:end

package/_src/Layer/MemoMap.ts

@@ -165,9 +165,17 @@ export function scope(scope: Scope, __tsplusTrace?: string) {
       case LayerTag.ZipWithConcurrent: {
         return IO.succeed(
           () => (memoMap: MemoMap) =>
-            memoMap
-              .getOrElseMemoize(scope, layer.self, layer.trace)
-              .zipWithConcurrent(memoMap.getOrElseMemoize(scope, layer.that, layer.trace), layer.f, layer.trace),
+            Do((Δ) => {
+              const concurrent = Δ(scope.forkWith(ExecutionStrategy.concurrent));
+              const left       = Δ(concurrent.forkWith(scope.executionStrategy));
+              const right      = Δ(concurrent.forkWith(scope.executionStrategy));
+              const out        = Δ(
+                memoMap
+                  .getOrElseMemoize(left, layer.self, layer.trace)
+                  .zipWithConcurrent(memoMap.getOrElseMemoize(right, layer.that, layer.trace), layer.f, layer.trace),
+              );
+              return out;
+            }),
         );
       }
     }

package/_src/Layer/api.ts

@@ -1,4 +1,5 @@
 import type { Spreadable } from "@fncts/base/types";
+import type { Runtime } from "@fncts/io/IO";
 
 import { Fold, Fresh, FromScoped, Layer, To, ZipWithConcurrent } from "@fncts/io/Layer/definition";
 import { DecisionTag } from "@fncts/io/Schedule";
@@ -205,7 +206,10 @@ export function matchLayer<E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(
   __tsplusTrace?: string,
 ) {
   return <RIn>(self: Layer<RIn, E, ROut>): Layer<RIn | RIn1 | RIn2, E1 | E2, ROut1 | ROut2> => {
-    return self.matchCauseLayer((cause) => cause.failureOrCause.match(failure, Layer.failCauseNow), success);
+    return self.matchCauseLayer(
+      (cause) => cause.failureOrCause.match({ Left: failure, Right: Layer.failCauseNow }),
+      success,
+    );
   };
 }
 
@@ -399,3 +403,12 @@ export function using<RIn, E, ROut>(that: Layer<RIn, E, ROut>, __tsplusTrace?: s
     return new To(Layer(IO.environment<RIn1>(), __tsplusTrace).and(that), self);
   };
 }
+
+/**
+ * @tsplus getter fncts.io.Layer toRuntime
+ */
+export function toRuntime<RIn, E, ROut>(self: Layer<RIn, E, ROut>): IO<RIn | Scope, E, Runtime<ROut>> {
+  return IO.scopeWith((scope) => self.build(scope)).flatMap((environment) =>
+    IO.runtime<ROut>().provideEnvironment(environment),
+  );
+}

package/_src/Layer/definition.ts

@@ -67,28 +67,41 @@ export class Fold<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2> extends Layer<
 
 export class Fresh<RIn, E, ROut> extends Layer<RIn, E, ROut> {
   readonly _tag = LayerTag.Fresh;
-  constructor(readonly self: Layer<RIn, E, ROut>, readonly trace?: string) {
+  constructor(
+    readonly self: Layer<RIn, E, ROut>,
+    readonly trace?: string,
+  ) {
     super();
   }
 }
 
 export class FromScoped<RIn, E, ROut> extends Layer<Exclude<RIn, Scope>, E, ROut> {
   readonly _tag = LayerTag.Scoped;
-  constructor(readonly self: IO<RIn, E, Environment<ROut>>, readonly trace?: string) {
+  constructor(
+    readonly self: IO<RIn, E, Environment<ROut>>,
+    readonly trace?: string,
+  ) {
     super();
   }
 }
 
 export class Defer<RIn, E, ROut> extends Layer<RIn, E, ROut> {
   readonly _tag = LayerTag.Defer;
-  constructor(readonly self: () => Layer<RIn, E, ROut>, readonly trace?: string) {
+  constructor(
+    readonly self: () => Layer<RIn, E, ROut>,
+    readonly trace?: string,
+  ) {
     super();
   }
 }
 
 export class To<RIn, E, ROut, E1, ROut1> extends Layer<RIn, E | E1, ROut1> {
   readonly _tag = LayerTag.To;
-  constructor(readonly self: Layer<RIn, E, ROut>, readonly that: Layer<ROut, E1, ROut1>, readonly trace?: string) {
+  constructor(
+    readonly self: Layer<RIn, E, ROut>,
+    readonly that: Layer<ROut, E1, ROut1>,
+    readonly trace?: string,
+  ) {
     super();
   }
 }

package/_src/Layer.ts

@@ -1,5 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Layer/*.ts }
-export * from "./Layer/api.js";
 export * from "./Layer/definition.js";
+export * from "./Layer/api.js";
 export * from "./Layer/MemoMap.js";
 // codegen:end

package/_src/LogLevel.ts

@@ -3,7 +3,11 @@
  * @tsplus companion fncts.LogLevelOps
  */
 export class LogLevel {
-  constructor(readonly ordinal: number, readonly label: string, readonly syslog: number) {}
+  constructor(
+    readonly ordinal: number,
+    readonly label: string,
+    readonly syslog: number,
+  ) {}
 }
 
 /**

package/_src/LogSpan.ts

@@ -3,7 +3,10 @@
  * @tsplus companion fncts.LogSpanOps
  */
 export class LogSpan {
-  constructor(readonly label: string, readonly startTime: number) {}
+  constructor(
+    readonly label: string,
+    readonly startTime: number,
+  ) {}
 }
 
 /**

package/_src/Logger.ts

@@ -1,5 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Logger/*.ts }
-export * from "./Logger/api.js";
-export * from "./Logger/constructors.js";
 export * from "./Logger/definition.js";
+export * from "./Logger/constructors.js";
+export * from "./Logger/api.js";
 // codegen:end

package/_src/MVar.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./MVar/*.ts }
-export * from "./MVar/api.js";
 export * from "./MVar/definition.js";
+export * from "./MVar/api.js";
 // codegen:end

package/_src/Push/api.ts

@@ -36,10 +36,10 @@ export function asyncInterrupt<R, E, A>(
         };
         const eitherPush = Δ(IO(make(unsafeSink)));
         Δ(
-          eitherPush.match(
-            (canceller) => future.await.onInterrupt(canceller),
-            (push) => push.run(sink),
-          ),
+          eitherPush.match({
+            Left: (canceller) => future.await.onInterrupt(canceller),
+            Right: (push) => push.run(sink),
+          }),
         );
       }).scoped,
   );

package/_src/Push.ts

@@ -1,5 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Push/*.ts }
-export * from "./Push/api.js";
-export * from "./Push/definition.js";
 export * from "./Push/internal.js";
+export * from "./Push/definition.js";
+export * from "./Push/api.js";
 // codegen:end

package/_src/Queue/api/dimapIO.ts

@@ -140,7 +140,10 @@ class ContramapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PEnqueueInternal<R
     readonly _A: (_: C) => void;
     readonly _B: (_: never) => B;
   };
-  constructor(readonly queue: PEnqueueInternal<RA, RB, EA, EB, A, B>, readonly f: (c: C) => IO<RC, EC, A>) {}
+  constructor(
+    readonly queue: PEnqueueInternal<RA, RB, EA, EB, A, B>,
+    readonly f: (c: C) => IO<RC, EC, A>,
+  ) {}
 
   awaitShutdown: UIO<void> = this.queue.awaitShutdown;
 
@@ -184,7 +187,10 @@ class MapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PDequeueInternal<RA, RB
     readonly _A: (_: A) => void;
     readonly _B: (_: never) => C;
   };
-  constructor(readonly queue: PDequeueInternal<RA, RB, EA, EB, A, B>, readonly f: (b: B) => IO<RC, EC, C>) {}
+  constructor(
+    readonly queue: PDequeueInternal<RA, RB, EA, EB, A, B>,
+    readonly f: (b: B) => IO<RC, EC, C>,
+  ) {}
 
   awaitShutdown: UIO<void> = this.queue.awaitShutdown;
 

package/_src/Queue/api/filterInputIO.ts

@@ -3,7 +3,10 @@ import type { PEnqueue, PEnqueueInternal } from "@fncts/io/Queue/definition";
 import { concrete, EnqueueTypeId, QueueInternal, QueueTypeId, QueueVariance } from "@fncts/io/Queue/definition";
 
 class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends QueueInternal<RA | R2, RB, EA | E2, EB, A1, B> {
-  constructor(readonly queue: QueueInternal<RA, RB, EA, EB, A, B>, readonly f: (_: A1) => IO<R2, E2, boolean>) {
+  constructor(
+    readonly queue: QueueInternal<RA, RB, EA, EB, A, B>,
+    readonly f: (_: A1) => IO<R2, E2, boolean>,
+  ) {
     super();
   }
 
@@ -78,7 +81,10 @@ class FilterInputEnqueueIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2>
     readonly _A: (_: A1) => void;
     readonly _B: (_: never) => B;
   };
-  constructor(readonly queue: PEnqueueInternal<RA, RB, EA, EB, A, B>, readonly f: (_: A1) => IO<R2, E2, boolean>) {}
+  constructor(
+    readonly queue: PEnqueueInternal<RA, RB, EA, EB, A, B>,
+    readonly f: (_: A1) => IO<R2, E2, boolean>,
+  ) {}
 
   awaitShutdown: UIO<void> = this.queue.awaitShutdown;
 

package/_src/Queue/api/filterOutputIO.ts

@@ -3,7 +3,10 @@ import type { PDequeue, PDequeueInternal } from "@fncts/io/Queue/definition";
 import { concrete, DequeueTypeId, QueueInternal, QueueTypeId, QueueVariance } from "@fncts/io/Queue/definition";
 
 class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInternal<RA, RB | RB1, EA, EB | EB1, A, B> {
-  constructor(readonly queue: QueueInternal<RA, RB, EA, EB, A, B>, readonly f: (b: B) => IO<RB1, EB1, boolean>) {
+  constructor(
+    readonly queue: QueueInternal<RA, RB, EA, EB, A, B>,
+    readonly f: (b: B) => IO<RB1, EB1, boolean>,
+  ) {
     super();
   }
 
@@ -86,7 +89,10 @@ class FilterOutputDequeueIO<RA, RB, EA, EB, A, B, RB1, EB1>
     readonly _A: (_: A) => void;
     readonly _B: (_: never) => B;
   };
-  constructor(readonly queue: PDequeueInternal<RA, RB, EA, EB, A, B>, readonly f: (b: B) => IO<RB1, EB1, boolean>) {}
+  constructor(
+    readonly queue: PDequeueInternal<RA, RB, EA, EB, A, B>,
+    readonly f: (b: B) => IO<RB1, EB1, boolean>,
+  ) {}
 
   awaitShutdown: UIO<void> = this.queue.awaitShutdown;
 

package/_src/Queue/api/operations.ts

@@ -131,9 +131,9 @@ export function takeAll<RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, EB, A,
 /**
  * Takes up to max number of values in the queue.
  *
- * @tsplus pipeable fncts.io.Queue takeAllUpTo
+ * @tsplus pipeable fncts.io.Queue takeUpTo
  */
-export function takeAllUpTo(n: number, __tsplusTrace?: string) {
+export function takeUpTo(n: number, __tsplusTrace?: string) {
   return <RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>) => {
     concrete(queue);
     return queue.takeUpTo(n);

package/_src/Queue/api/takeBetween.ts

@@ -11,34 +11,32 @@ import { concrete } from "@fncts/io/Queue/definition";
  */
 export function takeBetween(min: number, max: number, __tsplusTrace?: string) {
   return <RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, EB, A, B>): IO<RB, EB, Conc<B>> => {
-    concrete(queue);
-    if (max < min) {
-      return IO.succeedNow(Conc.empty());
-    } else {
-      return queue.takeUpTo(max).flatMap((bs) => {
-        const remaining = min - bs.length;
-
-        if (remaining === 1) {
-          return queue.take.map((b) => bs.prepend(b));
-        } else if (remaining > 1) {
-          return takeRemainderLoop(queue, remaining - 1).map((list) => bs.concat(list));
-        } else {
-          return IO.succeedNow(bs);
-        }
-      });
-    }
+    return takeRemainderLoop(queue, min, max, Conc.empty());
   };
 }
 
 function takeRemainderLoop<RA, RB, EA, EB, A, B>(
   queue: PDequeue<RA, RB, EA, EB, A, B>,
-  n: number,
+  min: number,
+  max: number,
+  acc: Conc<B>,
   __tsplusTrace?: string,
 ): IO<RB, EB, Conc<B>> {
   concrete(queue);
-  if (n <= 0) {
-    return IO.succeedNow(Conc.empty());
+  if (max < min) {
+    return IO.succeedNow(acc);
   } else {
-    return queue.take.flatMap((b) => takeRemainderLoop(queue, n - 1).map((out) => out.prepend(b)));
+    return queue.takeUpTo(max).flatMap((bs) => {
+      const remaining = min - bs.length;
+      if (remaining === 1) {
+        return queue.take.map((b) => acc.concat(bs).append(b));
+      } else if (remaining > 1) {
+        return queue.take.flatMap((b) =>
+          takeRemainderLoop(queue, remaining - 1, max - bs.length - 1, acc.concat(bs).append(b)),
+        );
+      } else {
+        return IO.succeed(acc.concat(bs));
+      }
+    });
   }
 }

package/_src/Queue/api/takeN.ts

@@ -0,0 +1,10 @@
+import type { PDequeue } from "@fncts/io/Queue";
+
+/**
+ * @tsplus pipeable fncts.io.Queue takeN
+ */
+export function takeN(n: number, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, EB, A, B>): IO<RB, EB, Conc<B>> => {
+    return queue.takeBetween(n, n);
+  };
+}

package/_src/Queue/api.ts

@@ -1,9 +1,11 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: api/*.ts }
-export * from "./api/dimapIO.js";
-export * from "./api/filterInputIO.js";
-export * from "./api/filterOutputIO.js";
-export * from "./api/operations.js";
-export * from "./api/poll.js";
-export * from "./api/takeBetween.js";
 export * from "./api/zipWithIO.js";
+export * from "./api/takeN.js";
+export * from "./api/takeBetween.js";
+export * from "./api/poll.js";
+export * from "./api/operations.js";
+export * from "./api/filterOutputIO.js";
+export * from "./api/filterInputIO.js";
+export * from "./api/dimapIO.js";
 // codegen:end

package/_src/Queue/internal.ts

@@ -184,7 +184,10 @@ export function unsafeCompletePromise<A>(p: Future<never, A>, a: A) {
 }
 
 export function unsafeRemove<A>(q: MutableQueue<A>, a: A) {
-  return unsafeOfferAll(q, unsafePollAll(q)).filter((b) => a !== b);
+  return unsafeOfferAll(
+    q,
+    unsafePollAll(q).filter((b) => a !== b),
+  );
 }
 
 function unsafeDequeueN<A>(q: MutableQueue<A>, max: number): Conc<A> {

package/_src/Queue.ts

@@ -1,7 +1,8 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Queue/*.ts }
-export * from "./Queue/api.js";
-export * from "./Queue/constructors.js";
-export * from "./Queue/definition.js";
-export * from "./Queue/internal.js";
 export * from "./Queue/strategy.js";
+export * from "./Queue/internal.js";
+export * from "./Queue/definition.js";
+export * from "./Queue/constructors.js";
+export * from "./Queue/api.js";
 // codegen:end

package/_src/Random.ts

@@ -1,5 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Random/*.ts }
-export * from "./Random/api.js";
-export * from "./Random/definition.js";
 export * from "./Random/live.js";
+export * from "./Random/definition.js";
+export * from "./Random/api.js";
 // codegen:end

package/_src/Ref/Derived.ts

@@ -35,8 +35,8 @@ export class Derived<EA, EB, A, B> extends RefInternal<never, never, EA, EB, A,
         new Derived<EC, ED, C, D>((f) =>
           f(
             value,
-            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
-            (c) => ca(c).flatMap((a) => setEither(a).match((e) => Either.left(ea(e)), Either.right)),
+            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
+            (c) => ca(c).flatMap((a) => setEither(a).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
           ),
         ),
     );
@@ -54,41 +54,43 @@ export class Derived<EA, EB, A, B> extends RefInternal<never, never, EA, EB, A,
         new DerivedAll<EC, ED, C, D>((f) =>
           f(
             value,
-            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
+            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
             (c) => (s) =>
               getEither(s)
-                .match(
-                  (eb) => Either.left(ec(eb)),
-                  (b) => ca(c)(b),
-                )
-                .flatMap((a) => setEither(a).match((e) => Either.left(ea(e)), Either.right)),
+                .match({
+                  Left: (eb) => Either.left(ec(eb)),
+                  Right: (b) => ca(c)(b),
+                })
+                .flatMap((a) => setEither(a).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
           ),
         ),
     );
   }
 
   get get(): FIO<EB, B> {
-    return this.use((value, getEither) => value.get.flatMap((s) => getEither(s).match(IO.failNow, IO.succeedNow)));
+    return this.use((value, getEither) =>
+      value.get.flatMap((s) => getEither(s).match({ Left: IO.failNow, Right: IO.succeedNow })),
+    );
   }
 
   set(a: A): FIO<EA, void> {
-    return this.use((value, _, setEither) => setEither(a).match(IO.failNow, (s) => value.set(s)));
+    return this.use((value, _, setEither) => setEither(a).match({ Left: IO.failNow, Right: (s) => value.set(s) }));
   }
 
   modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): IO<never, EA | EB, C> {
     return this.use(
       (value, getEither, setEither) =>
         value.modify((s) =>
-          getEither(s).match(
-            (e) => tuple(Either.left(e), s),
-            (a1) => {
+          getEither(s).match({
+            Left: (e) => tuple(Either.left(e), s),
+            Right: (a1) => {
               const [b, a2] = f(a1);
-              return setEither(a2).match(
-                (e) => tuple(Either.left(e), s),
-                (s) => tuple(Either.right<EA | EB, C>(b), s),
-              );
+              return setEither(a2).match({
+                Left: (e) => tuple(Either.left(e), s),
+                Right: (s) => tuple(Either.right<EA | EB, C>(b), s),
+              });
             },
-          ),
+          }),
         ).absolve,
     );
   }