effect 3.15.4 → 3.16.0

package/dist/esm/internal/stream.js

@@ -11,6 +11,7 @@ import * as Exit from "../Exit.js";
 import * as Fiber from "../Fiber.js";
 import * as FiberRef from "../FiberRef.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";
@@ -32,6 +33,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";
@@ -1487,6 +1489,8 @@ export const prepend = /*#__PURE__*/dual(2, (self, values) => new StreamImpl(cha
 /** @internal */
 export const provideContext = /*#__PURE__*/dual(2, (self, context) => new StreamImpl(pipe(toChannel(self), core.provideContext(context))));
 /** @internal */
+export const provideSomeContext = /*#__PURE__*/dual(2, (self, context) => mapInputContext(self, Context.merge(context)));
+/** @internal */
 export const provideLayer = /*#__PURE__*/dual(2, (self, layer) => new StreamImpl(channel.unwrapScopedWith(scope => Layer.buildWithScope(layer, scope).pipe(Effect.map(env => pipe(toChannel(self), core.provideContext(env)))))));
 /** @internal */
 export const provideService = /*#__PURE__*/dual(3, (self, tag, resource) => provideServiceEffect(self, tag, Effect.succeed(resource)));
@@ -1650,8 +1654,9 @@ export const repeatValue = value => new StreamImpl(channel.repeated(core.write(C
 /** @internal */
 export const repeatWith = /*#__PURE__*/dual(3, (self, schedule, options) => {
   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.unwrap(Effect.match(driver.next(void 0), {
       onFailure: () => core.void,
       onSuccess: () => pipe(process, channel.zipRight(pipe(scheduleOutput, Effect.map(c => pipe(core.write(Chunk.of(c)), core.flatMap(() => loop))), channel.unwrap)))
@@ -1661,19 +1666,64 @@ export const repeatWith = /*#__PURE__*/dual(3, (self, schedule, options) => {
 });
 const repeatWithSchedule = (value, schedule) => repeatEffectWithSchedule(Effect.succeed(value), schedule);
 /** @internal */
-export const repeatEffectWithSchedule = (effect, schedule) => flatMap(fromEffect(Effect.zip(effect, Schedule.driver(schedule))), ([a, driver]) => concat(succeed(a), unfoldEffect(a, s => Effect.matchEffect(driver.next(s), {
-  onFailure: Effect.succeed,
-  onSuccess: () => Effect.map(effect, nextA => Option.some([nextA, nextA]))
-}))));
+export const repeatEffectWithSchedule = (effect, schedule) => flatMap(fromEffect(Effect.zip(effect, Schedule.driver(schedule))), ([a, driver]) => {
+  const provideLastIterationInfo = Effect.provideServiceEffect(Schedule.CurrentIterationMetadata, Ref.get(driver.iterationMeta));
+  return concat(succeed(a), unfoldEffect(a, s => Effect.matchEffect(driver.next(s), {
+    onFailure: Effect.succeed,
+    onSuccess: () => Effect.map(provideLastIterationInfo(effect), nextA => Option.some([nextA, nextA]))
+  })));
+});
 /** @internal */
-export const retry = /*#__PURE__*/dual(2, (self, schedule) => Schedule.driver(schedule).pipe(Effect.map(driver => {
-  const loop = toChannel(self).pipe(channel.mapOutEffect(out => Effect.as(driver.reset, out)), channel.catchAll(error => driver.next(error).pipe(Effect.match({
+export const retry = /*#__PURE__*/dual(2, (self, policy) => Schedule.driver(policy).pipe(Effect.map(driver => {
+  const provideLastIterationInfo = provideServiceEffect(Schedule.CurrentIterationMetadata, Ref.get(driver.iterationMeta));
+  const loop = toChannel(provideLastIterationInfo(self)).pipe(channel.mapOutEffect(out => Effect.as(driver.reset, out)), channel.catchAll(error => driver.next(error).pipe(Effect.match({
     onFailure: () => core.fail(error),
     onSuccess: () => loop
   }), channel.unwrap)));
   return loop;
 }), channel.unwrap, fromChannel));
 /** @internal */
+export const withExecutionPlan = /*#__PURE__*/dual(args => isStream(args[0]), (self, policy, options) => suspend(() => {
+  const preventFallbackOnPartialStream = options?.preventFallbackOnPartialStream ?? false;
+  let i = 0;
+  let lastError = Option.none();
+  const loop = suspend(() => {
+    const step = policy.steps[i++];
+    if (!step) {
+      return fail(Option.getOrThrow(lastError));
+    }
+    let nextStream = Context.isContext(step.provide) ? provideSomeContext(self, step.provide) : provideSomeLayer(self, step.provide);
+    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 = self => catchAllCause(self, cause => failCause(InternalSchedule.scheduleDefectRefailCause(cause)));
+/** @internal */
 export const run = /*#__PURE__*/dual(2, (self, sink) => toChannel(self).pipe(channel.pipeToOrFail(sink_.toChannel(sink)), channel.runDrain));
 /** @internal */
 export const runCollect = self => run(self, sink_.collectAll());