@fncts/io 0.0.38 → 0.0.39

package/_src/Ref/DerivedAll.ts

@@ -34,8 +34,9 @@ export class DerivedAll<EA, EB, A, B> extends RefInternal<never, never, EA, EB,
         new DerivedAll((f) =>
           f(
             value,
-            (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)),
+            (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 })),
           ),
         ),
     );
@@ -53,28 +54,30 @@ export class DerivedAll<EA, EB, A, B> extends RefInternal<never, never, EA, EB,
         new DerivedAll((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((e) => Either.left(ec(e)), ca(c))
-                .flatMap((a) => setEither(a)(s).match((e) => Either.left(ea(e)), Either.right)),
+                .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 })),
           ),
         ),
     );
   }
 
   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) =>
         value.modify((s) =>
-          setEither(a)(s).match(
-            (e) => [Either.left(e), s] as [Either<EA, void>, typeof s],
-            (s) => [Either.right(undefined), s],
-          ),
+          setEither(a)(s).match({
+            Left: (e) => [Either.left(e), s] as [Either<EA, void>, typeof s],
+            Right: (s) => [Either.right(undefined), s],
+          }),
         ).absolve,
     );
   }
@@ -83,16 +86,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(
-            (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)(s).match(
-                (e) => tuple(Either.left(e), s),
-                (s) => tuple(Either.right<EA | EB, C>(b), s),
-              );
+              return setEither(a2)(s).match({
+                Left: (e) => tuple(Either.left(e), s),
+                Right: (s) => tuple(Either.right<EA | EB, C>(b), s),
+              });
             },
-          ),
+          }),
         ).absolve,
     );
   }

package/_src/RuntimeFlags/RuntimeFlags.ts

