Стійкість та конкурентність в Effect: Fibers, Retry Policies та таймаути

+-------------------------------------------------------------------------+
|                    БАТЬКІВСЬКЕ ВОЛОКНО (PARENT FIBER)                   |
|  Effect.all([task1, task2, task3], { concurrency: "unbounded" })        |
+-------------------------------------------------------------------------+
       |                               |                              |
       | fork                          | fork                         | fork
       v                               v                              v
+---------------+              +---------------+              +---------------+
| Дочірнє #1    |              | Дочірнє #2    |              | Дочірнє #3    |
| (Мережевий I/O|              | (ФАТАЛЬНИЙ    |              | (Важкий CPU   |
|               |              |  ЗБІЙ: 15ms)  |              |  розрахунок)  |
+---------------+              +---------------+              +---------------+
       |                               |                              |
       | АВТО-ПЕРЕРИВАННЯ              | ТРИГЕР ЗБОЮ                  | АВТО-ПЕРЕРИВАННЯ
       v (Interrupt)                   v                              v (Interrupt)
+-----------------------------------------------------------------------------+
| ПОШИРЕННЯ СИГНАЛУ ПЕРЕРИВАННЯ:                                              |
| 1. Збій Волокна #2 негайно сповіщає батьківський потік.                     |
| 2. Батько посилає Fiber.interrupt волокнам #1 та #3.                        |
| 3. Волокна #1 та #3 негайно зупиняються, виконуючи свої фіналізатори Scope  |
|    (закривають сокети, звільняють буфери). Жодних фонових витоків!          |
+-----------------------------------------------------------------------------+

import { Effect, Fiber, Duration } from 'effect';

const backgroundTask = Effect.gen(function* () {
  yield* Effect.logInfo('Фонове волокно запущено...');
  // Імітація тривалої операції
  yield* Effect.sleep(Duration.seconds(10));
  yield* Effect.logInfo('Фонове волокно завершено.');
  return 100;
});

export const mainProgram = Effect.gen(function* () {
  // 1. Відгалуження задачі в окреме волокно (Green Thread)
  const fiber = yield* Effect.fork(backgroundTask);

  // 2. Основний потік працює паралельно
  yield* Effect.sleep(Duration.seconds(1));
  yield* Effect.logInfo('Основний потік вирішує перервати фонову задачу!');

  // 3. Безпечне примусове переривання волокна
  yield* Fiber.interrupt(fiber);

  yield* Effect.logInfo('Фонове волокно успішно зупинено без витоків.');
});

import { Effect, Schedule, Duration, Data, pipe } from 'effect';

export class TransientNetworkError extends Data.TaggedError('TransientNetworkError')<{
  readonly statusCode: number;
}> {}

export class FatalAuthError extends Data.TaggedError('FatalAuthError')<{
  readonly reason: string;
}> {}

// Нестабільний запит до віддаленого шлюзу
let attempt = 0;
const unstableRequest = Effect.gen(function* () {
  attempt++;
  yield* Effect.logInfo(`Спроба мережевого запиту #${attempt}`);

  if (attempt < 3) {
    return yield* Effect.fail(new TransientNetworkError({ statusCode: 503 }));
  }

  return { data: 'Успішна відповідь шлюзу' };
});

// Конфігурація розкладу повторів:
// Початкова пауза 100мс -> експоненційне зростання -> максимум 5 спроб -> додавання джиттеру
const retrySchedule = pipe(
  Schedule.exponential(Duration.millis(100)),
  Schedule.jittered, // Захист від Thundering Herd: рандомізація дельти часу (+- 20%)
  Schedule.compose(Schedule.recurs(5))
);

// Застосування політики повторів ТІЛЬКИ для тимчасових помилок мережі
export const resilientCall = unstableRequest.pipe(
  Effect.retry({
    schedule: retrySchedule,
    while: (error) => error._tag === 'TransientNetworkError',
  })
);

import { Effect, Duration } from 'effect';

const fastPrimaryService = Effect.sleep(Duration.millis(200)).pipe(
  Effect.as('PRIMARY_REGION_DATA')
);

const backupService = Effect.sleep(Duration.millis(500)).pipe(
  Effect.as('BACKUP_REGION_DATA')
);

// 1. Перегони обчислень: швидке обчислення перемагає, повільне гарантовано переривається
export const hedgedRequest = Effect.race(fastPrimaryService, backupService);

// 2. Жорсткий таймаут виконання
export const timedOperation = hedgedRequest.pipe(
  // Якщо операція триває довше 350мс, вона переривається з помилкою NoSuchElementException
  Effect.timeout(Duration.millis(350)),
  // Обробка таймауту
  Effect.orElse(() => Effect.succeed('FALLBACK_STALE_CACHE'))
);

import { Effect, Duration } from 'effect';

const itemIds = Array.from({ length: 1000 }, (_, i) => `item_${i}`);

const processItem = (id: string) =>
  Effect.gen(function* () {
    yield* Effect.logInfo(`Обробка ${id}`);
    yield* Effect.sleep(Duration.millis(50));
    return `result_${id}`;
  });

// Обробка 1000 елементів пачками суворо по 5 паралельних потоків
export const throttledBatch = Effect.all(
  itemIds.map((id) => processItem(id)),
  { concurrency: 5 } // Ліміт віртуальних волокон
);