@fncts/io 0.0.10 → 0.0.13

package/STM/api.d.ts

@@ -2,8 +2,8 @@ import { Lazy } from "@fncts/base/data/function";
 import { Maybe } from "@fncts/base/data/Maybe";
 import { Either } from "@fncts/base/data/Either";
 import { FiberId } from "@fncts/base/data/FiberId";
-import { IO } from "@fncts/io/IO/definition";
 import { Environment } from "@fncts/base/data/Environment";
+import { IO } from "@fncts/io/IO/definition";
 import { Refinement } from "@fncts/base/data/Refinement";
 import { Predicate } from "@fncts/base/data/Predicate";
 import type { Journal } from "./internal/Journal.js";
@@ -37,25 +37,25 @@ export declare function absolve<R, E, E1, A>(z: STM<R, E, Either<E1, A>>): STM<R
  * @tsplus static fncts.io.STMOps Effect
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function makeEffect<R, E, A>(f: (journal: Journal, fiberId: FiberId, r: R) => A): STM<R, E, A>;
+export declare function makeEffect<R, E, A>(f: (journal: Journal, fiberId: FiberId, r: Environment<R>) => A): STM<R, E, A>;
 /**
  * Retrieves the environment inside an stm.
  * @tsplus static fncts.io.STMOps environment
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function environment<R>(): STM<R, never, R>;
+export declare function environment<R>(): STM<R, never, Environment<R>>;
 /**
  * Accesses the environment of the transaction.
  * @tsplus static fncts.io.STMOps environmentWith
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function environmentWith<R, A>(f: (r: R) => A): STM<R, never, A>;
+export declare function environmentWith<R, A>(f: (r: Environment<R>) => A): STM<R, never, A>;
 /**
  * Accesses the environment of the transaction to perform a transaction.
  * @tsplus static fncts.io.STMOps environmentWithSTM
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function environmentWithSTM<R0, R, E, A>(f: (r: R0) => STM<R, E, A>): STM<R & R0, E, A>;
+export declare function environmentWithSTM<R0, R, E, A>(f: (r: Environment<R0>) => STM<R, E, A>): STM<R0 | R, E, A>;
 /**
  * @tsplus static fncts.io.STMOps atomically
  * @tsplus getter fncts.io.STM commit
@@ -74,7 +74,7 @@ export declare function bimap_<R, E, A, E1, B>(stm: STM<R, E, A>, g: (e: E) => E
  */
 export declare function catch_<N extends keyof E, K extends E[N] & string, E, R, A, R1, E1, A1>(stm: STM<R, E, A>, tag: N, k: K, f: (e: Extract<E, {
     [n in N]: K;
-}>) => STM<R1, E1, A1>): STM<R & R1, Exclude<E, {
+}>) => STM<R1, E1, A1>): STM<R | R1, Exclude<E, {
     [n in N]: K;
 }> | E1, A | A1>;
 /**
@@ -82,7 +82,7 @@ export declare function catch_<N extends keyof E, K extends E[N] & string, E, R,
  * @tsplus fluent fncts.io.STM catchJust
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function catchJust_<R, E, A, R1, E1, B>(stm: STM<R, E, A>, f: (e: E) => Maybe<STM<R1, E1, B>>): STM<R1 & R, E | E1, A | B>;
+export declare function catchJust_<R, E, A, R1, E1, B>(stm: STM<R, E, A>, f: (e: E) => Maybe<STM<R1, E1, B>>): STM<R1 | R, E | E1, A | B>;
 /**
  * Recovers from specified error.
  * @tsplus fluent fncts.io.STM catchTag
@@ -92,7 +92,7 @@ export declare function catchTag_<K extends E["_tag"] & string, E extends {
     _tag: string;
 }, R, A, R1, E1, A1>(stm: STM<R, E, A>, k: K, f: (e: Extract<E, {
     _tag: K;
-}>) => STM<R1, E1, A1>): STM<R & R1, Exclude<E, {
+}>) => STM<R1, E1, A1>): STM<R | R1, Exclude<E, {
     _tag: K;
 }> | E1, A | A1>;
 /**
@@ -101,13 +101,13 @@ export declare function catchTag_<K extends E["_tag"] & string, E extends {
  * @tsplus fluent fncts.io.STM flatMapError
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function chainError_<R, E, A, R2, E2>(stm: STM<R, E, A>, f: (e: E) => STM<R2, never, E2>): STM<R2 & R, E2, A>;
+export declare function chainError_<R, E, A, R2, E2>(stm: STM<R, E, A>, f: (e: E) => STM<R2, never, E2>): STM<R2 | R, E2, A>;
 /**
  * Checks the condition, and if it's true, returns unit, otherwise, retries.
  * @tsplus static fncts.io.STMOps check
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function check(predicate: () => boolean): STM<unknown, never, void>;
+export declare function check(predicate: () => boolean): STM<never, never, void>;
 /**
  * Commits this transaction atomically, regardless of whether the transaction
  * is a success or a failure.
@@ -126,7 +126,7 @@ export declare function continueOrFail_<R, E, E1, A, A2>(fa: STM<R, E, A>, e: La
  * @tsplus fluent fncts.io.STM continueOrFailSTM
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function continueOrFailSTM_<R, E, E1, A, R2, E2, A2>(fa: STM<R, E, A>, e: Lazy<E1>, pf: (a: A) => Maybe<STM<R2, E2, A2>>): STM<R2 & R, E | E1 | E2, A2>;
+export declare function continueOrFailSTM_<R, E, E1, A, R2, E2, A2>(fa: STM<R, E, A>, e: Lazy<E1>, pf: (a: A) => Maybe<STM<R2, E2, A2>>): STM<R2 | R, E | E1 | E2, A2>;
 /**
  * Fail with `e` if the supplied `PartialFunction` does not match, otherwise
  * succeed with the returned value.
@@ -140,7 +140,7 @@ export declare function continueOrRetry_<R, E, A, A2>(fa: STM<R, E, A>, pf: (a:
  * @tsplus fluent fncts.io.STM continueOrRetrySTM
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function continueOrRetrySTM_<R, E, A, R2, E2, A2>(fa: STM<R, E, A>, pf: (a: A) => Maybe<STM<R2, E2, A2>>): STM<R2 & R, E | E2, A2>;
+export declare function continueOrRetrySTM_<R, E, A, R2, E2, A2>(fa: STM<R, E, A>, pf: (a: A) => Maybe<STM<R2, E2, A2>>): STM<R2 | R, E | E2, A2>;
 /**
  * Suspends creation of the specified transaction lazily.
  * @tsplus static fncts.io.STMOps defer
@@ -171,14 +171,14 @@ export declare function filterMap_<R, E, A, B>(stm: STM<R, E, A>, f: (a: A) => M
  * @tsplus fluent fncts.io.STM filterMapSTM
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function filterMapSTM_<R, E, A, R1, E1, B>(self: STM<R, E, A>, f: (a: A) => Maybe<STM<R1, E1, B>>): STM<R & R1, E | E1, B>;
+export declare function filterMapSTM_<R, E, A, R1, E1, B>(self: STM<R, E, A>, f: (a: A) => Maybe<STM<R1, E1, B>>): STM<R | R1, E | E1, B>;
 /**
  * Applies `or` if the predicate fails.
  * @tsplus fluent fncts.io.STM filterOrElse
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function filterOrElse_<R, E, A, B extends A, R2, E2, A2>(fa: STM<R, E, A>, p: Refinement<A, B>, or: (a: Exclude<A, B>) => STM<R2, E2, A2>): STM<R & R2, E | E2, B | A2>;
-export declare function filterOrElse_<R, E, A, R2, E2, A2>(fa: STM<R, E, A>, p: Predicate<A>, or: (a: A) => STM<R2, E2, A2>): STM<R & R2, E | E2, A | A2>;
+export declare function filterOrElse_<R, E, A, B extends A, R2, E2, A2>(fa: STM<R, E, A>, p: Refinement<A, B>, or: (a: Exclude<A, B>) => STM<R2, E2, A2>): STM<R | R2, E | E2, B | A2>;
+export declare function filterOrElse_<R, E, A, R2, E2, A2>(fa: STM<R, E, A>, p: Predicate<A>, or: (a: A) => STM<R2, E2, A2>): STM<R | R2, E | E2, A | A2>;
 /**
  * Fails with `failWith` if the predicate fails.
  * @tsplus fluent fncts.io.STM filterOrFail
@@ -198,7 +198,7 @@ export declare function filterOrHalt_<R, E, A>(fa: STM<R, E, A>, p: Predicate<A>
  * @tsplus getter fncts.io.STM flatten
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function flatten<R, E, R1, E1, B>(stm: STM<R, E, STM<R1, E1, B>>): STM<R1 & R, E | E1, B>;
+export declare function flatten<R, E, R1, E1, B>(stm: STM<R, E, STM<R1, E1, B>>): STM<R1 | R, E | E1, B>;
 /**
  * Unwraps the optional error, defaulting to the provided value.
  * @tsplus fluent fncts.io.STM flattenErrorOption
@@ -217,13 +217,13 @@ export declare function foreach_<A, R, E, B>(it: Iterable<A>, f: (a: A) => STM<R
  * @tsplus static fncts.io.STMOps fromEither
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function fromEither<E, A>(e: Lazy<Either<E, A>>): STM<unknown, E, A>;
+export declare function fromEither<E, A>(e: Lazy<Either<E, A>>): STM<never, E, A>;
 /**
  * Lifts an `Either` into a `STM`.
  * @tsplus static fncts.io.STMOps fromEitherNow
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function fromEitherNow<E, A>(e: Either<E, A>): STM<unknown, E, A>;
+export declare function fromEitherNow<E, A>(e: Either<E, A>): STM<never, E, A>;
 /**
  * Unwraps the optional success of this effect, but can fail with an None value.
  */