@@ -14,7 +14,7 @@ export type RuntimeFlags = number & {
  */
 export interface RuntimeFlagsOps {}
 
-export const RuntimeFlags: RuntimeFlagsOps = Newtype();
+export const RuntimeFlags: RuntimeFlagsOps = {};
 
 export declare namespace RuntimeFlags {
   type Patch = RuntimeFlagsPatch;

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(STM.succeedNow, f));
+      .flatMap((ca) => ca.match({ Left: STM.succeedNow, Right: 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(STM.failNow, STM.succeedNow));
+  return STM.defer(e().match({ Left: STM.failNow, Right: 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(STM.failNow, STM.succeedNow);
+  return e.match({ Left: STM.failNow, Right: 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(STM.succeedNow, () => STM.failNow(Nothing())),
+    (bc) => bc.match({ Left: STM.succeedNow, Right: () => 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(STM.succeedNow, (c) => STM.fail(orFail(c))));
+    return stm.flatMap((bc) => bc.match({ Left: STM.succeedNow, Right: (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(
-                (out1) => [state, out1, Decision.Done],
-                ([out1, _]) => [state, out1, Decision.Done],
-              ),
+              r.match({
+                Left: (out1) => [state, out1, Decision.Done],
+                Right: ([out1, _]) => [state, out1, Decision.Done],
+              }),
             ),
           () =>
             f(state, out, decision).map((r) =>
-              r.match(
-                (out1) => [state, out1, Decision.Done],
-                ([out1, interval]) => [state, out1, Decision.continueWith(interval)],
-              ),
+              r.match({
+                Left: (out1) => [state, out1, Decision.Done],
+                Right: ([out1, interval]) => [state, out1, Decision.continueWith(interval)],
+              }),
             ),
         ),
       ),

package/_src/ScopedRef/api.ts

@@ -25,13 +25,14 @@ class Synch<A> extends ScopedRef<A> {
     return this.ref.modifyIO(([oldScope, a]) =>
       IO.uninterruptibleMask((restore) =>
         Do((_) => {
+          _(oldScope.close(Exit.unit));
           const newScope = _(Scope.make);
-          const exit     = _(restore(acquire.provideSomeService(newScope, Scope.Tag)).result);
+          const exit     = _(restore(newScope.extend(acquire)).result);
           return _(
             exit.match(
               (cause): UIO<readonly [FIO<E, void>, readonly [Scope.Closeable, A]]> =>
-                newScope.close(Exit.unit).ignore.as([IO.failCauseNow(cause), [oldScope, a]] as const),
-              (a) => oldScope.close(Exit.unit).ignore.as([IO.unit, [newScope, a]] as const),
+                newScope.close(Exit.unit).as([IO.refailCause(cause), [oldScope, a]] as const),
+              (a) => IO.succeedNow([IO.unit, [newScope, a]] as const),
             ),
           );
         }),

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(
-            (e) => Channel.writeNow(leftovers) > Channel.failNow(e),
-            (z) => Channel.writeNow(leftovers) > Channel.succeedNow(z),
-          ),
+          r.match({
+            Left: (e) => Channel.writeNow(leftovers) > Channel.failNow(e),
+            Right: (z) => Channel.writeNow(leftovers) > Channel.succeedNow(z),
+          }),
         () => fromPushPull(push),
       ),
     Channel.failNow,
     () =>
       Channel.fromIO(push(Nothing())).matchChannel(
         ([r, leftovers]) =>
-          r.match(
-            (e) => Channel.writeNow(leftovers) > Channel.failNow(e),
-            (z) => Channel.writeNow(leftovers) > Channel.succeedNow(z),
-          ),
+          r.match({
+            Left: (e) => Channel.writeNow(leftovers) > Channel.failNow(e),
+            Right: (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(
-    (leftChunk) => (leftChunk.isEmpty ? [out, new PullBoth()] : [out, new PullRight(leftChunk)]),
-    (rightChunk) => (rightChunk.isEmpty ? [out, new PullBoth()] : [out, new PullLeft(rightChunk)]),
-  );
+  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)]),
+  });
 }

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(
-    (l) => (leftChunk.isEmpty ? [out, new PullBoth()] : [out, new PullRight(leftChunk)]),
-    (r) => (rightChunk.isEmpty ? [out, new PullBoth()] : [out, new PullLeft(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)]),
+  });
 }
 
 /**

package/_src/Stream/api.ts

@@ -56,7 +56,9 @@ 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(() => Nothing(), Maybe.just));
+    return stream
+      .aggregateAsyncWithinEither(sink, schedule)
+      .filterMap((cb) => cb.match({ Left: () => Nothing(), Right: Maybe.just }));
   };
 }
 
@@ -165,14 +167,14 @@ export function aggregateAsyncWithinEither<R1, E1, A1, B, R2, C>(
             (scheduleExit, sinkFiber) =>
               IO.fromExit(scheduleExit).matchCauseIO(
                 (cause) =>
-                  cause.failureOrCause.match(
-                    () =>
+                  cause.failureOrCause.match({
+                    Left: () =>
                       handoff.offer(HandoffSignal.End(new ScheduleEnd())).forkDaemon >
                       sinkFiber.join.map(([leftovers, b]) => handleSide(leftovers, b, Nothing())),
-                    (cause) =>
+                    Right: (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))),
@@ -255,8 +257,8 @@ export function asyncInterrupt<R, E, A>(
           }),
         ),
       );
-      return eitherStream.match(
-        (canceler) => {
+      return eitherStream.match({
+        Left: (canceler) => {
           const loop: Channel<never, unknown, unknown, unknown, E, Conc<A>, void> = Channel.unwrap(
             output.take
               .flatMap((take) => take.done)
@@ -267,8 +269,8 @@ export function asyncInterrupt<R, E, A>(
           );
           return new Stream(loop).ensuring(canceler);
         },
-        (stream) => Stream.unwrap(output.shutdown.as(stream)),
-      );
+        Right: (stream) => Stream.unwrap(output.shutdown.as(stream)),
+      });
     }),
   );
 }
@@ -336,10 +338,10 @@ export function asyncIO<R, E, A, R1 = R, E1 = E>(
             .matchCauseIO(
               (cause) =>
                 output.shutdown.as(
-                  cause.failureOrCause.match(
-                    (maybeError) => maybeError.match(() => Channel.endNow(undefined), Channel.failNow),
-                    Channel.failCauseNow,
-                  ),
+                  cause.failureOrCause.match({
+                    Left: (maybeError) => maybeError.match(() => Channel.endNow(undefined), Channel.failNow),
+                    Right: Channel.failCauseNow,
+                  }),
                 ),
               (as) => IO.succeed(Channel.writeNow(as) > loop),
             ),
@@ -577,7 +579,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(f, Stream.failCauseNow));
+    return stream.catchAllCause((cause) => cause.failureOrCause.match({ Left: f, Right: Stream.failCauseNow }));
   };
 }
 
@@ -3208,7 +3210,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(() => IO.failNow(Nothing()), IO.succeedNow)),
+    io.mapError(Maybe.just).flatMap((r) => r.match({ Left: () => IO.failNow(Nothing()), Right: IO.succeedNow })),
   );
 }
 
@@ -3430,22 +3432,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(
-                      (leftChunk) =>
+                    ab.match({
+                      Left: (leftChunk) =>
                         latest.modify(([_, rightLatest]) =>
                           tuple(
                             leftChunk.map((a) => f(a, rightLatest)),
                             tuple(leftChunk.unsafeGet(leftChunk.length - 1), rightLatest),
                           ),
                         ),
-                      (rightChunk) =>
+                      Right: (rightChunk) =>
                         latest.modify(([leftLatest, _]) =>
                           tuple(
                             rightChunk.map((b) => f(leftLatest, b)),
                             tuple(leftLatest, rightChunk.unsafeGet(rightChunk.length - 1)),
                           ),
                         ),
-                    ),
+                    }),
                   )
                   .flatMap(Stream.fromChunkNow),
               ),

package/_src/SupervisorPatch.ts

@@ -82,6 +82,7 @@ export function diff(oldValue: Supervisor<any>, newValue: Supervisor<any>): Supe
   }
 }
 
+/** @tsplus tailRec */
 function applyLoop(supervisor: Supervisor<any>, patches: List<SupervisorPatch>): Supervisor<any> {
   if (patches.isEmpty()) {
     return supervisor;

package/_src/TRef/definition.ts

@@ -159,8 +159,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((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 })),
             value,
             atomic,
           ),
@@ -178,11 +178,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((e) => Either.left(eb(e)), bd),
+            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
             (c) => (s) =>
               getEither(s)
-                .match((e) => Either.left(ec(e)), ca(c))
-                .flatMap((a) => setEither(a).match((e) => Either.left(ea(e)), Either.right)),
+                .match({ Left: (e) => Either.left(ec(e)), Right: ca(c) })
+                .flatMap((a) => setEither(a).match({ Left: (e) => Either.left(ea(e)), Right: Either.right })),
             value,
             atomic,
           ),
@@ -192,27 +192,29 @@ 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(STM.failNow, STM.succeedNow)),
+      value.get.flatMap((s) => getEither(s).match({ Left: STM.failNow, Right: STM.succeedNow })),
     );
   }
 
   set(a: A, __tsplusTrace?: string | undefined): STM<never, EA, void> {
-    return this.use((_getEither, setEither, value, _atomic) => setEither(a).match(STM.failNow, (s) => value.set(s)));
+    return this.use((_getEither, setEither, value, _atomic) =>
+      setEither(a).match({ Left: STM.failNow, Right: (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(
-          (e) => [Either.left<EA | EB, C>(e), s],
-          (a1) => {
+        getEither(s).match({
+          Left: (e) => [Either.left<EA | EB, C>(e), s],
+          Right: (a1) => {
             const [b, a2] = f(a1);
-            return setEither(a2).match(
-              (e) => [Either.left(e), s],
-              (s) => [Either.right(b), s],
-            );
+            return setEither(a2).match({
+              Left: (e) => [Either.left(e), s],
+              Right: (s) => [Either.right(b), s],
+            });
           },
-        ),
+        }),
       ),
     ).absolve;
   }
@@ -253,8 +255,9 @@ 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((e) => Either.left(eb(e)), bd),
-            (c) => (s) => ca(c).flatMap((a) => setEither(a)(s).match((e) => Either.left(ea(e)), Either.right)),
+            (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 })),
             value,
             atomic,
           ),
@@ -272,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((e) => Either.left(eb(e)), bd),
+            (s) => getEither(s).match({ Left: (e) => Either.left(eb(e)), Right: bd }),
             (c) => (s) =>
               getEither(s)
-                .match((e) => Either.left(ec(e)), ca(c))
-                .flatMap((a) => setEither(a)(s).match((e) => Either.left(ea(e)), Either.right)),
+                .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 })),
             value,
             atomic,
           ),
