effect 3.15.4 → 3.16.0

package/src/internal/stream.ts

@@ -8,11 +8,13 @@ import * as Duration from "../Duration.js"
 import * as Effect from "../Effect.js"
 import * as Either from "../Either.js"
 import * as Equal from "../Equal.js"
+import type { ExecutionPlan } from "../ExecutionPlan.js"
 import * as Exit from "../Exit.js"
 import * as Fiber from "../Fiber.js"
 import * as FiberRef from "../FiberRef.js"
 import type { LazyArg } from "../Function.js"
 import { constTrue, dual, identity, pipe } from "../Function.js"
+import * as internalExecutionPlan from "../internal/executionPlan.js"
 import * as Layer from "../Layer.js"
 import * as MergeDecision from "../MergeDecision.js"
 import * as Option from "../Option.js"
@@ -42,6 +44,7 @@ import * as MergeStrategy from "./channel/mergeStrategy.js"
 import * as core from "./core-stream.js"
 import * as doNotation from "./doNotation.js"
 import { RingBuffer } from "./ringBuffer.js"
+import * as InternalSchedule from "./schedule.js"
 import * as sink_ from "./sink.js"
 import * as DebounceState from "./stream/debounceState.js"
 import * as emit from "./stream/emit.js"
@@ -4848,6 +4851,16 @@ export const provideContext = dual<
     new StreamImpl(pipe(toChannel(self), core.provideContext(context)))
 )
 
