f_limit library

A Dart implementation of p-limit for controlling concurrency

This library provides utilities to limit the number of concurrent async operations. It's useful for controlling resource usage and preventing overwhelming external services.

Features:

• Concurrency limiting with configurable limits
• Multiple queue strategies: FIFO, LIFO, Priority, Alternating, Random
• Task cancellation support via TaskHandle
• Timeout support for individual tasks
• Retry policies with exponential backoff and jitter
• Pause/resume functionality
• Isolate support for CPU-intensive tasks
• Extension methods for concurrent mapping, filtering, and iteration

Classes

FLimit

A concurrency limiter that controls how many async operations can run simultaneously

LimitOptions

Options for creating a limited function

RetryExponential

Exponential backoff retry policy: delay increases exponentially with each attempt

RetryFixed

Fixed delay retry policy: retry with a constant delay between attempts

RetryPolicy

Abstract interface for retry policies

RetrySimple

Simple retry policy: retry up to a maximum number of attempts with no delay

RetryWithJitter

Decorator that adds random jitter to any retry policy

SettledResult<T>

Settled outcome for a task in batch APIs.

TaskHandle<T>

Task handle for controlling and monitoring a submitted task

TaskTimeouts

Timeout configuration for a task.

Enums

QueueStrategy

Queue strategy for task execution

TaskStatus

Execution state for a submitted task.

TimeoutStage

Timeout phases supported by TaskTimeouts.

Extensions

FLimitExtensions on FLimit

Extension methods for FLimit

FLimitIsolate on FLimit

Extension on FLimit to support running tasks in a separate isolate

Functions

executeWithRetry<T>(Future<T> function(), RetryPolicy retryPolicy) → Future<T>

Helper function to execute a function with a retry policy.

fLimit(int concurrency, {QueueStrategy queueStrategy = QueueStrategy.fifo}) → FLimit

Create a concurrency limiter

limitFunction<T>(Future<T> function(), LimitOptions options) → LimitedFunctionWrapper<T>

Create a limited version of a function

Typedefs

LimitedFunction<T> = Future<T> Function()

A function that takes no arguments and returns a Future

LimitedFunctionWrapper<T> = Future<T> Function()

Create a function with limited concurrency

Exceptions / Errors

CanceledException

Exception thrown when a task is canceled before execution

TimeoutException

Exception thrown when a task exceeds its timeout duration