effect 2.0.4 → 2.1.0

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
+      }
     )
 }
 

package/src/internal/schedule.ts

@@ -11,13 +11,14 @@ import type { LazyArg } from "../Function.js"
 import { constVoid, dual, pipe } from "../Function.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
-import type { Predicate, Refinement } from "../Predicate.js"
+import { hasProperty, type Predicate } from "../Predicate.js"
 import * as Random from "../Random.js"
 import type * as Ref from "../Ref.js"
 import type * as Schedule from "../Schedule.js"
 import * as ScheduleDecision from "../ScheduleDecision.js"
 import * as Interval from "../ScheduleInterval.js"
 import * as Intervals from "../ScheduleIntervals.js"
+import * as internalCause from "./cause.js"
 import * as effect from "./core-effect.js"
 import * as core from "./core.js"
 import * as ref from "./ref.js"
@@ -30,6 +31,9 @@ export const ScheduleTypeId: Schedule.ScheduleTypeId = Symbol.for(
   ScheduleSymbolKey
 ) as Schedule.ScheduleTypeId
 
+/** @internal */
+export const isSchedule = (u: unknown): u is Schedule.Schedule<any, any, any> => hasProperty(u, ScheduleTypeId)
+
 /** @internal */
 const ScheduleDriverSymbolKey = "effect/ScheduleDriver"
 
@@ -1831,6 +1835,29 @@ export const findNextMonth = (now: number, day: number, months: number): number
 
 // circular with Effect
 
+const ScheduleDefectTypeId = Symbol.for("effect/Schedule/ScheduleDefect")
+class ScheduleDefect<E> {
+  readonly [ScheduleDefectTypeId]: typeof ScheduleDefectTypeId
+  constructor(readonly error: E) {
+    this[ScheduleDefectTypeId] = ScheduleDefectTypeId
+  }
+}
+const isScheduleDefect = <E = unknown>(u: unknown): u is ScheduleDefect<E> => hasProperty(u, ScheduleDefectTypeId)
+const scheduleDefectWrap = <R, E, A>(self: Effect.Effect<R, E, A>) =>
+  core.catchAll(self, (e) => core.die(new ScheduleDefect(e)))
+const scheduleDefectRefail = <R, E, A>(self: Effect.Effect<R, E, A>) =>
+  core.catchAllCause(self, (cause) =>
+    Option.match(
+      internalCause.find(
+        cause,
+        (_) => internalCause.isDieType(_) && isScheduleDefect<E>(_.defect) ? Option.some(_.defect) : Option.none()
+      ),
+      {
+        onNone: () => core.failCause(cause),
+        onSome: (error) => core.fail(error.error)
+      }
+    ))
+
 /** @internal */
 export const repeat_Effect = dual<
   <R1, A extends A0, A0, B>(
@@ -1842,6 +1869,57 @@ export const repeat_Effect = dual<
   ) => Effect.Effect<R | R1, E, B>
 >(2, (self, schedule) => repeatOrElse_Effect(self, schedule, (e, _) => core.fail(e)))
 
+/** @internal */
+export const repeat_combined = dual<{
+  <A, O extends Effect.Repeat.Options<A>>(
+    options: O
+  ): <R, E>(self: Effect.Effect<R, E, A>) => Effect.Repeat.Return<R, E, A, O>
+  <R1, A extends A0, A0, B>(
+    schedule: Schedule.Schedule<R1, A, B>
+  ): <R, E>(self: Effect.Effect<R, E, A>) => Effect.Effect<R | R1, E, B>
+}, {
+  <R, E, A, O extends Effect.Repeat.Options<A>>(
+    self: Effect.Effect<R, E, A>,
+    options: O
+  ): Effect.Repeat.Return<R, E, A, O>
+  <R, E, A extends A0, A0, R1, B>(
+    self: Effect.Effect<R, E, A>,
+    schedule: Schedule.Schedule<R1, A0, B>
+  ): Effect.Effect<R | R1, E, B>
+}>(
+  2,
+  (self: Effect.Effect<any, any, any>, options: Effect.Repeat.Options<any> | Schedule.Schedule<any, any, any>) => {
+    if (isSchedule(options)) {
+      return repeat_Effect(self, options)
+    }
+
+    const base = options.schedule ?? passthrough(forever)
+    const withWhile = options.while ?
+      whileInputEffect(base, (a) => {
+        const applied = options.while!(a)
+        if (typeof applied === "boolean") {
+          return core.succeed(applied)
+        }
+        return scheduleDefectWrap(applied)
+      }) :
+      base
+    const withUntil = options.until ?
+      untilInputEffect(withWhile, (a) => {
+        const applied = options.until!(a)
+        if (typeof applied === "boolean") {
+          return core.succeed(applied)
+        }
+        return scheduleDefectWrap(applied)
+      }) :
+      withWhile
+    const withTimes = options.times ?
+      intersect(withUntil, recurs(options.times)) :
+      withUntil
+
+    return scheduleDefectRefail(repeat_Effect(self, withTimes))
+  }
+)
+
 /** @internal */
 export const repeatOrElse_Effect = dual<
   <R2, A extends A0, A0, B, E, R3, E2>(
@@ -1877,66 +1955,6 @@ const repeatOrElseEffectLoop = <R, E, A extends A0, A0, R1, B, R2, E2, C>(
   })
 }
 
