Effect.withRetry: retry w/ knowledge of past attempts

[jessekelly881]

What is the problem this feature would solve?

It's sometime necessary to have access to the context of previous retry attempts when running a new retry attempt. For example, when receiving a parse error from an llm response it is useful to be able to send the parse error message to the llm. Or in other cases it is useful to keep track of how many times a retry has taken place.

What is the feature you are proposing to solve the problem?

A fn like

Effect.withRetry({
    run: (previousFailures: Cause[], runCount: number) => Effect.fail(""),
   // ... normal retry params: while, etc. 
})

What alternatives have you considered?

runCount could just be extracted from previousResults.length

[mattrossman]

I was looking for a similar functionality recently. Here's a userland version of this with just the count tracking:

function retryWith<A, E>(f: (retryCount: number) => Effect.Effect<A, E>, options: Effect.Retry.Options<E>) {
  return Effect.gen(function*() {
    const retryCount = yield* Ref.make(0)
    return yield* Ref.get(retryCount).pipe(
      Effect.flatMap((i) => f(i)),
      Effect.tapError(() => Ref.update(retryCount, x => x +1)),
      Effect.retry(options)
    )
  })
}

// Example
retryWith((i) => Effect.fail(i), {
  times: 2
})

I briefly tried accumulating errors from previous runs instead of just the count, but getting TypeScript to infer the error type was more involved.

I call it retryWith here because it isn't very pipeline-friendly, and when I compare existing APIs like withRandom vs randomWith, it appears the .with* functions more often wrap existing effects and are more pipeline-friendly, while .*With functions often produce a standalone effect from a factory function.