@@ -234,26 +234,26 @@ export declare function get<R, E, A>(stm: STM<R, E, Maybe<A>>): STM<R, Maybe<E>,
  * @tsplus fluent fncts.io.STM provideEnvironment
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function provideEnvironment_<R, E, A>(stm: STM<R, E, A>, r: R): STM<unknown, E, A>;
+export declare function provideEnvironment_<R, E, A>(stm: STM<R, E, A>, r: Environment<R>): STM<never, E, A>;
 /**
  * Provides some of the environment required to run this effect,
  * leaving the remainder `R0`.
  * @tsplus fluent fncts.io.STM contramapEnvironment
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function contramapEnvironment_<R, E, A, R0>(self: STM<R, E, A>, f: (r: R0) => R): STM<R0, E, A>;
+export declare function contramapEnvironment_<R, E, A, R0>(self: STM<R, E, A>, f: (r: Environment<R0>) => Environment<R>): STM<R0, E, A>;
 /**
  * Halts the fiber running the effect.
  * @tsplus static fncts.io.STMOps halt
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function halt(u: Lazy<unknown>): STM<unknown, never, never>;
+export declare function halt(u: Lazy<unknown>): STM<never, never, never>;
 /**
  * Halts the fiber running the effect.
  * @tsplus static fncts.io.STMOps haltNow
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function haltNow(u: unknown): STM<unknown, never, never>;
+export declare function haltNow(u: unknown): STM<never, never, never>;
 /**
  * Returns a successful effect with the head of the list if the list is
  * non-empty or fails with the error `None` if the list is empty.
@@ -266,7 +266,7 @@ export declare function head<R, E, A>(stm: STM<R, E, Iterable<A>>): STM<R, Maybe
  * @tsplus static fncts.io.STMOps interrupt
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare const interrupt: STM<unknown, never, never>;
+export declare const interrupt: STM<never, never, never>;
 /**
  * Returns whether this effect is a failure.
  * @tsplus getter fncts.io.STM isFailure
@@ -279,18 +279,6 @@ export declare function isFailure<R, E, A>(stm: STM<R, E, A>): STM<R, never, boo
  * @tsplus location "@fncts/io/STM/api"
  */
 export declare function isSuccess<R, E, A>(stm: STM<R, E, A>): STM<R, never, boolean>;
