Concurrency Effects

/**
 * Perform non-blocking call, returns Task object
 * @param fn - Function to fork (generator, async, or sync)
 * @param args - Arguments to pass to the function
 * @returns ForkEffect that resolves with Task
 */
function fork<Fn extends (...args: any[]) => any>(
  fn: Fn,
  ...args: Parameters<Fn>
): ForkEffect<SagaReturnType<Fn>>;

/**
 * Fork method on context object
 * @param ctxAndFnName - Array of [context, methodName]
 * @param args - Arguments to pass
 * @returns ForkEffect
 */
function fork<Ctx extends { [P in Name]: (this: Ctx, ...args: any[]) => any }, Name extends string>(
  ctxAndFnName: [Ctx, Name],
  ...args: Parameters<Ctx[Name]>
): ForkEffect<SagaReturnType<Ctx[Name]>>;

import { fork, take, cancel } from "redux-saga/effects";

function* backgroundTask() {
  while (true) {
    console.log("Background work...");
    yield delay(1000);
  }
}

function* mainSaga() {
  // Fork a background task
  const task = yield fork(backgroundTask);
  
  // Fork multiple tasks
  const task1 = yield fork(fetchUser, 1);
  const task2 = yield fork(fetchUser, 2);
  
  // Parent waits for all forked tasks to complete
  // before terminating (unless cancelled)
}

/**
 * Create detached task independent from parent
 * @param fn - Function to spawn
 * @param args - Arguments to pass
 * @returns ForkEffect with detached task
 */
function spawn<Fn extends (...args: any[]) => any>(
  fn: Fn,
  ...args: Parameters<Fn>
): ForkEffect<SagaReturnType<Fn>>;

import { spawn } from "redux-saga/effects";

function* parentSaga() {
  // Spawn detached task
  yield spawn(independentTask);
  
  // Parent can complete without waiting for spawned task
  // Spawned task continues running independently
}

/**
 * Wait for result of previously forked task
 * @param task - Task object from fork effect
 * @returns JoinEffect that resolves with task result
 */
function join(task: Task): JoinEffect;

/**
 * Wait for results of multiple tasks
 * @param tasks - Array of Task objects
 * @returns JoinEffect that resolves when all tasks complete
 */
function join(tasks: Task[]): JoinEffect;

import { fork, join } from "redux-saga/effects";

function* coordinatorSaga() {
  // Fork multiple tasks
  const task1 = yield fork(fetchUser, 1);
  const task2 = yield fork(fetchUser, 2);
  
  // Wait for both to complete
  const [user1, user2] = yield join([task1, task2]);
  
  // Or join one at a time
  const result1 = yield join(task1);
  const result2 = yield join(task2);
}

/**
 * Cancel a previously forked task
 * @param task - Task object to cancel
 * @returns CancelEffect
 */
function cancel(task: Task): CancelEffect;

/**
 * Cancel multiple tasks
 * @param tasks - Array of tasks to cancel
 * @returns CancelEffect
 */
function cancel(tasks: Task[]): CancelEffect;

/**
 * Self-cancellation (cancel current task)
 * @returns CancelEffect for self-cancellation
 */
function cancel(): CancelEffect;

import { fork, cancel, take, cancelled } from "redux-saga/effects";

function* cancellableTask() {
  try {
    while (true) {
      yield call(doWork);
      yield delay(1000);
    }
  } finally {
    if (yield cancelled()) {
      console.log('Task was cancelled');
      // Cleanup logic
    }
  }
}

function* controllerSaga() {
  const task = yield fork(cancellableTask);
  
  // Cancel on user action
  yield take('CANCEL_BACKGROUND_TASK');
  yield cancel(task);
}

/**
 * Check if current generator has been cancelled
 * @returns CancelledEffect that resolves with boolean
 */
function cancelled(): CancelledEffect;

/**
 * Run multiple effects in parallel, wait for all to complete
 * @param effects - Array of effects to run in parallel
 * @returns AllEffect that resolves with array of results
 */
function all<T>(effects: T[]): AllEffect<T>;

/**
 * Run labeled effects in parallel
 * @param effects - Object with labeled effects
 * @returns AllEffect that resolves with object of results
 */
function all<T>(effects: { [key: string]: T }): AllEffect<T>;

import { all, call } from "redux-saga/effects";

function* fetchAllData() {
  // Run multiple calls in parallel (array form)
  const [users, posts, comments] = yield all([
    call(fetchUsers),
    call(fetchPosts),
    call(fetchComments)
  ]);
  
  // Run with labels (object form)
  const { userData, profileData } = yield all({
    userData: call(fetchUser, userId),
    profileData: call(fetchProfile, userId)
  });
}

/**
 * Run race between multiple effects, first to complete wins
 * @param effects - Object with labeled effects to race
 * @returns RaceEffect that resolves with winner's result
 */
function race<T>(effects: { [key: string]: T }): RaceEffect<T>;

/**
 * Race with array of effects
 * @param effects - Array of effects to race
 * @returns RaceEffect
 */
function race<T>(effects: T[]): RaceEffect<T>;

import { race, call, take, delay } from "redux-saga/effects";

function* fetchWithTimeout() {
  const { response, timeout } = yield race({
    response: call(fetchUser, userId),
    timeout: delay(5000, 'TIMEOUT')
  });
  
  if (timeout) {
    console.log('Request timed out');
  } else {
    console.log('Got response:', response);
  }
}

function* cancellableFetch() {
  const { data, cancelled } = yield race({
    data: call(fetchData),
    cancelled: take('CANCEL_FETCH')
  });
  
  if (cancelled) {
    console.log('Fetch was cancelled by user');
  }
}

/**
 * Update saga's context (extends existing context)
 * @param props - Properties to add/update in context
 * @returns SetContextEffect
 */
function setContext<C extends object>(props: C): SetContextEffect<C>;

/**
 * Get property from saga's context
 * @param prop - Property name to retrieve
 * @returns GetContextEffect that resolves with property value
 */
function getContext(prop: string): GetContextEffect;

import { setContext, getContext, call } from "redux-saga/effects";

function* apiSaga() {
  // Set context
  yield setContext({ 
    apiClient: new ApiClient(),
    userId: 123 
  });
  
  // Get from context
  const apiClient = yield getContext('apiClient');
  const userId = yield getContext('userId');
  
  const data = yield call([apiClient, 'fetchUser'], userId);
}

/**
 * Detach a fork effect from its parent
 * @param forkEffect - ForkEffect to detach
 * @returns Detached ForkEffect
 */
function detach(forkEffect: ForkEffect): ForkEffect;

import { fork, detach } from "redux-saga/effects";

function* parentSaga() {
  // Create detached fork
  yield detach(fork(backgroundService));
  
  // Parent can complete without waiting for detached task
}