@fncts/io 0.0.42 → 0.0.43

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({ 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 })),
+            (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)),
           ),
         ),
     );
@@ -54,43 +54,41 @@ 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({ Left: (e) => Either.left(eb(e)), Right: bd }),
+            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
             (c) => (s) =>
               getEither(s)
-                .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 })),
+                .match(
+                  (eb) => Either.left(ec(eb)),
+                  (b) => ca(c)(b),
+                )
+                .flatMap((a) => setEither(a).match((e) => Either.left(ea(e)), Either.right)),
           ),
         ),
     );
   }
 
   get get(): FIO<EB, B> {
-    return this.use((value, getEither) =>
-      value.get.flatMap((s) => getEither(s).match({ Left: IO.failNow, Right: IO.succeedNow })),
-    );
+    return this.use((value, getEither) => value.get.flatMap((s) => getEither(s).match(IO.failNow, IO.succeedNow)));
   }
 
   set(a: A): FIO<EA, void> {
-    return this.use((value, _, setEither) => setEither(a).match({ Left: IO.failNow, Right: (s) => value.set(s) }));
+    return this.use((value, _, setEither) => setEither(a).match(IO.failNow, (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({
-            Left: (e) => tuple(Either.left(e), s),
-            Right: (a1) => {
+          getEither(s).match(
+            (e) => tuple(Either.left(e), s),
+            (a1) => {
               const [b, a2] = f(a1);
-              return setEither(a2).match({
-                Left: (e) => tuple(Either.left(e), s),
-                Right: (s) => tuple(Either.right<EA | EB, C>(b), s),
-              });
+              return setEither(a2).match(
+                (e) => tuple(Either.left(e), s),
+                (s) => tuple(Either.right<EA | EB, C>(b), s),
+              );
             },
-          }),
+          ),
         ).absolve,
     );
   }

package/_src/Ref/DerivedAll.ts

@@ -34,9 +34,8 @@ export class DerivedAll<EA, EB, A, B> extends RefInternal<never, never, EA, EB,
         new DerivedAll((f) =>
           f(
             value,
-            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
-            (c) => (s) =>
-              ca(c).flatMap((a) => setEither(a)(s).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
+            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
+            (c) => (s) => ca(c).flatMap((a) => setEither(a)(s).match((e) => Either.left(ea(e)), Either.right)),
           ),
         ),
     );
@@ -54,30 +53,28 @@ export class DerivedAll<EA, EB, A, B> extends RefInternal<never, never, EA, EB,
         new DerivedAll((f) =>
           f(
             value,
-            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
+            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
             (c) => (s) =>
               getEither(s)
-                .match({ Left: (e) => Either.left(ec(e)), Right: ca(c) })
-                .flatMap((a) => setEither(a)(s).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
+                .match((e) => Either.left(ec(e)), ca(c))
+                .flatMap((a) => setEither(a)(s).match((e) => Either.left(ea(e)), Either.right)),
           ),
         ),
     );
   }
 
   get get(): FIO<EB, B> {
-    return this.use((value, getEither) =>
-      value.get.flatMap((s) => getEither(s).match({ Left: IO.failNow, Right: IO.succeedNow })),
-    );
+    return this.use((value, getEither) => value.get.flatMap((s) => getEither(s).match(IO.failNow, IO.succeedNow)));
   }
 
   set(a: A): FIO<EA, void> {
     return this.use(
       (value, _, setEither) =>
         value.modify((s) =>
-          setEither(a)(s).match({
-            Left: (e) => [Either.left(e), s] as [Either<EA, void>, typeof s],
-            Right: (s) => [Either.right(undefined), s],
-          }),
+          setEither(a)(s).match(
+            (e) => [Either.left(e), s] as [Either<EA, void>, typeof s],
+            (s) => [Either.right(undefined), s],
+          ),
         ).absolve,
     );
   }
@@ -86,16 +83,16 @@ export class DerivedAll<EA, EB, A, B> extends RefInternal<never, never, EA, EB,
     return this.use(
       (value, getEither, setEither) =>
         value.modify((s) =>
-          getEither(s).match({
-            Left: (e) => tuple(Either.left(e), s),
-            Right: (a1) => {
+          getEither(s).match(
+            (e) => tuple(Either.left(e), s),
+            (a1) => {
               const [b, a2] = f(a1);
-              return setEither(a2)(s).match({
-                Left: (e) => tuple(Either.left(e), s),
-                Right: (s) => tuple(Either.right<EA | EB, C>(b), s),
-              });
+              return setEither(a2)(s).match(
+                (e) => tuple(Either.left(e), s),
+                (s) => tuple(Either.right<EA | EB, C>(b), s),
+              );
             },
-          }),
+          ),
         ).absolve,
     );
   }

package/_src/STM/api/core-api.ts

@@ -65,6 +65,6 @@ export function matchSTM<E, A, R1, E1, B, R2, E2, C>(
     return self
       .map(Either.right)
       .catchAll((e) => g(e).map(Either.left))
-      .flatMap((ca) => ca.match({ Left: STM.succeedNow, Right: f }));
+      .flatMap((ca) => ca.match(STM.succeedNow, f));
   };
 }

