@fncts/io 0.0.30 → 0.0.32

package/_src/Channel/api/mapOutConcurrentIO.ts

@@ -19,7 +19,7 @@ export function mapOutConcurrentIO<OutElem, Env1, OutErr1, OutElem1>(
             ),
           );
           const errorSignal = Δ(Future.make<OutErr1, never>());
-          const permits     = Δ(TSemaphore.make(n).commit);
+          const permits     = Δ(Semaphore(n));
           const pull        = Δ(self.toPull);
           Δ(
             pull.matchCauseIO(

package/_src/Channel/api/mergeAllWith.ts

@@ -35,7 +35,7 @@ export function mergeAllWith<OutDone>(
           const cancelers    = Δ(IO.acquireRelease(Queue.makeUnbounded<Future<never, void>>(), (queue) => queue.shutdown));
           const lastDone     = Δ(Ref.make<Maybe<OutDone>>(Nothing()));
           const errorSignal  = Δ(Future.make<never, void>());
-          const permits      = Δ(TSemaphore.make(n).commit);
+          const permits      = Δ(Semaphore(n));
           const pull         = Δ(channels.toPull);
           const evaluatePull = (pull: IO<Env | Env1, OutErr | OutErr1, Either<OutDone, OutElem>>) =>
             pull

package/_src/Channel/api/runScoped.ts

@@ -23,7 +23,11 @@ function runScopedInterpret<Env, InErr, InDone, OutErr, OutDone>(
         return IO.fromExit(exec.getDone());
       }
       case ChannelStateTag.Read: {
-        return readUpstream(channelState, () => runScopedInterpret(exec.run(), exec));
+        return readUpstream(
+          channelState,
+          () => runScopedInterpret(exec.run(), exec),
+          (cause) => IO.refailCause(cause),
+        );
       }
     }
   }
@@ -38,8 +42,29 @@ function runScopedInterpret<Env, InErr, InDone, OutErr, OutDone>(
 export function runScoped<Env, InErr, InDone, OutErr, OutDone>(
   self: Channel<Env, InErr, unknown, InDone, OutErr, never, OutDone>,
 ): IO<Env | Scope, OutErr, OutDone> {
-  return IO.acquireReleaseExit(
-    IO.succeed(new ChannelExecutor(() => self, null, identity)),
-    (exec, exit) => exec.close(exit) ?? IO.unit,
-  ).flatMap((exec) => IO.defer(runScopedInterpret(exec.run(), exec)));
+  const run = (channelFuture: Future<OutErr, OutDone>, scopeFuture: Future<never, void>, scope: Scope) =>
+    IO.acquireReleaseExit(IO.succeed(new ChannelExecutor(() => self, null, identity)), (exec, exit) => {
+      const finalize = exec.close(exit);
+      if (finalize !== null) {
+        return finalize.tapErrorCause((cause) => scope.addFinalizer(IO.refailCause(cause)));
+      } else {
+        return IO.unit;
+      }
+    }).flatMap((exec) =>
+      IO.defer(runScopedInterpret(exec.run(), exec).fulfill(channelFuture) > channelFuture.await < scopeFuture.await),
+    );
+
+  return IO.uninterruptibleMask((restore) =>
+    Do((Δ) => {
+      const parent        = Δ(IO.scope);
+      const child         = Δ(parent.fork);
+      const channelFuture = Δ(Future.make<OutErr, OutDone>());
+      const scopeFuture   = Δ(Future.make<never, void>());
+      const fiber         = Δ(restore(run(channelFuture, scopeFuture, child)).forkScoped);
+      Δ(IO.addFinalizer(scopeFuture.succeed(undefined)));
+      const done = Δ(restore(channelFuture.await));
+      Δ(fiber.inheritAll);
+      return done;
+    }),
+  );
 }

package/_src/Channel/api/toPull.ts

@@ -32,7 +32,7 @@ function toPullInterpret<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
       return done.match(IO.failCauseNow, (outDone) => IO.succeedNow(Either.left(outDone)));
     }
     case ChannelStateTag.Read: {
-      return readUpstream(channelState, () => toPullInterpret(exec.run(), exec));
+      return readUpstream(channelState, () => toPullInterpret(exec.run(), exec), IO.refailCause);
     }
   }
 }

