effect 2.0.5 → 2.1.0

package/dist/dts/Effect.d.ts

@@ -1192,27 +1192,51 @@ export declare const parallelErrors: <R, E, A>(self: Effect<R, E, A>) => Effect<
  */
 export declare const sandbox: <R, E, A>(self: Effect<R, E, A>) => Effect<R, Cause.Cause<E>, A>;
 /**
- * Retries with the specified retry policy. Retries are done following the
- * failure of the original `io` (up to a fixed maximum with `once` or `recurs`
- * for example), so that that `io.retry(Schedule.once)` means "execute `io`
- * and in case of failure, try again once".
- *
  * @since 2.0.0
  * @category error handling
  */
-export declare const retry: {
-    <R1, E extends E0, E0, B>(policy: Schedule.Schedule<R1, E0, B>): <R, A>(self: Effect<R, E, A>) => Effect<R1 | R, E, A>;
-    <R, E extends E0, E0, A, R1, B>(self: Effect<R, E, A>, policy: Schedule.Schedule<R1, E0, B>): Effect<R | R1, E, A>;
-};
+export declare namespace Retry {
+    /**
+     * @since 2.0.0
+     * @category error handling
+     */
+    type Return<R, E, A, O extends Options<E>> = Effect<R | (O extends {
+        schedule: Schedule.Schedule<infer X, infer _I, infer _O>;
+    } ? X : never) | (O extends {
+        while: (...args: Array<any>) => Effect<infer X, infer _E, infer _A>;
+    } ? X : never) | (O extends {
+        until: (...args: Array<any>) => Effect<infer X, infer _E, infer _A>;
+    } ? X : never), (O extends {
+        schedule: Schedule.Schedule<infer _R, infer _I, infer _O>;
+    } ? E : O extends {
+        until: Refinement<E, infer E2>;
+    } ? E2 : E) | (O extends {
+        while: (...args: Array<any>) => Effect<infer _R, infer X, infer _A>;
+    } ? X : never) | (O extends {
+        until: (...args: Array<any>) => Effect<infer _R, infer X, infer _A>;
+    } ? X : never), A> extends infer Z ? Z : never;
+    /**
+     * @since 2.0.0
+     * @category error handling
+     */
+    interface Options<E> {
+        while?: (error: E) => boolean | Effect<any, any, boolean>;
+        until?: (error: E) => boolean | Effect<any, any, boolean>;
+        times?: number;
+        schedule?: Schedule.Schedule<any, E, any>;
+    }
+}
 /**
- * Retries this effect the specified number of times.
+ * Retries according to the options provided
  *
  * @since 2.0.0
  * @category error handling
  */