-/** @internal */
-export const repeatUntil_Effect = dual<
-  {
-    <A, B extends A>(f: Refinement<A, B>): <R, E>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, B>
-    <A>(f: Predicate<A>): <R, E>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
-  },
-  {
-    <R, E, A, B extends A>(self: Effect.Effect<R, E, A>, f: Predicate<A>): Effect.Effect<R, E, B>
-    <R, E, A>(self: Effect.Effect<R, E, A>, f: Predicate<A>): Effect.Effect<R, E, A>
-  }
->(
-  2,
-  <R, E, A>(self: Effect.Effect<R, E, A>, f: Predicate<A>) =>
-    repeatUntilEffect_Effect(self, (a) => core.sync(() => f(a)))
-)
-
-/** @internal */
-export const repeatUntilEffect_Effect: {
-  <A, R2, E2>(
-    f: (a: A) => Effect.Effect<R2, E2, boolean>
-  ): <R, E>(self: Effect.Effect<R, E, A>) => Effect.Effect<R | R2, E | E2, A>
-  <R, E, A, R2, E2>(
-    self: Effect.Effect<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, boolean>
-  ): Effect.Effect<R | R2, E | E2, A>
-} = dual<
-  <A, R2, E2>(
-    f: (a: A) => Effect.Effect<R2, E2, boolean>
-  ) => <R, E>(self: Effect.Effect<R, E, A>) => Effect.Effect<R | R2, E | E2, A>,
-  <R, E, A, R2, E2>(
-    self: Effect.Effect<R, E, A>,
-    f: (a: A) => Effect.Effect<R2, E2, boolean>
-  ) => Effect.Effect<R | R2, E | E2, A>
->(2, (self, f) =>
-  core.flatMap(self, (a) =>
-    core.flatMap(f(a), (result) =>
-      result ?
-        core.succeed(a) :
-        core.flatMap(
-          core.yieldNow(),
-          () => repeatUntilEffect_Effect(self, f)
-        ))))
-
-/** @internal */
-export const repeatWhile_Effect = dual<
-  <A>(f: Predicate<A>) => <R, E>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(self: Effect.Effect<R, E, A>, f: Predicate<A>) => Effect.Effect<R, E, A>
->(2, (self, f) => repeatWhileEffect_Effect(self, (a) => core.sync(() => f(a))))
-
-/** @internal */
-export const repeatWhileEffect_Effect = dual<
-  <R1, A, E2>(
-    f: (a: A) => Effect.Effect<R1, E2, boolean>
-  ) => <R, E>(self: Effect.Effect<R, E, A>) => Effect.Effect<R | R1, E | E2, A>,
-  <R, E, R1, A, E2>(
-    self: Effect.Effect<R, E, A>,
-    f: (a: A) => Effect.Effect<R1, E2, boolean>
-  ) => Effect.Effect<R | R1, E | E2, A>
->(2, (self, f) => repeatUntilEffect_Effect(self, (a) => effect.negate(f(a))))
-
 /** @internal */
 export const retry_Effect = dual<
   <R1, E extends E0, E0, B>(
@@ -1949,21 +1967,54 @@ export const retry_Effect = dual<
 >(2, (self, policy) => retryOrElse_Effect(self, policy, (e, _) => core.fail(e)))
 
 /** @internal */
-export const retryN_Effect = dual<
-  (n: number) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(self: Effect.Effect<R, E, A>, n: number) => Effect.Effect<R, E, A>
->(2, (self, n) => retryN_EffectLoop(self, n))
+export const retry_combined = dual<{
+  <E, O extends Effect.Retry.Options<E>>(
+    options: O
+  ): <R, A>(self: Effect.Effect<R, E, A>) => Effect.Retry.Return<R, E, A, O>
+  <R1, E extends E0, E0, B>(
+    policy: Schedule.Schedule<R1, E0, B>
+  ): <R, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R | R1, E, A>
+}, {
+  <R, A, E, O extends Effect.Retry.Options<E>>(
+    self: Effect.Effect<R, E, A>,
+    options: O
+  ): Effect.Retry.Return<R, E, A, O>
+  <R, E extends E0, E0, A, R1, B>(
+    self: Effect.Effect<R, E, A>,
+    policy: Schedule.Schedule<R1, E0, B>
+  ): Effect.Effect<R | R1, E, A>
+}>(
+  2,
+  (self: Effect.Effect<any, any, any>, options: Effect.Retry.Options<any> | Schedule.Schedule<any, any, any>) => {
+    if (isSchedule(options)) {
+      return retry_Effect(self, options)
+    }
 
-/** @internal */
-const retryN_EffectLoop = <R, E, A>(
-  self: Effect.Effect<R, E, A>,
-  n: number
-): Effect.Effect<R, E, A> => {
-  return core.catchAll(self, (e) =>
-    n <= 0 ?
-      core.fail(e) :
-      core.flatMap(core.yieldNow(), () => retryN_EffectLoop(self, n - 1)))
-}
+    const base = options.schedule ?? forever
+    const withWhile = options.while ?
+      whileInputEffect(base, (e) => {
+        const applied = options.while!(e)
+        if (typeof applied === "boolean") {
+          return core.succeed(applied)
+        }
+        return scheduleDefectWrap(applied)
+      }) :
+      base
+    const withUntil = options.until ?
+      untilInputEffect(withWhile, (e) => {
+        const applied = options.until!(e)
+        if (typeof applied === "boolean") {
+          return core.succeed(applied)
+        }
+        return scheduleDefectWrap(applied)
+      }) :
+      withWhile
+    const withTimes = options.times ?
+      intersect(withUntil, recurs(options.times)) :
+      withUntil
+    return scheduleDefectRefail(retry_Effect(self, withTimes))
+  }
+)
 
 /** @internal */
 export const retryOrElse_Effect = dual<
@@ -2003,66 +2054,6 @@ const retryOrElse_EffectLoop = <R, E, A, R1, A1, R2, E2, A2>(
   )
 }
 