-/**
- * Depending on provided environment returns either this one or the other effect.
- * @tsplus fluent fncts.io.STM join
- * @tsplus location "@fncts/io/STM/api"
- */
-export declare function join_<R, E, A, R1, E1, A1>(stm: STM<R, E, A>, that: STM<R1, E1, A1>): STM<Either<R, R1>, E | E1, A | A1>;
-/**
- * Depending on provided environment returns either this one or the other effect.
- * @tsplus fluent fncts.io.STM joinEither
- * @tsplus location "@fncts/io/STM/api"
- */
-export declare function joinEither_<R, E, A, R1, E1, A1>(stm: STM<R, E, A>, that: STM<R1, E1, A1>): STM<Either<R, R1>, E | E1, Either<A, A1>>;
 /**
  * Returns a successful effect if the value is `Left`, or fails with the error `None`.
  * @tsplus getter fncts.io.STM left
@@ -364,23 +352,23 @@ export declare function swapWith_<R, E, A, R2, E2, A2>(stm: STM<R, E, A>, f: (st
  * @tsplus fluent fncts.io.STM tap
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function tap_<R, E, A, R1, E1, B>(stm: STM<R, E, A>, f: (a: A) => STM<R1, E1, B>): STM<R1 & R, E | E1, A>;
+export declare function tap_<R, E, A, R1, E1, B>(stm: STM<R, E, A>, f: (a: A) => STM<R1, E1, B>): STM<R1 | R, E | E1, A>;
 /**
  * Returns an effect with the value on the left part.
  * @tsplus static fncts.io.STMOps toLeft
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function toLeft<A>(a: Lazy<A>): STM<unknown, never, Either<A, never>>;
+export declare function toLeft<A>(a: Lazy<A>): STM<never, never, Either<A, never>>;
 /**
  * Returns an `STM` effect that succeeds with `Unit`.
  * @tsplus static fncts.io.STMOps unit
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare const unit: STM<unknown, never, void>;
+export declare const unit: STM<never, never, void>;
 /**
  * Sequentially zips this value with the specified one, combining the values
  * using the specified combiner function.
  * @tsplus fluent fncts.io.STM zipWith
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function zipWith_<R, E, A, R1, E1, B, C>(self: STM<R, E, A>, that: STM<R1, E1, B>, f: (a: A, b: B) => C): STM<R & R1, E | E1, C>;
+export declare function zipWith_<R, E, A, R1, E1, B, C>(self: STM<R, E, A>, that: STM<R1, E1, B>, f: (a: A, b: B) => C): STM<R | R1, E | E1, C>;

package/STM/definition.d.ts

@@ -1,4 +1,5 @@
 import { FiberId } from "@fncts/base/data/FiberId";
+import { Environment } from "@fncts/base/data/Environment";
 import type { Journal } from "./internal/Journal.js";
 import type { _A, _E, _R } from "@fncts/base/types";
 export declare const enum STMTag {
@@ -18,7 +19,7 @@ export declare type STMTypeId = typeof STMTypeId;
  */
 export declare abstract class STM<R, E, A> {
     readonly _typeId: STMTypeId;
-    readonly _R: (_: R) => void;
+    readonly _R: () => R;
     readonly _E: () => E;
     readonly _A: () => A;
 }
