effect 2.0.5 → 2.1.0

package/src/Effect.ts

@@ -1759,29 +1759,58 @@ export const parallelErrors: <R, E, A>(self: Effect<R, E, A>) => Effect<R, Array
 export const sandbox: <R, E, A>(self: Effect<R, E, A>) => Effect<R, Cause.Cause<E>, A> = effect.sandbox
 
 /**
- * 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 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>
-} = _schedule.retry_Effect
+export declare namespace Retry {
+  /**
+   * @since 2.0.0
+   * @category error handling
+   */
+  export 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
+   */
+  export 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 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>
-} = _schedule.retryN_Effect
+export 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>
+} = _schedule.retry_combined
 
 /**
  * Retries with the specified schedule, until it fails, and then both the
@@ -1803,54 +1832,6 @@ export const retryOrElse: {
   ): Effect<R | R1 | R2, E | E2, A | A2>
 } = _schedule.retryOrElse_Effect
 
-/**
- * Retries this effect until its error satisfies the specified predicate.
- *
- * @since 2.0.0
- * @category error handling
- */
-export 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>
-} = _schedule.retryUntil_Effect
-
-/**
- * Retries this effect until its error satisfies the specified effectful
- * predicate.
- *
- * @since 2.0.0
- * @category error handling
- */
-export 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>
-} = _schedule.retryUntilEffect_Effect
-
-/**
- * Retries this effect while its error satisfies the specified predicate.
- *
- * @since 2.0.0
- * @category error handling
- */
-export 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>
-} = _schedule.retryWhile_Effect
-
-/**
- * Retries this effect while its error satisfies the specified effectful
- * predicate.
- *
- * @since 2.0.0
- * @category error handling
- */
-export 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>
-} = _schedule.retryWhileEffect_Effect
-
 const try_: {
   <A, E>(options: { readonly try: LazyArg<A>; readonly catch: (error: unknown) => E }): Effect<never, E, A>
   <A>(evaluate: LazyArg<A>): Effect<never, Cause.UnknownException, A>
@@ -3994,6 +3975,40 @@ export const loop: {
   ): Effect<R, E, void>
 } = effect.loop
 
+/**
+ * @since 2.0.0
+ * @category repetition / recursion
+ */
+export declare namespace Repeat {
+  /**
+   * @since 2.0.0
+   * @category repetition / recursion
+   */
+  export 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
+   */
+  export 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
@@ -4005,11 +4020,20 @@ export const loop: {
  * @category repetition / recursion
  */
 export 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>
-} = _schedule.repeat_Effect
+} = _schedule.repeat_combined
 
 /**
  * Returns a new effect that repeats this effect the specified number of times
@@ -4049,56 +4073,6 @@ export const repeatOrElse: {
   ): Effect<R | R2 | R3, E2, B>
 } = _schedule.repeatOrElse_Effect
 
-/**
- * Repeats this effect until its value satisfies the specified predicate or
- * until the first failure.
- *
- * @since 2.0.0
- * @category repetition / recursion
- */
-export 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>
-} = _schedule.repeatUntil_Effect
-
-/**
- * Repeats this effect until its value satisfies the specified effectful
- * predicate or until the first failure.
- *
- * @since 2.0.0
- * @category repetition / recursion
- */
-export 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>
-} = _schedule.repeatUntilEffect_Effect
-
-/**
- * Repeats this effect while its value satisfies the specified effectful
- * predicate or until the first failure.
- *
- * @since 2.0.0
- * @category repetition / recursion
- */
-export 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>
-} = _schedule.repeatWhile_Effect
-
-/**
- * Repeats this effect while its value satisfies the specified effectful
- * predicate or until the first failure.
- *
- * @since 2.0.0
- * @category repetition / recursion
- */
-export 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>
-} = _schedule.repeatWhileEffect_Effect
-
 /**
  * Runs this effect according to the specified schedule.
  *
@@ -4741,7 +4715,10 @@ export const makeSemaphore: (permits: number) => Effect<never, never, Semaphore>
  * @since 2.0.0
  * @category execution
  */