-/** @internal */
-export const retryUntil_Effect = dual<
-  {
-    <E, E2 extends E>(f: Refinement<E, E2>): <R, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E2, A>
-    <E>(f: Predicate<E>): <R, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
-  },
-  {
-    <R, E, A, E2 extends E>(self: Effect.Effect<R, E, A>, f: Refinement<E, E2>): Effect.Effect<R, E2, A>
-    <R, E, A>(self: Effect.Effect<R, E, A>, f: Predicate<E>): Effect.Effect<R, E, A>
-  }
->(2, <R, E, A>(self: Effect.Effect<R, E, A>, f: Predicate<E>) =>
-  retryUntilEffect_Effect(
-    self,
-    (e) => core.sync(() => f(e))
-  ))
-
-/** @internal */
-export const retryUntilEffect_Effect: {
-  <R1, E, E2>(
-    f: (e: E) => Effect.Effect<R1, E2, boolean>
-  ): <R, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R1 | R, E | E2, A>
-  <R, E, A, R1, E2>(
-    self: Effect.Effect<R, E, A>,
-    f: (e: E) => Effect.Effect<R1, E2, boolean>
-  ): Effect.Effect<R | R1, E | E2, A>
-} = dual<
-  <R1, E, E2>(
-    f: (e: E) => Effect.Effect<R1, E2, boolean>
-  ) => <R, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R | R1, E | E2, A>,
-  <R, E, A, R1, E2>(
-    self: Effect.Effect<R, E, A>,
-    f: (e: E) => Effect.Effect<R1, E2, boolean>
-  ) => Effect.Effect<R | R1, E | E2, A>
->(2, (self, f) =>
-  core.catchAll(self, (e) =>
-    core.flatMap(f(e), (b) =>
-      b ?
-        core.fail(e) :
-        core.flatMap(
-          core.yieldNow(),
-          () => retryUntilEffect_Effect(self, f)
-        ))))
-
-/** @internal */
-export const retryWhile_Effect = dual<
-  <E>(f: Predicate<E>) => <R, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A>(self: Effect.Effect<R, E, A>, f: Predicate<E>) => Effect.Effect<R, E, A>
->(2, (self, f) => retryWhileEffect_Effect(self, (e) => core.sync(() => f(e))))
-
-/** @internal */
-export const retryWhileEffect_Effect = dual<
-  <R1, E, E2>(
-    f: (e: E) => Effect.Effect<R1, E2, boolean>
-  ) => <R, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R | R1, E | E2, A>,
-  <R, E, A, R1, E2>(
-    self: Effect.Effect<R, E, A>,
-    f: (e: E) => Effect.Effect<R1, E2, boolean>
-  ) => Effect.Effect<R | R1, E | E2, A>
->(2, (self, f) => retryUntilEffect_Effect(self, (e) => effect.negate(f(e))))
-
 /** @internal */
 export const schedule_Effect = dual<
   <R2, Out>(

package/src/internal/version.ts

@@ -1 +1 @@
-export const moduleVersion = "2.0.4"
+export const moduleVersion = "2.1.0"