@@ -29,12 +30,12 @@ export declare function unifySTM<X extends STM<any, any, any>>(self: X): STM<_R<
 /**
  * @tsplus type fncts.io.STM
  */
-export interface USTM<A> extends STM<unknown, never, A> {
+export interface USTM<A> extends STM<never, never, A> {
 }
 export declare class Effect<R, E, A> extends STM<R, E, A> {
-    readonly f: (journal: Journal, fiberId: FiberId, r: R) => A;
+    readonly f: (journal: Journal, fiberId: FiberId, r: Environment<R>) => A;
     readonly _tag = STMTag.Effect;
-    constructor(f: (journal: Journal, fiberId: FiberId, r: R) => A);
+    constructor(f: (journal: Journal, fiberId: FiberId, r: Environment<R>) => A);
 }
 export declare class OnFailure<R, E, A, E1> extends STM<R, E1, A> {
     readonly stm: STM<R, E, A>;
@@ -56,21 +57,21 @@ export declare class OnSuccess<R, E, A, B> extends STM<R, E, B> {
     readonly _tag = STMTag.OnSuccess;
     constructor(stm: STM<R, E, A>, apply: (a: A) => STM<R, E, B>);
 }
-export declare class Succeed<A> extends STM<unknown, never, A> {
+export declare class Succeed<A> extends STM<never, never, A> {
     readonly a: () => A;
     readonly _tag = STMTag.Succeed;
     constructor(a: () => A);
 }
-export declare class SucceedNow<A> extends STM<unknown, never, A> {
+export declare class SucceedNow<A> extends STM<never, never, A> {
     readonly a: A;
     readonly _tag = STMTag.SucceedNow;
     constructor(a: A);
 }
 export declare class ContramapEnvironment<R, E, A, R0> extends STM<R0, E, A> {
     readonly stm: STM<R, E, A>;
-    readonly f: (_: R0) => R;
+    readonly f: (_: Environment<R0>) => Environment<R>;
     readonly _tag = STMTag.ContramapEnvironment;
-    constructor(stm: STM<R, E, A>, f: (_: R0) => R);
+    constructor(stm: STM<R, E, A>, f: (_: Environment<R0>) => Environment<R>);
 }
 export declare function concrete<R, E, A>(_: STM<R, E, A>): asserts _ is Effect<R, E, A> | OnFailure<R, unknown, A, E> | OnSuccess<R, E, unknown, A> | OnRetry<R, E, A> | Succeed<A> | SucceedNow<A> | ContramapEnvironment<unknown, E, A, R>;
 export declare const FailExceptionTypeId: unique symbol;

package/STM/driver.d.ts

@@ -1,6 +1,6 @@
 import { STM } from "@fncts/io/STM/definition";
-import { FiberId } from "@fncts/base/data/FiberId";
 import { Environment } from "@fncts/base/data/Environment";
+import { FiberId } from "@fncts/base/data/FiberId";
 import { TExit } from "@fncts/io/TExit/definition";
 import type { Journal } from "./internal/Journal.js";
 export declare class STMDriver<R, E, A> {

package/STM/internal/Journal.d.ts

@@ -6,6 +6,7 @@ import { IO } from "@fncts/io/IO/definition";
 import type { Entry } from "./Entry.js";
 import type { TryCommit } from "./TryCommit.js";
 import type { AtomicReference } from "@fncts/base/internal/AtomicReference";
+import type { Scheduler } from "@fncts/io/internal/Scheduler";
 import type { Atomic } from "@fncts/io/TRef";
 import type { TxnId } from "@fncts/io/TxnId";
 import { CommitState } from "./CommitState.js";
@@ -72,7 +73,7 @@ export declare function execTodos(todos: Map<TxnId, Todo>): void;
  * @tsplus fluent fncts.io.Journal completeTodos
  * @tsplus location "@fncts/io/STM/internal/Journal"
  */
-export declare function completeTodos<E, A>(journal: Journal, exit: Exit<E, A>): Done<E, A>;
+export declare function completeTodos<E, A>(journal: Journal, exit: Exit<E, A>, scheduler: Scheduler): Done<E, A>;
 /**
  * For the given transaction id, adds the specified todo effect to all
  * `TRef` values.
@@ -84,8 +85,8 @@ export declare function addTodo(journal: Journal, txnId: TxnId, todoEffect: Todo
  * Finds all the new todo targets that are not already tracked in the `oldJournal`.
  */
 export declare function untrackedTodoTargets(oldJournal: Journal, newJournal: Journal): Journal;
-export declare function tryCommitSync<R, E, A>(fiberId: FiberId, stm: STM<R, E, A>, r: Environment<R>): TryCommit<E, A>;
-export declare function tryCommitAsync<R, E, A>(journal: Journal | undefined, fiberId: FiberId, stm: STM<R, E, A>, txnId: TxnId, state: AtomicReference<CommitState<E, A>>, r: Environment<R>): (k: (_: IO<R, E, A>) => unknown) => void;
+export declare function tryCommitSync<R, E, A>(fiberId: FiberId, stm: STM<R, E, A>, r: Environment<R>, scheduler: Scheduler): TryCommit<E, A>;
+export declare function tryCommitAsync<R, E, A>(journal: Journal | undefined, fiberId: FiberId, stm: STM<R, E, A>, txnId: TxnId, state: AtomicReference<CommitState<E, A>>, r: Environment<R>, scheduler: Scheduler): (k: (_: IO<R, E, A>) => unknown) => void;
 /**
  * Determines if the journal is valid.
  * @tsplus getter fncts.io.Journal isValid

package/Schedule/Decision.d.ts

@@ -1,12 +1,13 @@
+import { Intervals } from "@fncts/base/data/Intervals";
 import { Interval } from "@fncts/base/data/Interval";
 export declare const enum DecisionTag {
     Continue = "Continue",
     Done = "Done"
 }
 export declare class Continue {
-    readonly interval: Interval;
+    readonly interval: Intervals;
     readonly _tag = DecisionTag.Continue;
-    constructor(interval: Interval);
+    constructor(interval: Intervals);
 }
 export declare class Done {
     readonly _tag = DecisionTag.Done;
@@ -30,9 +31,14 @@ export declare const done: Decision;
  * @tsplus static fncts.io.Schedule.DecisionOps Continue
  * @tsplus location "@fncts/io/Schedule/Decision"
  */
-export declare function continue_(interval: Interval): Decision;
+export declare function continue_(interval: Intervals): Decision;
+/**
+ * @tsplus static fncts.io.Schedule.DecisionOps continueWith
+ * @tsplus location "@fncts/io/Schedule/Decision"
+ */
+export declare function continueWith(interval: Interval): Decision;
 /**
  * @tsplus fluent fncts.io.Schedule.Decision match
  * @tsplus location "@fncts/io/Schedule/Decision"
  */
-export declare function match_<A, B>(self: Decision, onDone: () => A, onContinue: (interval: Interval) => B): A | B;
+export declare function match_<A, B>(self: Decision, onDone: () => A, onContinue: (interval: Intervals) => B): A | B;

package/Schedule/Driver.d.ts

@@ -7,13 +7,13 @@ import { NoSuchElementError } from "@fncts/base/data/exceptions";
  */
 export declare class Driver<State, Env, In, Out> {
     readonly next: (inp: In, __tsplusTrace?: string) => IO<Env, Nothing, Out>;
-    readonly last: IO<unknown, NoSuchElementError, Out>;
+    readonly last: IO<never, NoSuchElementError, Out>;
     readonly reset: UIO<void>;
     readonly state: UIO<State>;
-    constructor(next: (inp: In, __tsplusTrace?: string) => IO<Env, Nothing, Out>, last: IO<unknown, NoSuchElementError, Out>, reset: UIO<void>, state: UIO<State>);
+    constructor(next: (inp: In, __tsplusTrace?: string) => IO<Env, Nothing, Out>, last: IO<never, NoSuchElementError, Out>, reset: UIO<void>, state: UIO<State>);
 }
 /**
  * @tsplus static fncts.io.Schedule.DriverOps __call
  * @tsplus location "@fncts/io/Schedule/Driver"
  */
-export declare function makeDriver<State, Env, In, Out>(next: (inp: In, __tsplusTrace?: string) => IO<Env, Nothing, Out>, last: IO<unknown, NoSuchElementError, Out>, reset: UIO<void>, state: UIO<State>): Driver<State, Env, In, Out>;
+export declare function makeDriver<State, Env, In, Out>(next: (inp: In, __tsplusTrace?: string) => IO<Env, Nothing, Out>, last: IO<never, NoSuchElementError, Out>, reset: UIO<void>, state: UIO<State>): Driver<State, Env, In, Out>;