+/** @internal */
+export const provideSomeContext = dual<
+  <R2>(context: Context.Context<R2>) => <A, E, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E, Exclude<R, R2>>,
+  <A, E, R, R2>(self: Stream.Stream<A, E, R>, context: Context.Context<R2>) => Stream.Stream<A, E, Exclude<R, R2>>
+>(
+  2,
+  <A, E, R, R2>(self: Stream.Stream<A, E, R>, context: Context.Context<R2>): Stream.Stream<A, E, Exclude<R, R2>> =>
+    mapInputContext(self as any, Context.merge(context))
+)
+
 /** @internal */
 export const provideLayer = dual<
   <RIn, E2, ROut>(
@@ -5382,8 +5395,13 @@ export const repeatWith = dual<
     return pipe(
       Schedule.driver(schedule),
       Effect.map((driver) => {
+        const provideLastIterationInfo = provideServiceEffect(
+          Schedule.CurrentIterationMetadata,
+          Ref.get(driver.iterationMeta)
+        )
+
         const scheduleOutput = pipe(driver.last, Effect.orDie, Effect.map(options.onSchedule))
-        const process = pipe(self, map(options.onElement), toChannel)
+        const process = pipe(self, provideLastIterationInfo, map(options.onElement), toChannel)
         const loop: Channel.Channel<Chunk.Chunk<C>, unknown, E, unknown, void, unknown, R | R2> = channel.unwrap(
           Effect.match(driver.next(void 0), {
             onFailure: () => core.void,
@@ -5419,34 +5437,45 @@ export const repeatEffectWithSchedule = <A, E, R, X, A0 extends A, R2>(
 ): Stream.Stream<A, E, R | R2> =>
   flatMap(
     fromEffect(Effect.zip(effect, Schedule.driver(schedule))),
-    ([a, driver]) =>
-      concat(
+    ([a, driver]) => {
+      const provideLastIterationInfo = Effect.provideServiceEffect(
+        Schedule.CurrentIterationMetadata,
+        Ref.get(driver.iterationMeta)
+      )
+      return concat(
         succeed(a),
         unfoldEffect(a, (s) =>
           Effect.matchEffect(driver.next(s as A0), {
             onFailure: Effect.succeed,
-            onSuccess: () => Effect.map(effect, (nextA) => Option.some([nextA, nextA] as const))
+            onSuccess: () =>
+              Effect.map(provideLastIterationInfo(effect), (nextA) => Option.some([nextA, nextA] as const))
           }))
       )
+    }
   )
 
 /** @internal */
 export const retry = dual<
-  <E0 extends E, R2, E, X>(
-    schedule: Schedule.Schedule<X, E0, R2>
+  <E, R2, X>(
+    policy: Schedule.Schedule<X, Types.NoInfer<E>, R2>
   ) => <A, R>(self: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R2 | R>,
-  <A, E, R, X, E0 extends E, R2>(
+  <A, E, R, X, R2>(
     self: Stream.Stream<A, E, R>,
-    schedule: Schedule.Schedule<X, E0, R2>
+    policy: Schedule.Schedule<X, Types.NoInfer<E>, R2>
   ) => Stream.Stream<A, E, R2 | R>
 >(
   2,
-  <A, E, R, X, E0 extends E, R2>(
+  <A, E, R, X, R2>(
     self: Stream.Stream<A, E, R>,
-    schedule: Schedule.Schedule<X, E0, R2>
-  ): Stream.Stream<A, E, R | R2> =>
-    Schedule.driver(schedule).pipe(
+    policy: Schedule.Schedule<X, Types.NoInfer<E>, R2>
+  ): Stream.Stream<A, E, R2 | R> =>
+    Schedule.driver(policy).pipe(
       Effect.map((driver) => {
+        const provideLastIterationInfo = provideServiceEffect(
+          Schedule.CurrentIterationMetadata,
+          Ref.get(driver.iterationMeta)
+        )
+
         const loop: Channel.Channel<
           Chunk.Chunk<A>,
           unknown,
@@ -5454,11 +5483,11 @@ export const retry = dual<
           unknown,
           unknown,
           unknown,
-          R | R2
-        > = toChannel(self).pipe(
+          R2 | R
+        > = toChannel(provideLastIterationInfo(self)).pipe(
           channel.mapOutEffect((out) => Effect.as(driver.reset, out)),
           channel.catchAll((error) =>
-            driver.next(error as E0).pipe(
+            driver.next(error).pipe(
               Effect.match({
                 onFailure: () => core.fail(error),
                 onSuccess: () => loop
@@ -5474,6 +5503,102 @@ export const retry = dual<
     )
 )
 
+/** @internal */
+export const withExecutionPlan: {
+  <Input, R2, Provides, PolicyE>(
+    policy: ExecutionPlan<{
+      provides: Provides
+      input: Input
+      error: PolicyE
+      requirements: R2
+    }>,
+    options?: {
+      readonly preventFallbackOnPartialStream?: boolean | undefined
+    }
+  ): <A, E extends Input, R>(
+    self: Stream.Stream<A, E, R>
+  ) => Stream.Stream<A, E | PolicyE, R2 | Exclude<R, Provides>>
+  <A, E extends Input, R, R2, Input, Provides, PolicyE>(
+    self: Stream.Stream<A, E, R>,
+    policy: ExecutionPlan<{
+      provides: Provides
+      input: Input
+      error: PolicyE
+      requirements: R2
+    }>,
+    options?: {
+      readonly preventFallbackOnPartialStream?: boolean | undefined
+    }
+  ): Stream.Stream<A, E | PolicyE, R2 | Exclude<R, Provides>>
+} = dual((args) => isStream(args[0]), <A, E extends Input, R, R2, Input, Provides, PolicyE>(
+  self: Stream.Stream<A, E, R>,
+  policy: ExecutionPlan<{
+    provides: Provides
+    input: Input
+    error: PolicyE
+    requirements: R2
+  }>,
+  options?: {
+    readonly preventFallbackOnPartialStream?: boolean | undefined
+  }
+): Stream.Stream<A, E | PolicyE, R2 | Exclude<R, Provides>> =>
+  suspend(() => {
+    const preventFallbackOnPartialStream = options?.preventFallbackOnPartialStream ?? false
+    let i = 0
+    let lastError = Option.none<E | PolicyE>()
+    const loop: Stream.Stream<
+      A,
+      E | PolicyE,
+      R2 | Exclude<R, Provides>
+    > = suspend(() => {
+      const step = policy.steps[i++]
+      if (!step) {
+        return fail(Option.getOrThrow(lastError))
+      }
+
+      let nextStream: Stream.Stream<A, E | PolicyE, R2 | Exclude<R, Provides>> = Context.isContext(step.provide)
+        ? provideSomeContext(self, step.provide)
+        : provideSomeLayer(self, step.provide as Layer.Layer<Provides, E | PolicyE, R2>)
+      let receivedElements = false
+
+      if (Option.isSome(lastError)) {
+        const error = lastError.value
+        let attempted = false
+        const wrapped = nextStream
+        // ensure the schedule is applied at least once
+        nextStream = suspend(() => {
+          if (attempted) return wrapped
+          attempted = true
+          return fail(error)
+        })
+        nextStream = scheduleDefectRefail(retry(nextStream, internalExecutionPlan.scheduleFromStep(step, false)!))
+      } else {
+        const schedule = internalExecutionPlan.scheduleFromStep(step, true)
+        nextStream = schedule ? scheduleDefectRefail(retry(nextStream, schedule)) : nextStream
+      }
+
+      return catchAll(
+        preventFallbackOnPartialStream ?
+          mapChunks(nextStream, (chunk) => {
+            receivedElements = true
+            return chunk
+          }) :
+          nextStream,
+        (error) => {
+          if (preventFallbackOnPartialStream && receivedElements) {
+            return fail(error)
+          }
+          lastError = Option.some(error)
+          return loop
+        }
+      )
+    })
+    return loop
+  }))
+
+const scheduleDefectRefail = <A, E, R>(self: Stream.Stream<A, E, R>) =>
+  catchAllCause(self, (cause) => failCause(InternalSchedule.scheduleDefectRefailCause(cause)))
+
 /** @internal */
 export const run = dual<
   <A2, A, E2, R2>(

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.15.4"
+let moduleVersion = "3.16.0"
 
 export const getCurrentVersion = () => moduleVersion