All the helpers in this module except none are infinite, so you almost certainly want to use another helper to stop after a number of retries or to use the count passed as an argument to do the same.

Recommended: Update to at least TS 5.6+, or use a TypeScript-aware polyfill for the Iterator Helpers feature (ES2025). In that case, you can simply use the take method directly:

import * as Task from 'true-myth/task';
import * as Delay from 'true-myth/task/delay';

let theTask = Task.withRetries(
  () => Task.fromPromise(fetch('https://example.com/')),
  Delay.exponential().map(Delay.jitter).take(5),
);
Copy

Fallback: If you are unable to use a polyfill or upgrade to TS 5.6 for now, you can still use these safely using generator functions, which are long-standing JavaScript features available in all modern browsers since ES6. The above example might be written like this (note that these are fully-general versions of the take and map functions—that is, much more general than is required for working with the “strategies” from True Myth).

import * as Task from 'true-myth/task';
import { exponential, jitter } from 'true-myth/task/delay';

let theTask = Task.withRetries(
  () => Task.fromPromise(fetch('https://example.com/')),
  take(map(Delay.exponential(), Delay.jitter), 5),
);

function* take<T>(iterable: Iterable<T>, count: number): Generator<T> {
  let taken = 0;
  for (let item of iterable) {
    if (taken >= count) {
      break;
    }

    taken += 1;
    yield item;
  }
}

function* map<T, U>(iterable: Iterable<T>, fn: (t: T) => U): Generator<U> {
  for (let value of iterable) {
    yield fn(value);
  }
}
Copy

This is a bit harder to follow but works the same way, and will let you migrate incrementally once you are able to use the ES2025 Iterator Helpers features.