-export const runFork: <E, A>(effect: Effect<never, E, A>) => Fiber.RuntimeFiber<E, A> = _runtime.unsafeForkEffect
+export const runFork: <E, A>(
+  effect: Effect<never, E, A>,
+  options?: Runtime.RunForkOptions
+) => Fiber.RuntimeFiber<E, A> = _runtime.unsafeForkEffect
 
 /**
  * @since 2.0.0
@@ -4749,7 +4726,7 @@ export const runFork: <E, A>(effect: Effect<never, E, A>) => Fiber.RuntimeFiber<
  */
 export const runCallback: <E, A>(
   effect: Effect<never, E, A>,
-  onExit?: (exit: Exit.Exit<E, A>) => void
+  options?: Runtime.RunCallbackOptions<E, A> | undefined
 ) => Runtime.Cancel<E, A> = _runtime.unsafeRunEffect
 
 /**

package/src/Runtime.ts

@@ -13,6 +13,7 @@ import * as internal from "./internal/runtime.js"
 import type { Pipeable } from "./Pipeable.js"
 import type * as RuntimeFlags from "./RuntimeFlags.js"
 import type { Scheduler } from "./Scheduler.js"
+import type { Scope } from "./Scope.js"
 
 /**
  * @since 2.0.0
@@ -28,7 +29,7 @@ export interface AsyncFiberException<out E, out A> {
  * @category models
  */
 export interface Cancel<out E, out A> {
-  (fiberId?: FiberId.FiberId, onExit?: (exit: Exit.Exit<E, A>) => void): void
+  (fiberId?: FiberId.FiberId, options?: RunCallbackOptions<E, A> | undefined): void
 }
 
 /**
@@ -57,6 +58,8 @@ export interface Runtime<in R> extends Pipeable {
 export interface RunForkOptions {
   readonly scheduler?: Scheduler | undefined
   readonly updateRefs?: ((refs: FiberRefs.FiberRefs, fiberId: FiberId.Runtime) => FiberRefs.FiberRefs) | undefined
+  readonly immediate?: boolean
+  readonly scope?: Scope
 }
 
 /**
@@ -93,6 +96,14 @@ export const runSyncExit: <R>(runtime: Runtime<R>) => <E, A>(effect: Effect.Effe
  */
 export const runSync: <R>(runtime: Runtime<R>) => <E, A>(effect: Effect.Effect<R, E, A>) => A = internal.unsafeRunSync
 