@@ -286,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(STM.failNow, STM.succeedNow)),
+      value.get.flatMap((s) => getEither(s).match({ Left: STM.failNow, Right: 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(
-          (e) => [Either.left(e), s] as [Either<EA, void>, typeof s],
-          (s) => [Either.right(undefined), s],
-        ),
+        setEither(a)(s).match({
+          Left: (e) => [Either.left(e), s] as [Either<EA, void>, typeof s],
+          Right: (s) => [Either.right(undefined), s],
+        }),
       ),
     ).absolve;
   }
@@ -304,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(
-          (e) => [Either.left<EA | EB, C>(e), s],
-          (a1) => {
+        getEither(s).match({
+          Left: (e) => [Either.left<EA | EB, C>(e), s],
+          Right: (a1) => {
             const [b, a2] = f(a1);
-            return setEither(a2)(s).match(
-              (e) => [Either.left(e), s],
-              (s) => [Either.right(b), s],
-            );
+            return setEither(a2)(s).match({
+              Left: (e) => [Either.left(e), s],
+              Right: (s) => [Either.right(b), s],
+            });
           },
-        ),
+        }),
       ),
     ).absolve;
   }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@fncts/io",
-  "version": "0.0.38",
+  "version": "0.0.39",
   "dependencies": {
-    "@fncts/base": "0.0.31",
+    "@fncts/base": "0.0.32",
     "@fncts/transformers": "0.0.6",
     "@fncts/typelevel": "0.0.15"
   },