@fncts/io 0.0.11 → 0.0.14

package/IO/api/scopeWith.d.ts

@@ -1,8 +1,7 @@
 import { Scope } from "@fncts/io/Scope/definition";
 import { IO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 /**
  * @tsplus static fncts.io.IOOps scopeWith
  * @tsplus location "@fncts/io/IO/api/scopeWith"
  */
-export declare function scopeWith<R, E, A>(f: (scope: Scope) => IO<R, E, A>): IO<R & Has<Scope>, E, A>;
+export declare function scopeWith<R, E, A>(f: (scope: Scope) => IO<R, E, A>, __tsplusTrace?: string): IO<R | Scope, E, A>;

package/IO/api/scoped.d.ts

@@ -1,14 +1,13 @@
-import { Lazy } from "@fncts/base/data/function";
+import { Lazy } from "@fncts/base/data/function/definition";
 import { IO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Scope } from "@fncts/io/Scope/definition";
 /**
  * @tsplus static fncts.io.IOOps scoped
  * @tsplus location "@fncts/io/IO/api/scoped"
  */
-export declare function scoped<R, E, A>(io: Lazy<IO<R & Has<Scope>, E, A>>): IO<R, E, A>;
+export declare function scoped<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, A>;
 /**
  * @tsplus getter fncts.io.IO scoped
  * @tsplus location "@fncts/io/IO/api/scoped"
  */
-export declare function scoped_<R, E, A>(io: IO<R & Has<Scope>, E, A>): IO<R, E, A>;
+export declare function scoped_<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, A>;

package/IO/api/sequenceT.d.ts

@@ -1,10 +1,10 @@
-import { ReadonlyNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray";
+import { ReadonlyNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import { IO } from "@fncts/io/IO/definition";
-import { HKT } from "@fncts/typelevel/HKT";
+import type { _A, _E, _R } from "@fncts/base/types";
 /**
  * @tsplus static fncts.io.IOOps sequenceT
  * @tsplus location "@fncts/io/IO/api/sequenceT"
  */
-export declare function sequenceT<T extends ReadonlyNonEmptyArray<IO<any, any, any>>>(...ios: T): IO<HKT._R<T[number]>, HKT._E<T[number]>, {
-    [K in keyof T]: T[K] extends HKT ? HKT._A<T[K]> : never;
+export declare function sequenceT<T extends ReadonlyNonEmptyArray<IO<any, any, any>>>(...ios: T): IO<_R<T[number]>, _E<T[number]>, {
+    [K in keyof T]: _A<T[K]>;
 }>;

package/IO/api/sleep.d.ts

@@ -1,5 +1,5 @@
-import { Lazy } from "@fncts/base/data/function";
-import { Duration } from "@fncts/base/data/Duration";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Duration } from "@fncts/base/data/Duration/definition";
 import { UIO } from "@fncts/io/IO/definition";
 /**
  * @tsplus static fncts.io.IOOps sleep

package/IO/api/stateful.d.ts

@@ -1,10 +1,9 @@
-import { Lazy } from "@fncts/base/data/function";
+import { Lazy } from "@fncts/base/data/function/definition";
 import { IO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
-import { Tag } from "@fncts/base/data/Tag";
+import { Tag } from "@fncts/base/data/Tag/definition";
 import { State } from "../../State.js";
 /**
  * @tsplus static fncts.io.IOOps stateful
  * @tsplus location "@fncts/io/IO/api/stateful"
  */
-export declare function stateful<S, R, E, A>(s: S, io: Lazy<IO<Has<State<S>> & R, E, A>>, tag: Tag<State<S>>, __tsplusTrace?: string): IO<R, E, A>;
+export declare function stateful<S, R, E, A>(s: S, io: Lazy<IO<State<S> | R, E, A>>, tag: Tag<State<S>>, __tsplusTrace?: string): IO<R, E, A>;

package/IO/api/timeout.d.ts

@@ -1,7 +1,7 @@
 import { IO } from "@fncts/io/IO/definition";
-import { Lazy } from "@fncts/base/data/function";
-import { Duration } from "@fncts/base/data/Duration";
-import { Maybe } from "@fncts/base/data/Maybe";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Duration } from "@fncts/base/data/Duration/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 /**
  * @tsplus fluent fncts.io.IO timeoutTo
  * @tsplus location "@fncts/io/IO/api/timeout"
@@ -11,4 +11,4 @@ export declare function timeoutTo<R, E, A, B, B1>(self: IO<R, E, A>, duration: L
  * @tsplus fluent fncts.io.IO timeout
  * @tsplus location "@fncts/io/IO/api/timeout"
  */
-export declare function timeout<R, E, A>(self: IO<R, E, A>, duration: Lazy<Duration>): IO<R, E, Maybe<A>>;
+export declare function timeout<R, E, A>(self: IO<R, E, A>, duration: Lazy<Duration>, __tsplusTrace?: string): IO<R, E, Maybe<A>>;

package/IO/api/withEarlyRelease.d.ts

@@ -1,5 +1,4 @@
 import { IO, UIO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Scope } from "@fncts/io/Scope/definition";
 /**
  * Returns a new scoped workflow that returns the result of this workflow as
@@ -7,4 +6,4 @@ import { Scope } from "@fncts/io/Scope/definition";
  * @tsplus getter fncts.io.IO withEarlyRelease
  * @tsplus location "@fncts/io/IO/api/withEarlyRelease"
  */
-export declare function withEarlyRelease<R, E, A>(self: IO<R, E, A>): IO<R & Has<Scope>, E, readonly [UIO<void>, A]>;
+export declare function withEarlyRelease<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R | Scope, E, readonly [UIO<void>, A]>;

package/IO/api/withFinalizer.d.ts

@@ -1,8 +1,7 @@
 import { IO, URIO } from "@fncts/io/IO/definition";
-import { Has } from "@fncts/base/typeclass/Has";
 import { Scope } from "@fncts/io/Scope/definition";
 /**
  * @tsplus fluent fncts.io.IO withFinalizer
  * @tsplus location "@fncts/io/IO/api/withFinalizer"
  */
-export declare function withFinalizer_<R, E, A, R1>(self: IO<R, E, A>, finalizer: (a: A) => URIO<R1, any>): IO<R & R1 & Has<Scope>, E, A>;
+export declare function withFinalizer_<R, E, A, R1>(self: IO<R, E, A>, finalizer: (a: A) => URIO<R1, any>, __tsplusTrace?: string): IO<R | R1 | Scope, E, A>;

package/IO/api/withFinalizerExit.d.ts

@@ -1,9 +1,8 @@
 import { IO, URIO } from "@fncts/io/IO/definition";
-import { Exit } from "@fncts/base/data/Exit";
-import { Has } from "@fncts/base/typeclass/Has";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 /**
  * @tsplus fluent fncts.io.IO withFinalizerExit
  * @tsplus location "@fncts/io/IO/api/withFinalizerExit"
  */
-export declare function withFinalizerExit_<R, E, A, R1>(self: IO<R, E, A>, finalizer: (a: A, exit: Exit<any, any>) => URIO<R1, any>): IO<R & R1 & Has<Scope>, E, A>;
+export declare function withFinalizerExit_<R, E, A, R1>(self: IO<R, E, A>, finalizer: (a: A, exit: Exit<any, any>) => URIO<R1, any>, __tsplusTrace?: string): IO<R | R1 | Scope, E, A>;

package/IO/api/withRuntimeConfig.d.ts

@@ -1,5 +1,5 @@
 import { IO } from "@fncts/io/IO/definition";
-import { Lazy } from "@fncts/base/data/function";
+import { Lazy } from "@fncts/base/data/function/definition";
 import { RuntimeConfig } from "@fncts/io/RuntimeConfig";
 /**
  * Runs the specified effect on the specified runtime configuration, restoring
@@ -7,4 +7,4 @@ import { RuntimeConfig } from "@fncts/io/RuntimeConfig";
  * @tsplus fluent fncts.io.IO withRuntimeConfig
  * @tsplus location "@fncts/io/IO/api/withRuntimeConfig"
  */
-export declare function withRuntimeConfig_<R, E, A>(self: IO<R, E, A>, runtimeConfig: Lazy<RuntimeConfig>): IO<R, E, A>;
+export declare function withRuntimeConfig_<R, E, A>(self: IO<R, E, A>, runtimeConfig: Lazy<RuntimeConfig>, __tsplusTrace?: string): IO<R, E, A>;

package/IO/api/zipC.d.ts

@@ -1,13 +1,13 @@
 import { IO } from "@fncts/io/IO/definition";
-import { Maybe } from "@fncts/base/data/Maybe";
-import { Either } from "@fncts/base/data/Either";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Either } from "@fncts/base/data/Either/definition";
 /**
  * @tsplus fluent fncts.io.IO zipC
  * @tsplus location "@fncts/io/IO/api/zipC"
  */
-export declare function zipC_<R, E, A, R1, E1, B>(self: IO<R, E, A>, that: IO<R1, E1, B>): IO<R & R1, E | E1, readonly [A, B]>;
+export declare function zipC_<R, E, A, R1, E1, B>(self: IO<R, E, A>, that: IO<R1, E1, B>, __tsplusTrace?: string): IO<R | R1, E | E1, readonly [A, B]>;
 /**
  * @tsplus fluent fncts.io.IO zipWithC
  * @tsplus location "@fncts/io/IO/api/zipC"
  */
-export declare function zipWithC_<R, E, A, R1, E1, B, C>(self: IO<R, E, A>, that: IO<R1, E1, B>, f: (a: A, b: B) => C): IO<R & R1, E | E1, C>;
+export declare function zipWithC_<R, E, A, R1, E1, B, C>(self: IO<R, E, A>, that: IO<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): IO<R | R1, E | E1, C>;