@fncts/io 0.0.12 → 0.0.15

package/_src/Schedule/definition.ts

@@ -32,7 +32,7 @@ import type { Driver as Driver_ } from "./Driver.js";
  * @tsplus companion fncts.io.ScheduleOps
  */
 export abstract class Schedule<Env, In, Out> {
-  readonly _Env!: (_: Env) => void;
+  readonly _Env!: () => Env;
   readonly _In!: (_: In) => void;
   readonly _Out!: () => Out;
   readonly _State!: unknown;

package/_src/Scope/Finalizer/definition.ts

@@ -1,5 +1,5 @@
 interface FinalizerN extends HKT {
-  readonly [HKT.T]: Finalizer;
+  readonly type: Finalizer;
 }
 
 /**
@@ -10,7 +10,7 @@ export interface Finalizer
     {
       readonly Finalizer: unique symbol;
     },
-    (exit: Exit<any, any>) => IO<unknown, never, any>
+    (exit: Exit<any, any>) => IO<never, never, any>
   > {}
 
 /**

package/_src/Scope/ReleaseMap/api/releaseAll.ts

@@ -3,7 +3,12 @@ import { Exited, ReleaseMap } from "../definition.js";
 /**
  * @tsplus fluent fncts.io.Scope.ReleaseMap releaseAll
  */
-export function releaseAll_(releaseMap: ReleaseMap, exit: Exit<any, any>, execStrategy: ExecutionStrategy): UIO<any> {
+export function releaseAll_(
+  releaseMap: ReleaseMap,
+  exit: Exit<any, any>,
+  execStrategy: ExecutionStrategy,
+  __tsplusTrace?: string,
+): UIO<any> {
   return ReleaseMap.reverseGet(releaseMap).modify((s) => {
     switch (s._tag) {
       case "Exited":

package/_src/Scope/ReleaseMap/api.ts

@@ -3,7 +3,7 @@ import { Exited, ReleaseMap, Running } from "./definition.js";
 /**
  * @tsplus fluent fncts.io.Scope.ReleaseMap addIfOpen
  */
-export function addIfOpen_(releaseMap: ReleaseMap, finalizer: Finalizer): UIO<Maybe<number>> {
+export function addIfOpen_(releaseMap: ReleaseMap, finalizer: Finalizer, __tsplusTrace?: string): UIO<Maybe<number>> {
   return ReleaseMap.reverseGet(releaseMap).modify((s) => {
     switch (s._tag) {
       case "Exited":
@@ -23,7 +23,12 @@ export function addIfOpen_(releaseMap: ReleaseMap, finalizer: Finalizer): UIO<Ma
 /**
  * @tsplus fluent fncts.io.Scope.ReleaseMap release
  */
-export function release_(releaseMap: ReleaseMap, key: number, exit: Exit<any, any>): IO<unknown, never, any> {
+export function release_(
+  releaseMap: ReleaseMap,
+  key: number,
+  exit: Exit<any, any>,
+  __tsplusTrace?: string,
+): IO<never, never, any> {
   return ReleaseMap.reverseGet(releaseMap).modify((s) => {
     switch (s._tag) {
       case "Exited": {
@@ -45,7 +50,7 @@ export function release_(releaseMap: ReleaseMap, key: number, exit: Exit<any, an
 /**
  * @tsplus fluent fncts.io.Scope.ReleaseMap add
  */
-export function add_(releaseMap: ReleaseMap, finalizer: Finalizer): UIO<Finalizer> {
+export function add_(releaseMap: ReleaseMap, finalizer: Finalizer, __tsplusTrace?: string): UIO<Finalizer> {
   return releaseMap.addIfOpen(finalizer).map((key) =>
     key.match(
       (): Finalizer => Finalizer.get(() => IO.unit),
@@ -57,7 +62,12 @@ export function add_(releaseMap: ReleaseMap, finalizer: Finalizer): UIO<Finalize
 /**
  * @tsplus fluent fncts.io.Scope.ReleaseMap replace
  */
-export function replace_(releaseMap: ReleaseMap, key: number, finalizer: Finalizer): UIO<Maybe<Finalizer>> {
+export function replace_(
+  releaseMap: ReleaseMap,
+  key: number,
+  finalizer: Finalizer,
+  __tsplusTrace?: string,
+): UIO<Maybe<Finalizer>> {
   return ReleaseMap.reverseGet(releaseMap).modify((s) => {
     switch (s._tag) {
       case "Exited":
@@ -74,7 +84,7 @@ export function replace_(releaseMap: ReleaseMap, key: number, finalizer: Finaliz
 /**
  * @tsplus fluent fncts.io.Scope.ReleaseMap updateAll
  */
-export function updateAll_(releaseMap: ReleaseMap, f: (_: Finalizer) => Finalizer): UIO<void> {
+export function updateAll_(releaseMap: ReleaseMap, f: (_: Finalizer) => Finalizer, __tsplusTrace?: string): UIO<void> {
   return ReleaseMap.reverseGet(releaseMap).update((s) => {
     switch (s._tag) {
       case "Exited":

package/_src/Scope/ReleaseMap/definition.ts

@@ -15,7 +15,7 @@ export class Running {
 export type State = Exited | Running;
 
 interface ReleaseMapN extends HKT {
-  readonly [HKT.T]: ReleaseMap;
+  readonly type: ReleaseMap;
 }
 
 /**

package/_src/Scope/api.ts

@@ -4,14 +4,14 @@ import { ReleaseMap } from "./ReleaseMap.js";
 /**
  * @tsplus fluent fncts.io.Scope addFinalizer
  */
-export function addFinalizer_(self: Scope, finalizer: Lazy<UIO<any>>): UIO<void> {
+export function addFinalizer_(self: Scope, finalizer: Lazy<UIO<any>>, __tsplusTrace?: string): UIO<void> {
   return self.addFinalizerExit(Finalizer.get(() => finalizer()));
 }
 
 /**
  * @tsplus static fncts.io.ScopeOps addFinalizer
  */
-export function addFinalizer(finalizer: Lazy<UIO<void>>): IO<Has<Scope>, never, void> {
+export function addFinalizer(finalizer: Lazy<UIO<void>>, __tsplusTrace?: string): IO<Scope, never, void> {
   return IO.serviceWithIO((scope) => scope.addFinalizer(finalizer), Scope.Tag);
 }
 
@@ -24,7 +24,11 @@ export const concurrent: UIO<Scope.Closeable> = makeWith(ExecutionStrategy.concu
 /**
  * @tsplus fluent fncts.io.Scope extend
  */
-export function extend_<R, E, A>(self: Scope, io: Lazy<IO<R & Has<Scope>, E, A>>): IO<R, E, A> {
+export function extend_<R, E, A>(
+  self: Scope,
+  io: Lazy<IO<R, E, A>>,
+  __tsplusTrace?: string,
+): IO<Exclude<R, Scope>, E, A> {
   return IO.defer(io).contramapEnvironment((r) => r.union(Environment.empty.add(self, Scope.Tag)));
 }
 
@@ -53,7 +57,7 @@ export const make: UIO<Scope.Closeable> = makeWith(ExecutionStrategy.sequential)
  * @tsplus static fncts.io.ScopeOps makeWith
  * @tsplus static fncts.io.Scope.CloseableOps makeWith
  */
-export function makeWith(executionStrategy: Lazy<ExecutionStrategy>): UIO<Scope.Closeable> {
+export function makeWith(executionStrategy: Lazy<ExecutionStrategy>, __tsplusTrace?: string): UIO<Scope.Closeable> {
   return ReleaseMap.make.map(
     (releaseMap) =>
       new (class extends Closeable {
@@ -65,10 +69,10 @@ export function makeWith(executionStrategy: Lazy<ExecutionStrategy>): UIO<Scope.
         }
         get fork() {
           return IO.uninterruptible(
-            IO.gen(function* (_) {
-              const scope     = yield* _(Scope.make);
-              const finalizer = yield* _(releaseMap.add(Finalizer.get((exit) => scope.close(exit))));
-              yield* _(scope.addFinalizerExit(finalizer));
+            Do((_) => {
+              const scope     = _(Scope.make);
+              const finalizer = _(releaseMap.add(Finalizer.get((exit) => scope.close(exit))));
+              _(scope.addFinalizerExit(finalizer));
               return scope;
             }),
           );
@@ -80,14 +84,14 @@ export function makeWith(executionStrategy: Lazy<ExecutionStrategy>): UIO<Scope.
 /**
  * @tsplus static fncts.io.ScopeOps unsafeMake
  */
-export function unsafeMake() {
+export function unsafeMake(__tsplusTrace?: string) {
   return unsafeMakeWith(ExecutionStrategy.sequential);
 }
 
 /**
  * @tsplus static fncts.io.ScopeOps unsafeMakeWith
  */
-export function unsafeMakeWith(executionStrategy: ExecutionStrategy): Scope.Closeable {
+export function unsafeMakeWith(executionStrategy: ExecutionStrategy, __tsplusTrace?: string): Scope.Closeable {
   const releaseMap = ReleaseMap.unsafeMake();
   return new (class extends Closeable {
     addFinalizerExit(finalizer: Finalizer): UIO<void> {
@@ -98,10 +102,10 @@ export function unsafeMakeWith(executionStrategy: ExecutionStrategy): Scope.Clos
     }
     get fork() {
       return IO.uninterruptible(
-        IO.gen(function* (_) {
-          const scope     = yield* _(Scope.make);
-          const finalizer = yield* _(releaseMap.add(Finalizer.get((exit) => scope.close(exit))));
-          yield* _(scope.addFinalizerExit(finalizer));
+        Do((_) => {
+          const scope     = _(Scope.make);
+          const finalizer = _(releaseMap.add(Finalizer.get((exit) => scope.close(exit))));
+          _(scope.addFinalizerExit(finalizer));
           return scope;
         }),
       );
@@ -112,6 +116,10 @@ export function unsafeMakeWith(executionStrategy: ExecutionStrategy): Scope.Clos
 /**
  * @tsplus fluent fncts.io.Scope.Closeable use
  */
-export function use_<R, E, A>(self: Scope.Closeable, io: Lazy<IO<R & Has<Scope>, E, A>>): IO<R, E, A> {
+export function use_<R, E, A>(
+  self: Scope.Closeable,
+  io: Lazy<IO<R, E, A>>,
+  __tsplusTrace?: string,
+): IO<Exclude<R, Scope>, E, A> {
   return self.extend(io).onExit((exit) => self.close(exit));
 }

package/_src/ScopedRef/api.ts

@@ -1,21 +1,16 @@
 /**
  * @tsplus static fncts.io.ScopedRefOps fromAcquire
  */
-export function fromAcquire<R, E, A>(
-  acquire: IO<R, E, A>,
-  __tsplusTrace?: string,
-): IO<R & Has<Scope>, E, ScopedRef<A>> {
+export function fromAcquire<R, E, A>(acquire: IO<R, E, A>, __tsplusTrace?: string): IO<R | Scope, E, ScopedRef<A>> {
   return IO.uninterruptibleMask(({ restore }) =>
-    IO.gen(function* (_) {
-      const newScope = yield* _(Scope.make);
-      const a        = yield* _(
-        restore(acquire(IO.$.provideSomeService(newScope, Scope.Tag))).tapCause((cause) =>
-          newScope.close(Exit.fail(cause)),
-        ),
+    Do((_) => {
+      const newScope = _(Scope.make);
+      const a        = _(
+        restore(acquire.provideSomeService(newScope, Scope.Tag).tapCause((cause) => newScope.close(Exit.fail(cause)))),
       );
-      const ref       = yield* _(Ref.Synchronized.make([newScope, a] as const));
+      const ref       = _(Ref.Synchronized.make([newScope, a] as const));
       const scopedRef = new Synch(ref);
-      yield* _(IO.addFinalizer(scopedRef.close));
+      _(IO.addFinalizer(scopedRef.close));
       return scopedRef;
     }),
   );
@@ -28,13 +23,13 @@ class Synch<A> extends ScopedRef<A> {
 
   close: UIO<void> = this.ref.get.flatMap(([scope, _]) => scope.close(Exit.unit));
 
-  set<R, E>(acquire: IO<R & Has<Scope>, E, A>, __tsplusTrace?: string): IO<R, E, void> {
+  set<R, E>(acquire: IO<R, E, A>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, void> {
     return this.ref.modifyIO(([oldScope, a]) =>
       IO.uninterruptibleMask(({ restore }) =>
-        IO.gen(function* (_) {
-          const newScope = yield* _(Scope.make);
-          const exit     = yield* _(restore(acquire(IO.$.provideSomeService(newScope, Scope.Tag))).result);
-          return yield* _(
+        Do((_) => {
+          const newScope = _(Scope.make);
+          const exit     = _(restore(acquire.provideSomeService(newScope, Scope.Tag)).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),

package/_src/ScopedRef/definition.ts

@@ -8,6 +8,6 @@ export type ScopedRefTypeId = typeof ScopedRefTypeId;
 export abstract class ScopedRef<A> {
   readonly _typeId: ScopedRefTypeId = ScopedRefTypeId;
 
-  abstract set<R, E>(acquire: IO<R & Has<Scope>, E, A>, __tsplusTrace?: string): IO<R, E, void>;
+  abstract set<R, E>(acquire: IO<R | Scope, E, A>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, void>;
   abstract get: UIO<A>;
 }