package/_src/Channel/api.ts

@@ -1028,6 +1028,7 @@ function isChannelFailure<E>(u: unknown): u is ChannelFailure<E> {
 
 /**
  * @tsplus pipeable fncts.io.Channel pipeToOrFail
+ * @tsplus pipeable-operator fncts.io.Channel >>>
  */
 export function pipeToOrFail<OutElem, OutDone, Env1, OutErr1, OutElem1, OutDone1>(
   right: Channel<Env1, never, OutElem, OutDone, OutErr1, OutElem1, OutDone1>,

package/_src/Channel/internal/ChannelExecutor.ts

@@ -184,9 +184,13 @@ class Emit<R> {
  * ChannelExecutor
  * -------------------------------------------------------------------------------------------------
  */
-export function readUpstream<R, E, A>(r: State.Read<R, E>, cont: () => IO<R, E, A>): IO<R, E, A> {
+export function readUpstream<R, E, A, E1>(
+  r: State.Read<R, E>,
+  cont: () => IO<R, E1, A>,
+  onFailure: (cause: Cause<E>) => IO<R, E1, A>,
+): IO<R, E1, A> {
   const readStack: Stack<State.Read<any, any>> = Stack.single(r);
-  const read = (): IO<R, E, A> => {
+  const read = (): IO<R, E1, A> => {
     const current = readStack.pop()!;
     if (current.upstream === null) {
       return IO.defer(cont);
@@ -199,13 +203,13 @@ export function readUpstream<R, E, A>(r: State.Read<R, E>, cont: () => IO<R, E,
           if (emitEffect === null) {
             return IO.defer(cont());
           } else {
-            return emitEffect.flatMap(() => cont());
+            return emitEffect.matchCauseIO(onFailure, () => cont());
           }
         } else {
           if (emitEffect === null) {
             return IO.defer(read());
           } else {
-            return emitEffect.flatMap(() => read());
+            return emitEffect.matchCauseIO(onFailure, () => read());
           }
         }
       }
@@ -215,13 +219,13 @@ export function readUpstream<R, E, A>(r: State.Read<R, E>, cont: () => IO<R, E,
           if (doneEffect === null) {
             return IO.defer(cont());
           } else {
-            return doneEffect.flatMap(() => cont());
+            return doneEffect.matchCauseIO(onFailure, () => cont());
           }
         } else {
           if (doneEffect === null) {
             return IO.defer(read());
           } else {
-            return doneEffect.flatMap(() => read());
+            return doneEffect.matchCauseIO(onFailure, () => read());
           }
         }
       }
@@ -321,8 +325,10 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
                           );
                         }
                         case State.ChannelStateTag.Read: {
-                          return readUpstream(state, () => drainer).catchAllCause((cause) =>
-                            currentChannel.input.error(cause),
+                          return readUpstream(
+                            state,
+                            () => drainer,
+                            (cause: Cause<any>) => currentChannel.input.error(cause),
                           );
                         }
                       }
@@ -492,26 +498,24 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
 
   private popAllFinalizers(exit: Exit<unknown, unknown>): URIO<Env, any> {
     /**
-     * @tsplus tailrec
+     * @tsplus tailRec
      */
-    const unwind = (
-      acc: IO<Env, never, Exit<never, any>>,
-      conts: List<ErasedContinuation<Env>>,
-    ): IO<Env, never, Exit<never, unknown>> => {
-      if (conts.isEmpty()) {
-        return acc;
+    const unwind = (acc: List<Finalizer<Env>>): List<Finalizer<Env>> => {
+      if (this.doneStack.isEmpty()) {
+        return acc.reverse;
       } else {
-        const head = conts.unsafeHead!;
+        const head     = this.doneStack.unsafeHead;
+        this.doneStack = this.doneStack.unsafeTail;
         concreteContinuation(head);
         if (head._tag === ChannelTag.ContinuationK) {
-          return unwind(acc, conts.unsafeTail);
+          return unwind(acc);
         } else {
-          return unwind(acc.zipRight(head.finalizer(exit).result), conts.unsafeTail);
+          return unwind(acc.prepend(head.finalizer));
         }
       }
     };
-    const effect   = unwind(IO.succeedNow(Exit.succeed(undefined)), this.doneStack).flatMap(IO.fromExitNow);
-    this.doneStack = Nil();
+    const finalizers = unwind(List.empty());
+    const effect     = finalizers.isEmpty() ? IO.unit : this.runFinalizers(finalizers, exit);
     this.storeInProgressFinalizer(effect);
     return effect;
   }

package/_src/Fiber/FiberMessage.ts

@@ -26,7 +26,7 @@ export class InterruptSignal {
 /**
  * @tsplus static fncts.io.FiberMessageOps InterruptSignal
  */
-export function mkInterruptSignal(cause: Cause<never>): FiberMessage {
+export function interruptSignal(cause: Cause<never>): FiberMessage {
   return new InterruptSignal(cause);
 }
 
@@ -38,7 +38,7 @@ export class GenStackTrace {
 /**
  * @tsplus static fncts.io.FiberMessageOps GenStackTrace
  */
-export function mkGenStackTrace(onTrace: (trace: Trace) => void): FiberMessage {
+export function genStackTrace(onTrace: (trace: Trace) => void): FiberMessage {
   return new GenStackTrace(onTrace);
 }
 
@@ -50,7 +50,7 @@ export class Stateful {
 /**
  * @tsplus static fncts.io.FiberMessageOps Stateful
  */
-export function mkStateful(onFiber: (fiber: FiberRuntime<any, any>, status: FiberStatus) => void): FiberMessage {
+export function stateful(onFiber: (fiber: FiberRuntime<any, any>, status: FiberStatus) => void): FiberMessage {
   return new Stateful(onFiber);
 }
 
@@ -62,7 +62,7 @@ export class Resume {
 /**
  * @tsplus static fncts.io.FiberMessageOps Resume
  */
-export function mkResume(cont: IO<any, any, any>): FiberMessage {
+export function resume(cont: IO<any, any, any>): FiberMessage {
   return new Resume(cont);
 }
 
@@ -73,6 +73,6 @@ export interface YieldNow {
 /**
  * @tsplus static fncts.io.FiberMessageOps YieldNow
  */
-export const YieldNow: FiberMessage = {
+export const yieldNow: FiberMessage = {
   _tag: FiberMessageTag.YieldNow,
 };

package/_src/Fiber/FiberRuntime.ts

@@ -506,7 +506,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
         } else if (isInterruptedException(e)) {
           cur = IO.concrete(IO.failCauseNow(Cause.both(Cause.halt(e), Cause.interrupt(FiberId.none))));
         } else {
-          cur = IO.concrete(IO.failCauseNow(Cause.halt(e)));
+          cur = IO.concrete(IO.failCauseNow(Cause.halt(e, Trace(this.fiberId, Conc(TraceElement.parse(lastTrace))))));
         }
       }
     }

package/_src/FiberRefs/api.ts

@@ -155,4 +155,4 @@ function findAncestor(
     }
   }
   return [ref.initial, true];
-}
+}

package/_src/Hub/api.ts

@@ -11,7 +11,7 @@ import {
   unsafeMakeHub,
 } from "@fncts/io/Hub/internal";
 import { Hub as HubInternal } from "@fncts/io/internal/Hub";
-import { EnqueueTypeId, QueueTypeId , QueueVariance } from "@fncts/io/Queue";
+import { EnqueueTypeId, QueueTypeId, QueueVariance } from "@fncts/io/Queue";
 
 /**
  * Waits for the hub to be shut down.

package/_src/IO/api/blocking.ts

@@ -0,0 +1,9 @@
+import { backgroundScheduler } from "@fncts/io/internal/BackgroundScheduler";
+
+/**
+ * @tsplus static fncts.io.IOOps blocking
+ * @tsplus getter fncts.io.IO blocking
+ */
+export function blocking<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
+  return FiberRef.currentScheduler.locally(backgroundScheduler)(IO.yieldNow) > self;
+}

package/_src/IO/api/provideSomeLayer.ts

@@ -1,11 +1,9 @@
-import type { Spreadable } from "@fncts/base/types";
-import type { Erase } from "@fncts/typelevel/Intersection";
 /**
  * @tsplus static fncts.io.IOAspects provideSomeLayer
  * @tsplus pipeable fncts.io.IO provideSomeLayer
  */
 export function provideSomeLayer<RIn, E1, ROut>(layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string) {
-  return <R, E, A>(self: IO<R, E, A>): IO<RIn & Erase<R, ROut>, E | E1, A> => {
+  return <R, E, A>(self: IO<R, E, A>): IO<RIn | Exclude<R, ROut>, E | E1, A> => {
     // @ts-expect-error
     return self.provideLayer(Layer.environment<RIn>().and(layer));
   };

package/_src/IO/api/raceWith.ts

@@ -31,15 +31,13 @@ export function raceFibersWith<R, E, A, R1, E1, B, R2, E2, C, R3, E3, D>(
       const raceIndicator = new AtomicBoolean(true);
       const leftFiber     = IO.unsafeMakeChildFiber(left, parentState, parentRuntimeFlags, null, __tsplusTrace);
       const rightFiber    = IO.unsafeMakeChildFiber(right0, parentState, parentRuntimeFlags, null, __tsplusTrace);
-      leftFiber.setFiberRef(FiberRef.forkScopeOverride, Just(parentState.scope));
-      rightFiber.setFiberRef(FiberRef.forkScopeOverride, Just(parentState.scope));
 
       return IO.async((cb) => {
         leftFiber.addObserver(() => complete(leftFiber, rightFiber, leftWins, raceIndicator, cb));
         rightFiber.addObserver(() => complete(rightFiber, leftFiber, rightWins, raceIndicator, cb));
         leftFiber.startFork(left);
         rightFiber.startFork(right0);
-      });
+      }, leftFiber.fiberId.combine(rightFiber.fiberId));
     });
   };
 }

package/_src/IO/api/stateful.ts

@@ -9,5 +9,5 @@ export function stateful<S, R, E, A>(
   tag: Tag<State<S>>,
   __tsplusTrace?: string,
 ): IO<R, E, A> {
-  return IO.defer(io)(IO.$.provideSomeLayer(State.initial(s, tag)));
+  return IO.defer(io).provideSomeLayer(State.initial(s, tag));
 }

package/_src/IO/api/zipConcurrent.ts

@@ -1,16 +1,14 @@
 import type { InterruptibilityRestorer } from "./interrupt.js";
 import type { Grafter } from "./transplant.js";
 
-import { tuple } from "@fncts/base/data/function";
 import { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
-import { AtomicReference } from "@fncts/base/internal/AtomicReference";
 
 /**
  * @tsplus pipeable fncts.io.IO zipConcurrent
  */
 export function zipConcurrent<R1, E1, B>(that: IO<R1, E1, B>, __tsplusTrace?: string) {
-  return <R, E, A>(self: IO<R, E, A>): IO<R | R1, E | E1, readonly [A, B]> => {
-    return self.zipWithConcurrent(that, tuple);
+  return <R, E, A>(self: IO<R, E, A>): IO<R | R1, E | E1, Zipped.Make<A, B>> => {
+    return self.zipWithConcurrent(that, (a, b) => Zipped(a, b));
   };
 }
 
@@ -19,32 +17,30 @@ export function zipConcurrent<R1, E1, B>(that: IO<R1, E1, B>, __tsplusTrace?: st
  */
 export function zipWithConcurrent<A, R1, E1, B, C>(that: IO<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string) {
   return <R, E>(self: IO<R, E, A>): IO<R | R1, E | E1, C> => {
-    return IO.fiberId.flatMap((fiberId) =>
-      IO.uninterruptibleMask((restore) => {
-        return IO.transplant((graft) => {
-          const future = Future.unsafeMake<void, void>(FiberId.none);
-          const ref    = new AtomicBoolean(false);
-          return fork(self, restore, graft, future, ref)
-            .zip(fork(that, restore, graft, future, ref))
-            .flatMap(([left, right]) =>
-              restore(future.await).matchCauseIO(
-                (cause) =>
-                  left.interruptFork >
-                  right.interruptFork >
-                  left.await.zip(right.await).flatMap(([left, right]) =>
-                    left
-                      .zipWithCause(right, f, (a, b) => Cause.both(a, b))
-                      .match(
-                        (causes) => IO.refailCause(Cause.both(cause.stripFailures, causes)),
-                        () => IO.refailCause(cause.stripFailures),
-                      ),
-                  ),
-                () => left.join.zipWith(right.join, f),
-              ),
-            );
-        });
-      }),
-    );
+    return IO.uninterruptibleMask((restore) => {
+      return IO.transplant((graft) => {
+        const future = Future.unsafeMake<void, void>(FiberId.none);
+        const ref    = new AtomicBoolean(false);
+        return fork(self, restore, graft, future, ref)
+          .zip(fork(that, restore, graft, future, ref))
+          .flatMap(([left, right]) =>
+            restore(future.await).matchCauseIO(
+              (cause) =>
+                left.interruptFork >
+                right.interruptFork >
+                left.await.zip(right.await).flatMap(([left, right]) =>
+                  left
+                    .zipWithCause(right, f, (a, b) => Cause.both(a, b))
+                    .match(
+                      (causes) => IO.refailCause(Cause.both(cause.stripFailures, causes)),
+                      () => IO.refailCause(cause.stripFailures),
+                    ),
+                ),
+              () => left.join.zipWith(right.join, f),
+            ),
+          );
+      });
+    });
   };
 }
 

package/_src/IO/runtime.ts

@@ -59,7 +59,7 @@ export class Runtime<R> {
       this.unsafeRunAsyncWith(io, resolve);
     });
 
-  unsafeRunSyncExit = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): Exit<E, A> => {
+  unsafeRunOrFork = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): Either<Fiber.Runtime<E, A>, Exit<E, A>> => {
     const fiberId   = FiberId.unsafeMake(__tsplusTrace);
     const scheduler = new StagedScheduler();
     const fiberRefs = this.fiberRefs.updateAs(fiberId, FiberRef.currentEnvironment, this.environment);
@@ -83,10 +83,10 @@ export class Runtime<R> {
 
     const result = fiber.exitValue();
     if (result !== null) {
-      return result;
+      return Either.right(result);
     }
 
-    return Exit.halt(fiber);
+    return Either.left(fiber);
   };
 }
 
@@ -135,4 +135,4 @@ export const unsafeRunWith = defaultRuntime.unsafeRunWith;
 /**
  * @tsplus getter fncts.io.IO unsafeRunSyncExit
  */
-export const unsafeRunSyncExit = defaultRuntime.unsafeRunSyncExit;
+export const unsafeRunOrFork = defaultRuntime.unsafeRunOrFork;

package/_src/IO.ts

@@ -13,6 +13,7 @@ export * from "./IO/api/addFinalizer.js";
 export * from "./IO/api/addFinalizerExit.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";

package/_src/Queue/api/filterInputIO.ts

@@ -1,6 +1,6 @@
 import type { PEnqueue, PEnqueueInternal } from "@fncts/io/Queue/definition";
 
-import { concrete, EnqueueTypeId, QueueInternal, QueueTypeId , QueueVariance } 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>) {

package/_src/Queue/api/filterOutputIO.ts

@@ -1,6 +1,6 @@
 import type { PDequeue, PDequeueInternal } from "@fncts/io/Queue/definition";
 
-import { concrete, DequeueTypeId, QueueInternal, QueueTypeId , QueueVariance } 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>) {

package/_src/Ref/Synchronized/constructors.ts

@@ -5,7 +5,7 @@ import { PSynchronizedInternal } from "./definition.js";
  */
 export function unsafeMakeSynchronized<A>(a: A, __tsplusTrace?: string): Ref.Synchronized<A> {
   const ref       = Ref.unsafeMake(a);
-  const semaphore = TSemaphore.unsafeMake(1);
+  const semaphore = Semaphore.unsafeMake(1);
   return new PSynchronizedInternal(semaphore, ref.get, (a: A) => ref.set(a));
 }
 
@@ -15,7 +15,7 @@ export function unsafeMakeSynchronized<A>(a: A, __tsplusTrace?: string): Ref.Syn
 export function makeSynchronized<A>(a: Lazy<A>, __tsplusTrace?: string): UIO<Ref.Synchronized<A>> {
   return Do((_) => {
     const ref       = _(Ref.make(a));
-    const semaphore = _(TSemaphore.make(1).commit);
+    const semaphore = _(Semaphore(1));
     return new PSynchronizedInternal(semaphore, ref.get, (a: A) => ref.set(a));
   });
 }

package/_src/Ref/Synchronized/definition.ts

@@ -30,7 +30,7 @@ export const Synchronized: PSynchronizedOps = {};
 export class PSynchronizedInternal<RA, RB, EA, EB, A, B> extends RefInternal<RA, RB, EA, EB, A, B> {
   readonly [SynchronizedTypeId]: SynchronizedTypeId = SynchronizedTypeId;
   constructor(
-    readonly semaphore: TSemaphore,
+    readonly semaphore: Semaphore,
     readonly unsafeGet: IO<RB, EB, B>,
     readonly unsafeSet: (a: A) => IO<RA, EA, void>,
   ) {

package/_src/Semaphore.ts

@@ -0,0 +1,81 @@
+/**
+ * @tsplus type fncts.io.Semaphore
+ * @tsplus companion fncts.io.SemaphoreOps
+ */
+export class Semaphore {
+  constructor(readonly permits: number) {}
+
+  taken   = 0;
+  waiters = new Set<() => void>();
+
+  get free(): number {
+    return this.permits - this.taken;
+  }
+
+  runNext() {
+    const next = this.waiters.values().next();
+    if (!next.done) {
+      this.waiters.delete(next.value);
+      next.value();
+    }
+  }
+
+  take(n: number) {
+    return IO.asyncInterrupt<never, never, number>((cb) => {
+      if (this.free < n) {
+        const observer = () => {
+          if (this.free >= n) {
+            this.waiters.delete(observer);
+            this.taken += n;
+            cb(IO.succeedNow(n));
+          }
+        };
+        this.waiters.add(observer);
+        return Either.left(
+          IO(() => {
+            this.waiters.delete(observer);
+          }),
+        );
+      }
+      this.taken += n;
+      return Either.right(IO.succeedNow(n));
+    });
+  }
+
+  release(n: number) {
+    return IO.withFiberRuntime<never, never, void>((fiber) => {
+      this.taken -= n;
+      fiber.getFiberRef(FiberRef.currentScheduler).scheduleTask(() => {
+        this.waiters.forEach((wake) => wake());
+      });
+      return IO.unit;
+    });
+  }
+
+  withPermits(permits: number) {
+    return <R, E, A>(io: IO<R, E, A>): IO<R, E, A> => {
+      return IO.uninterruptibleMask((restore) =>
+        restore(this.take(permits)).flatMap((permits) => restore(io).ensuring(this.release(permits))),
+      );
+    };
+  }
+
+  withPermit<R, E, A>(io: IO<R, E, A>): IO<R, E, A> {
+    return this.withPermits(1)(io);
+  }
+}
+
+/**
+ * @tsplus static fncts.io.SemaphoreOps unsafeMake
+ */
+export function unsafeMakeSemaphore(permits: number): Semaphore {
+  return new Semaphore(permits);
+}
+
+/**
+ * @tsplus static fncts.io.SemaphoreOps make
+ * @tsplus static fncts.io.SemaphoreOps __call
+ */
+export function makeSemaphore(permits: number, __tsplusTrace?: string): UIO<Semaphore> {
+  return IO(Semaphore.unsafeMake(permits));
+}

package/_src/State/definition.ts

@@ -1,4 +1,4 @@
-import type { StateInternal} from "./internal.js";
+import type { StateInternal } from "./internal.js";
 
 import { StateVariance } from "./internal.js";
 import { StateTypeId } from "./internal.js";