package/_src/STM/api.ts

@@ -429,7 +429,7 @@ export function foreach<A, R, E, B>(
  * @tsplus static fncts.io.STMOps fromEither
  */
 export function fromEither<E, A>(e: Lazy<Either<E, A>>, __tsplusTrace?: string): STM<never, E, A> {
-  return STM.defer(e().match({ Left: STM.failNow, Right: STM.succeedNow }));
+  return STM.defer(e().match(STM.failNow, STM.succeedNow));
 }
 
 /**
@@ -438,7 +438,7 @@ export function fromEither<E, A>(e: Lazy<Either<E, A>>, __tsplusTrace?: string):
  * @tsplus static fncts.io.STMOps fromEitherNow
  */
 export function fromEitherNow<E, A>(e: Either<E, A>, __tsplusTrace?: string): STM<never, E, A> {
-  return e.match({ Left: STM.failNow, Right: STM.succeedNow });
+  return e.match(STM.failNow, STM.succeedNow);
 }
 
 /**
@@ -553,7 +553,7 @@ export function isSuccess<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string) {
 export function left<R, E, B, C>(stm: STM<R, E, Either<B, C>>, __tsplusTrace?: string): STM<R, Maybe<E>, B> {
   return stm.matchSTM(
     (e) => STM.fail(Just(e)),
-    (bc) => bc.match({ Left: STM.succeedNow, Right: () => STM.failNow(Nothing()) }),
+    (bc) => bc.match(STM.succeedNow, () => STM.failNow(Nothing())),
   );
 }
 
@@ -564,7 +564,7 @@ export function left<R, E, B, C>(stm: STM<R, E, Either<B, C>>, __tsplusTrace?: s
  */
 export function leftOrFail<C, E1>(orFail: (c: C) => E1, __tsplusTrace?: string) {
   return <R, E, B>(stm: STM<R, E, Either<B, C>>): STM<R, E | E1, B> => {
-    return stm.flatMap((bc) => bc.match({ Left: STM.succeedNow, Right: (c) => STM.fail(orFail(c)) }));
+    return stm.flatMap((bc) => bc.match(STM.succeedNow, (c) => STM.fail(orFail(c))));
   };
 }
 

package/_src/Schedule/api.ts

@@ -618,17 +618,17 @@ export function reconsiderIO<S, O, R1, O1>(
         decision.match(
           () =>
             f(state, out, decision).map((r) =>
-              r.match({
-                Left: (out1) => [state, out1, Decision.Done],
-                Right: ([out1, _]) => [state, out1, Decision.Done],
-              }),
+              r.match(
+                (out1) => [state, out1, Decision.Done],
+                ([out1, _]) => [state, out1, Decision.Done],
+              ),
             ),
           () =>
             f(state, out, decision).map((r) =>
-              r.match({
-                Left: (out1) => [state, out1, Decision.Done],
-                Right: ([out1, interval]) => [state, out1, Decision.continueWith(interval)],
-              }),
+              r.match(
+                (out1) => [state, out1, Decision.Done],
+                ([out1, interval]) => [state, out1, Decision.continueWith(interval)],
+              ),
             ),
         ),
       ),

package/_src/Sink/api.ts

@@ -567,20 +567,20 @@ function fromPushPull<R, E, In, L, Z>(
     (inp: Conc<In>) =>
       Channel.fromIO(push(Just(inp))).matchChannel(
         ([r, leftovers]) =>
-          r.match({
-            Left: (e) => Channel.writeNow(leftovers) > Channel.failNow(e),
-            Right: (z) => Channel.writeNow(leftovers) > Channel.succeedNow(z),
-          }),
+          r.match(
+            (e) => Channel.writeNow(leftovers) > Channel.failNow(e),
+            (z) => Channel.writeNow(leftovers) > Channel.succeedNow(z),
+          ),
         () => fromPushPull(push),
       ),
     Channel.failNow,
     () =>
       Channel.fromIO(push(Nothing())).matchChannel(
         ([r, leftovers]) =>
-          r.match({
-            Left: (e) => Channel.writeNow(leftovers) > Channel.failNow(e),
-            Right: (z) => Channel.writeNow(leftovers) > Channel.succeedNow(z),
-          }),
+          r.match(
+            (e) => Channel.writeNow(leftovers) > Channel.failNow(e),
+            (z) => Channel.writeNow(leftovers) > Channel.succeedNow(z),
+          ),
         () => Channel.fromIO(IO.halt(new Error("empty sink"))),
       ),
   );

package/_src/Stream/api/zipAllWith.ts

@@ -132,8 +132,8 @@ function zipWithChunks<A, B, C>(
   __tsplusTrace?: string,
 ): readonly [Conc<C>, State<A, B>] {
   const [out, r] = zipChunks(leftChunk, rightChunk, f);
-  return r.match({
-    Left: (leftChunk) => (leftChunk.isEmpty ? [out, new PullBoth()] : [out, new PullRight(leftChunk)]),
-    Right: (rightChunk) => (rightChunk.isEmpty ? [out, new PullBoth()] : [out, new PullLeft(rightChunk)]),
-  });
+  return r.match(
+    (leftChunk) => (leftChunk.isEmpty ? [out, new PullBoth()] : [out, new PullRight(leftChunk)]),
+    (rightChunk) => (rightChunk.isEmpty ? [out, new PullBoth()] : [out, new PullLeft(rightChunk)]),
+  );
 }

package/_src/Stream/api/zipWithChunks.ts

@@ -73,10 +73,10 @@ function handleSuccess<A1, A2, A3>(
   __tsplusTrace?: string,
 ): readonly [Conc<A3>, State<A1, A2>] {
   const [out, remaining] = f(leftChunk, rightChunk);
-  return remaining.match({
-    Left: (l) => (leftChunk.isEmpty ? [out, new PullBoth()] : [out, new PullRight(leftChunk)]),
-    Right: (r) => (rightChunk.isEmpty ? [out, new PullBoth()] : [out, new PullLeft(rightChunk)]),
-  });
+  return remaining.match(
+    (l) => (leftChunk.isEmpty ? [out, new PullBoth()] : [out, new PullRight(leftChunk)]),
+    (r) => (rightChunk.isEmpty ? [out, new PullBoth()] : [out, new PullLeft(rightChunk)]),
+  );
 }
 
 /**

package/_src/Stream/api.ts

@@ -3,7 +3,7 @@ import type { Canceler } from "../IO.js";
 import type { PDequeue, PEnqueue, PQueue } from "../Queue.js";
 import type { SinkEndReason } from "./internal/SinkEndReason.js";
 
-import { constVoid, identity, tuple } from "@fncts/base/data/function";
+import { identity, tuple } from "@fncts/base/data/function";
 
 import { MergeDecision } from "../Channel/internal/MergeDecision.js";
 import { Hub } from "../Hub.js";
@@ -56,9 +56,7 @@ export function aggregateAsyncWithin<R1, E1, A1, B, R2, C>(
   __tsplusTrace?: string,
 ) {
   return <R, E, A extends A1>(stream: Stream<R, E, A>): Stream<R | R1 | R2, E | E1, B> => {
-    return stream
-      .aggregateAsyncWithinEither(sink, schedule)
-      .filterMap((cb) => cb.match({ Left: () => Nothing(), Right: Maybe.just }));
+    return stream.aggregateAsyncWithinEither(sink, schedule).filterMap((cb) => cb.match(() => Nothing(), Maybe.just));
   };
 }
 
@@ -167,14 +165,14 @@ export function aggregateAsyncWithinEither<R1, E1, A1, B, R2, C>(
             (scheduleExit, sinkFiber) =>
               IO.fromExit(scheduleExit).matchCauseIO(
                 (cause) =>
-                  cause.failureOrCause.match({
-                    Left: () =>
+                  cause.failureOrCause.match(
+                    () =>
                       handoff.offer(HandoffSignal.End(new ScheduleEnd())).forkDaemon >
                       sinkFiber.join.map(([leftovers, b]) => handleSide(leftovers, b, Nothing())),
-                    Right: (cause) =>
+                    (cause) =>
                       handoff.offer(HandoffSignal.Halt(cause)).forkDaemon >
                       sinkFiber.join.map(([leftovers, b]) => handleSide(leftovers, b, Nothing())),
-                  }),
+                  ),
                 (c) =>
                   handoff.offer(HandoffSignal.End(new ScheduleEnd())).forkDaemon >
                   sinkFiber.join.map(([leftovers, b]) => handleSide(leftovers, b, Just(c))),
@@ -257,8 +255,8 @@ export function asyncInterrupt<R, E, A>(
           }),
         ),
       );
-      return eitherStream.match({
-        Left: (canceler) => {
+      return eitherStream.match(
+        (canceler) => {
           const loop: Channel<never, unknown, unknown, unknown, E, Conc<A>, void> = Channel.unwrap(
             output.take
               .flatMap((take) => take.done)
@@ -269,8 +267,8 @@ export function asyncInterrupt<R, E, A>(
           );
           return new Stream(loop).ensuring(canceler);
         },
-        Right: (stream) => Stream.unwrap(output.shutdown.as(stream)),
-      });
+        (stream) => Stream.unwrap(output.shutdown.as(stream)),
+      );
     }),
   );
 }
@@ -338,10 +336,10 @@ export function asyncIO<R, E, A, R1 = R, E1 = E>(
             .matchCauseIO(
               (cause) =>
                 output.shutdown.as(
-                  cause.failureOrCause.match({
-                    Left: (maybeError) => maybeError.match(() => Channel.endNow(undefined), Channel.failNow),
-                    Right: Channel.failCauseNow,
-                  }),
+                  cause.failureOrCause.match(
+                    (maybeError) => maybeError.match(() => Channel.endNow(undefined), Channel.failNow),
+                    Channel.failCauseNow,
+                  ),
                 ),
               (as) => IO.succeed(Channel.writeNow(as) > loop),
             ),
@@ -579,7 +577,7 @@ function bufferSignalConsumer<R, E, A>(
  */
 export function catchAll<R1, E, E1, A1>(f: (e: E) => Stream<R1, E1, A1>, __tsplusTrace?: string) {
   return <R, A>(stream: Stream<R, E, A>): Stream<R | R1, E1, A | A1> => {
-    return stream.catchAllCause((cause) => cause.failureOrCause.match({ Left: f, Right: Stream.failCauseNow }));
+    return stream.catchAllCause((cause) => cause.failureOrCause.match(f, Stream.failCauseNow));
   };
 }
 
@@ -3230,7 +3228,7 @@ export function toPull<R, E, A>(
   __tsplusTrace?: string,
 ): IO<R | Scope, never, IO<R, Maybe<E>, Conc<A>>> {
   return stream.channel.toPull.map((io) =>
-    io.mapError(Maybe.just).flatMap((r) => r.match({ Left: () => IO.failNow(Nothing()), Right: IO.succeedNow })),
+    io.mapError(Maybe.just).flatMap((r) => r.match(() => IO.failNow(Nothing()), IO.succeedNow)),
   );
 }
 
@@ -3487,22 +3485,22 @@ export function zipWithLatest<A, R1, E1, B, C>(fb: Stream<R1, E1, B>, f: (a: A,
                 Stream.repeatIOMaybe(left)
                   .mergeEither(Stream.repeatIOMaybe(right))
                   .mapIO((ab) =>
-                    ab.match({
-                      Left: (leftChunk) =>
+                    ab.match(
+                      (leftChunk) =>
                         latest.modify(([_, rightLatest]) =>
                           tuple(
                             leftChunk.map((a) => f(a, rightLatest)),
                             tuple(leftChunk.unsafeGet(leftChunk.length - 1), rightLatest),
                           ),
                         ),
-                      Right: (rightChunk) =>
+                      (rightChunk) =>
                         latest.modify(([leftLatest, _]) =>
                           tuple(
                             rightChunk.map((b) => f(leftLatest, b)),
                             tuple(leftLatest, rightChunk.unsafeGet(rightChunk.length - 1)),
                           ),
                         ),
-                    }),
+                    ),
                   )
                   .flatMap(Stream.fromChunkNow),
               ),

package/_src/TRef/definition.ts

@@ -162,8 +162,8 @@ export class Derived<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
       (getEither, setEither, value, atomic) =>
         new Derived((f) =>
           f(
-            (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 })),
+            (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)),
             value,
             atomic,
           ),