+/**
+ * @since 2.0.0
+ * @category models
+ */
+export interface RunCallbackOptions<E, A> extends RunForkOptions {
+  readonly onExit?: ((exit: Exit.Exit<E, A>) => void) | undefined
+}
+
 /**
  * Executes the effect asynchronously, eventually passing the exit value to
  * the specified callback.
@@ -107,8 +118,8 @@ export const runCallback: <R>(
   runtime: Runtime<R>
 ) => <E, A>(
   effect: Effect.Effect<R, E, A>,
-  onExit?: ((exit: Exit.Exit<E, A>) => void) | undefined
-) => (fiberId?: FiberId.FiberId | undefined, onExit?: ((exit: Exit.Exit<E, A>) => void) | undefined) => void =
+  options?: RunCallbackOptions<E, A> | undefined
+) => (fiberId?: FiberId.FiberId | undefined, options?: RunCallbackOptions<E, A> | undefined) => void =
   internal.unsafeRunCallback
 
 /**

package/src/internal/channel.ts

@@ -1217,7 +1217,7 @@ export const mergeAllWith = (
                 )
             })
           ),
-          Effect.repeatUntil(Option.isSome),
+          Effect.repeat({ until: (_): _ is Option.Some<OutDone> => Option.isSome(_) }),
           Effect.flatMap((outDone) =>
             Ref.update(
               lastDone,
@@ -1325,7 +1325,7 @@ export const mergeAllWith = (
               })
           })
         }),
-        Effect.repeatWhile(identity),
+        Effect.repeat({ while: (_) => _ }),
         Effect.forkScoped
       )
       return [queue, input] as const

package/src/internal/runtime.ts

@@ -1,3 +1,4 @@
+import { equals } from "effect/Equal"
 import type * as Cause from "../Cause.js"
 import * as Context from "../Context.js"
 import type * as Effect from "../Effect.js"
@@ -15,8 +16,10 @@ import type * as ReadonlyArray from "../ReadonlyArray.js"
 import type * as Runtime from "../Runtime.js"
 import type * as RuntimeFlags from "../RuntimeFlags.js"
 import * as _scheduler from "../Scheduler.js"
+import * as _scope from "../Scope.js"
 import * as InternalCause from "./cause.js"
 import * as core from "./core.js"
+import * as executionStrategy from "./executionStrategy.js"
 import * as FiberRuntime from "./fiberRuntime.js"
 import * as fiberScope from "./fiberScope.js"
 import * as OpCodes from "./opCodes/effect.js"
@@ -30,8 +33,6 @@ export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
   options?: Runtime.RunForkOptions
 ): Fiber.RuntimeFiber<E, A> => {
   const fiberId = FiberId.unsafeMake()
-  const effect = self
-
   const fiberRefUpdates: ReadonlyArray.NonEmptyArray<
     readonly [FiberRef.FiberRef<any>, ReadonlyArray.NonEmptyReadonlyArray<readonly [FiberId.Runtime, any]>]
   > = [[core.currentContext, [[fiberId, runtime.context]]]]
@@ -55,6 +56,24 @@ export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
     runtime.runtimeFlags
   )
 
+  let effect: Effect.Effect<R, E, A> = self
+
+  if (options?.scope) {
+    effect = core.flatMap(
+      _scope.fork(options.scope, executionStrategy.sequential),
+      (closeableScope) =>
+        core.zipRight(
+          core.scopeAddFinalizer(
+            closeableScope,
+            core.fiberIdWith((id) =>
+              equals(id, fiberRuntime.id()) ? core.unit : core.interruptAsFiber(fiberRuntime, id)
+            )
+          ),
+          core.onExit(effect, (exit) => _scope.close(closeableScope, exit))
+        )
+    )
+  }
+
   const supervisor = fiberRuntime._supervisor
 
   // we can compare by reference here as _supervisor.none is wrapped with globalValue
@@ -66,7 +85,12 @@ export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
 
   fiberScope.globalScope.add(runtime.runtimeFlags, fiberRuntime)
 
-  fiberRuntime.start(effect)
+  // Only an explicit false will prevent immediate execution
+  if (options?.immediate === false) {
+    fiberRuntime.resume(effect)
+  } else {
+    fiberRuntime.start(effect)
+  }
 
   return fiberRuntime
 }
@@ -75,22 +99,25 @@ export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
 export const unsafeRunCallback = <R>(runtime: Runtime.Runtime<R>) =>
 <E, A>(
   effect: Effect.Effect<R, E, A>,
-  onExit?: (exit: Exit.Exit<E, A>) => void
-): (fiberId?: FiberId.FiberId, onExit?: (exit: Exit.Exit<E, A>) => void) => void => {
-  const fiberRuntime = unsafeFork(runtime)(effect)
+  options: Runtime.RunCallbackOptions<E, A> = {}
+): (fiberId?: FiberId.FiberId, options?: Runtime.RunCallbackOptions<E, A> | undefined) => void => {
+  const fiberRuntime = unsafeFork(runtime)(effect, options)
 
-  if (onExit) {
+  if (options.onExit) {
     fiberRuntime.addObserver((exit) => {
-      onExit(exit)
+      options.onExit!(exit)
     })
   }
 
-  return (id, onExitInterrupt) =>
+  return (id, cancelOptions) =>
     unsafeRunCallback(runtime)(
       pipe(fiberRuntime, Fiber.interruptAs(id ?? FiberId.none)),
-      onExitInterrupt ?
-        (exit) => onExitInterrupt(Exit.flatten(exit)) :
-        void 0
+      {
+        ...cancelOptions,
+        onExit: cancelOptions?.onExit
+          ? (exit) => cancelOptions.onExit!(Exit.flatten(exit))
+          : undefined
+      }
     )
 }