-export declare const retryN: {
-    (n: number): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(self: Effect<R, E, A>, n: number): Effect<R, E, A>;
+export declare const retry: {
+    <E, O extends Retry.Options<E>>(options: O): <R, A>(self: Effect<R, E, A>) => Retry.Return<R, E, A, O>;
+    <R1, E extends E0, E0, B>(policy: Schedule.Schedule<R1, E0, B>): <R, A>(self: Effect<R, E, A>) => Effect<R1 | R, E, A>;
+    <R, A, E, O extends Retry.Options<E>>(self: Effect<R, E, A>, options: O): Retry.Return<R, E, A, O>;
+    <R, E extends E0, E0, A, R1, B>(self: Effect<R, E, A>, policy: Schedule.Schedule<R1, E0, B>): Effect<R | R1, E, A>;
 };
 /**
  * Retries with the specified schedule, until it fails, and then both the
@@ -1226,50 +1250,6 @@ export declare const retryOrElse: {
     <R1, E extends E3, A1, R2, E2, A2, E3>(policy: Schedule.Schedule<R1, E3, A1>, orElse: (e: E, out: A1) => Effect<R2, E2, A2>): <R, A>(self: Effect<R, E, A>) => Effect<R1 | R2 | R, E | E2, A2 | A>;
     <R, E extends E3, A, R1, A1, R2, E2, A2, E3>(self: Effect<R, E, A>, policy: Schedule.Schedule<R1, E3, A1>, orElse: (e: E, out: A1) => Effect<R2, E2, A2>): Effect<R | R1 | R2, E | E2, A | A2>;
 };
-/**
- * Retries this effect until its error satisfies the specified predicate.
- *
- * @since 2.0.0
- * @category error handling
- */
-export declare const retryUntil: {
-    <E, E2 extends E>(f: Refinement<E, E2>): <R, A>(self: Effect<R, E, A>) => Effect<R, E2, A>;
-    <E>(f: Predicate<E>): <R, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A, E2 extends E>(self: Effect<R, E, A>, f: Refinement<E, E2>): Effect<R, E2, A>;
-    <R, E, A>(self: Effect<R, E, A>, f: Predicate<E>): Effect<R, E, A>;
-};
-/**
- * Retries this effect until its error satisfies the specified effectful
- * predicate.
- *
- * @since 2.0.0
- * @category error handling
- */
-export declare const retryUntilEffect: {
-    <R1, E, E2>(f: (e: E) => Effect<R1, E2, boolean>): <R, A>(self: Effect<R, E, A>) => Effect<R1 | R, E | E2, A>;
-    <R, E, A, R1, E2>(self: Effect<R, E, A>, f: (e: E) => Effect<R1, E2, boolean>): Effect<R | R1, E | E2, A>;
-};
-/**
- * Retries this effect while its error satisfies the specified predicate.
- *
- * @since 2.0.0
- * @category error handling
- */
-export declare const retryWhile: {
-    <E>(f: Predicate<E>): <R, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(self: Effect<R, E, A>, f: Predicate<E>): Effect<R, E, A>;
-};
-/**
- * Retries this effect while its error satisfies the specified effectful
- * predicate.
- *
- * @since 2.0.0
- * @category error handling
- */
-export declare const retryWhileEffect: {
-    <R1, E, E2>(f: (e: E) => Effect<R1, E2, boolean>): <R, A>(self: Effect<R, E, A>) => Effect<R1 | R, E | E2, A>;
-    <R, E, A, R1, E2>(self: Effect<R, E, A>, f: (e: E) => Effect<R1, E2, boolean>): Effect<R | R1, E | E2, A>;
-};
 declare const try_: {
     <A, E>(options: {
         readonly try: LazyArg<A>;
@@ -2901,6 +2881,41 @@ export declare const loop: {
         readonly discard: true;
     }): Effect<R, E, void>;
 };
+/**
+ * @since 2.0.0
+ * @category repetition / recursion
+ */
+export declare namespace Repeat {
+    /**
+     * @since 2.0.0
+     * @category repetition / recursion
+     */
+    type Return<R, E, A, O extends Options<A>> = Effect<R | (O extends {
+        schedule: Schedule.Schedule<infer X, infer _I, infer _O>;
+    } ? X : never) | (O extends {
+        while: (...args: Array<any>) => Effect<infer X, infer _E, infer _A>;
+    } ? X : never) | (O extends {
+        until: (...args: Array<any>) => Effect<infer X, infer _E, infer _A>;
+    } ? X : never), E | (O extends {
+        while: (...args: Array<any>) => Effect<infer _R, infer X, infer _A>;
+    } ? X : never) | (O extends {
+        until: (...args: Array<any>) => Effect<infer _R, infer X, infer _A>;
+    } ? X : never), (O extends {
+        schedule: Schedule.Schedule<infer _R, infer _I, infer Out>;
+    } ? Out : O extends {
+        until: Refinement<A, infer B>;
+    } ? B : A)> extends infer Z ? Z : never;
+    /**
+     * @since 2.0.0
+     * @category repetition / recursion
+     */
+    interface Options<A> {
+        while?: (_: A) => boolean | Effect<any, any, boolean>;
+        until?: (_: A) => boolean | Effect<any, any, boolean>;
+        times?: number;
+        schedule?: Schedule.Schedule<any, A, any>;
+    }
+}
 /**
  * Returns a new effect that repeats this effect according to the specified
  * schedule or until the first failure. Scheduled recurrences are in addition
@@ -2912,7 +2927,9 @@ export declare const loop: {
  * @category repetition / recursion
  */
 export declare const repeat: {
+    <A, O extends Repeat.Options<A>>(options: O): <R, E>(self: Effect<R, E, A>) => Repeat.Return<R, E, A, O>;
     <R1, A extends A0, A0, B>(schedule: Schedule.Schedule<R1, A, B>): <R, E>(self: Effect<R, E, A>) => Effect<R1 | R, E, B>;
+    <R, E, A, O extends Repeat.Options<A>>(self: Effect<R, E, A>, options: O): Repeat.Return<R, E, A, O>;
     <R, E, A extends A0, A0, R1, B>(self: Effect<R, E, A>, schedule: Schedule.Schedule<R1, A0, B>): Effect<R | R1, E, B>;
 };
 /**
@@ -2944,52 +2961,6 @@ export declare const repeatOrElse: {
     <R2, A extends A0, A0, B, E, R3, E2>(schedule: Schedule.Schedule<R2, A, B>, orElse: (error: E, option: Option.Option<B>) => Effect<R3, E2, B>): <R>(self: Effect<R, E, A>) => Effect<R2 | R3 | R, E2, B>;
     <R, E, A extends A0, A0, R2, B, R3, E2>(self: Effect<R, E, A>, schedule: Schedule.Schedule<R2, A0, B>, orElse: (error: E, option: Option.Option<B>) => Effect<R3, E2, B>): Effect<R | R2 | R3, E2, B>;
 };
-/**
- * Repeats this effect until its value satisfies the specified predicate or
- * until the first failure.
- *
- * @since 2.0.0
- * @category repetition / recursion
- */
-export declare const repeatUntil: {
-    <A, B extends A>(f: Refinement<A, B>): <R, E>(self: Effect<R, E, A>) => Effect<R, E, B>;
-    <A>(f: Predicate<A>): <R, E>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A, B extends A>(self: Effect<R, E, A>, f: Predicate<A>): Effect<R, E, B>;
-    <R, E, A>(self: Effect<R, E, A>, f: Predicate<A>): Effect<R, E, A>;
-};
-/**
- * Repeats this effect until its value satisfies the specified effectful
- * predicate or until the first failure.
- *
- * @since 2.0.0
- * @category repetition / recursion
- */
-export declare const repeatUntilEffect: {
-    <A, R2, E2>(f: (a: A) => Effect<R2, E2, boolean>): <R, E>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A>;
-    <R, E, A, R2, E2>(self: Effect<R, E, A>, f: (a: A) => Effect<R2, E2, boolean>): Effect<R | R2, E | E2, A>;
-};
-/**
- * Repeats this effect while its value satisfies the specified effectful
- * predicate or until the first failure.
- *
- * @since 2.0.0
- * @category repetition / recursion
- */
-export declare const repeatWhile: {
-    <A>(f: Predicate<A>): <R, E>(self: Effect<R, E, A>) => Effect<R, E, A>;
-    <R, E, A>(self: Effect<R, E, A>, f: Predicate<A>): Effect<R, E, A>;
-};
-/**
- * Repeats this effect while its value satisfies the specified effectful
- * predicate or until the first failure.
- *
- * @since 2.0.0
- * @category repetition / recursion
- */
-export declare const repeatWhileEffect: {
-    <R1, A, E2>(f: (a: A) => Effect<R1, E2, boolean>): <R, E>(self: Effect<R, E, A>) => Effect<R1 | R, E2 | E, A>;
-    <R, E, R1, A, E2>(self: Effect<R, E, A>, f: (a: A) => Effect<R1, E2, boolean>): Effect<R | R1, E | E2, A>;
-};
 /**
  * Runs this effect according to the specified schedule.
  *
@@ -3470,12 +3441,12 @@ export declare const makeSemaphore: (permits: number) => Effect<never, never, Se
  * @since 2.0.0
  * @category execution
  */
-export declare const runFork: <E, A>(effect: Effect<never, E, A>) => Fiber.RuntimeFiber<E, A>;
+export declare const runFork: <E, A>(effect: Effect<never, E, A>, options?: Runtime.RunForkOptions) => Fiber.RuntimeFiber<E, A>;
 /**
  * @since 2.0.0
  * @category execution
  */
-export declare const runCallback: <E, A>(effect: Effect<never, E, A>, onExit?: (exit: Exit.Exit<E, A>) => void) => Runtime.Cancel<E, A>;
+export declare const runCallback: <E, A>(effect: Effect<never, E, A>, options?: Runtime.RunCallbackOptions<E, A> | undefined) => Runtime.Cancel<E, A>;
 /**
  * Runs an `Effect` workflow, returning a `Promise` which resolves with the
  * result of the workflow or rejects with an error.