@@ -181,11 +181,11 @@ export class Derived<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
       (getEither, setEither, value, atomic) =>
         new DerivedAll((f) =>
           f(
-            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
+            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
             (c) => (s) =>
               getEither(s)
-                .match({ Left: (e) => Either.left(ec(e)), Right: ca(c) })
-                .flatMap((a) => setEither(a).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
+                .match((e) => Either.left(ec(e)), ca(c))
+                .flatMap((a) => setEither(a).match((e) => Either.left(ea(e)), Either.right)),
             value,
             atomic,
           ),
@@ -195,29 +195,27 @@ export class Derived<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
 
   get get(): STM<never, EB, B> {
     return this.use((getEither, _setEither, value, _atomic) =>
-      value.get.flatMap((s) => getEither(s).match({ Left: STM.failNow, Right: STM.succeedNow })),
+      value.get.flatMap((s) => getEither(s).match(STM.failNow, STM.succeedNow)),
     );
   }
 
   set(a: A, __tsplusTrace?: string | undefined): STM<never, EA, void> {
-    return this.use((_getEither, setEither, value, _atomic) =>
-      setEither(a).match({ Left: STM.failNow, Right: (s) => value.set(s) }),
-    );
+    return this.use((_getEither, setEither, value, _atomic) => setEither(a).match(STM.failNow, (s) => value.set(s)));
   }
 
   modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): STM<never, EA | EB, C> {
     return this.use((getEither, setEither, value, _atomic) =>
       value.modify((s) =>
-        getEither(s).match({
-          Left: (e) => [Either.left<EA | EB, C>(e), s],
-          Right: (a1) => {
+        getEither(s).match(
+          (e) => [Either.left<EA | EB, C>(e), s],
+          (a1) => {
             const [b, a2] = f(a1);
-            return setEither(a2).match({
-              Left: (e) => [Either.left(e), s],
-              Right: (s) => [Either.right(b), s],
-            });
+            return setEither(a2).match(
+              (e) => [Either.left(e), s],
+              (s) => [Either.right(b), s],
+            );
           },
-        }),
+        ),
       ),
     ).absolve;
   }
@@ -258,9 +256,8 @@ export class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
       (getEither, setEither, value, atomic) =>
         new DerivedAll((f) =>
           f(
-            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
-            (c) => (s) =>
-              ca(c).flatMap((a) => setEither(a)(s).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
+            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
+            (c) => (s) => ca(c).flatMap((a) => setEither(a)(s).match((e) => Either.left(ea(e)), Either.right)),
             value,
             atomic,
           ),
@@ -278,11 +275,11 @@ export class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
       (getEither, setEither, value, atomic) =>
         new DerivedAll((f) =>
           f(
-            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
+            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
             (c) => (s) =>
               getEither(s)
-                .match({ Left: (e) => Either.left(ec(e)), Right: ca(c) })
-                .flatMap((a) => setEither(a)(s).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
+                .match((e) => Either.left(ec(e)), ca(c))
+                .flatMap((a) => setEither(a)(s).match((e) => Either.left(ea(e)), Either.right)),
             value,
             atomic,
           ),
@@ -292,17 +289,17 @@ export class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
 
   get get(): STM<never, EB, B> {
     return this.use((getEither, _setEither, value, _atomic) =>
-      value.get.flatMap((s) => getEither(s).match({ Left: STM.failNow, Right: STM.succeedNow })),
+      value.get.flatMap((s) => getEither(s).match(STM.failNow, STM.succeedNow)),
     );
   }
 
   set(a: A, __tsplusTrace?: string | undefined): STM<never, EA, void> {
     return this.use((_getEither, setEither, value, _atomic) =>
       value.modify((s) =>
-        setEither(a)(s).match({
-          Left: (e) => [Either.left(e), s] as [Either<EA, void>, typeof s],
-          Right: (s) => [Either.right(undefined), s],
-        }),
+        setEither(a)(s).match(
+          (e) => [Either.left(e), s] as [Either<EA, void>, typeof s],
+          (s) => [Either.right(undefined), s],
+        ),
       ),
     ).absolve;
   }
@@ -310,16 +307,16 @@ export class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
   modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): STM<never, EA | EB, C> {
     return this.use((getEither, setEither, value, atomic) =>
       value.modify((s) =>
-        getEither(s).match({
-          Left: (e) => [Either.left<EA | EB, C>(e), s],
-          Right: (a1) => {
+        getEither(s).match(
+          (e) => [Either.left<EA | EB, C>(e), s],
+          (a1) => {
             const [b, a2] = f(a1);
-            return setEither(a2)(s).match({
-              Left: (e) => [Either.left(e), s],
-              Right: (s) => [Either.right(b), s],
-            });
+            return setEither(a2)(s).match(
+              (e) => [Either.left(e), s],
+              (s) => [Either.right(b), s],
+            );
           },
-        }),
+        ),
       ),
     ).absolve;
   }

package/_src/index.ts

@@ -38,6 +38,7 @@ export type {} from "./IO.js";
 export type {} from "./Hub.js";
 export type {} from "./Future.js";
 export type {} from "./FiberStatus.js";
+export type {} from "./FiberSet.js";
 export type {} from "./FiberScope.js";
 export type {} from "./FiberRefs.js";
 export type {} from "./FiberRef.js";

package/index.d.ts

@@ -36,6 +36,7 @@ export type {} from "./IO.js";
 export type {} from "./Hub.js";
 export type {} from "./Future.js";
 export type {} from "./FiberStatus.js";
+export type {} from "./FiberSet.js";
 export type {} from "./FiberScope.js";
 export type {} from "./FiberRefs.js";
 export type {} from "./FiberRef.js";

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@fncts/io",
-  "version": "0.0.42",
+  "version": "0.0.43",
   "dependencies": {
-    "@fncts/base": "0.0.34",
-    "@fncts/transformers": "0.0.8",
-    "@fncts/typelevel": "0.0.17"
+    "@fncts/base": "0.0.35",
+    "@fncts/transformers": "0.0.9",
+    "@fncts/typelevel": "0.0.18"
   },
   "exports": {
     "./*": {