Error Handling

Rust-style Result type for type-safe error handling with pattern matching.

Configurable retry with exponential backoff, jitter, and circuit breaker

Standalone circuit breaker with sliding window failure rate, fallback support, half-open probing, and event callbacks.

Fluent parameter validation and guard clauses for .NET.

Option/Maybe monad for explicit null handling with Map, Bind, Match, and LINQ support.

Lightweight Result type for .NET — model success and failure without exceptions using pattern matching.

Configurable retry logic and circuit breaker for .NET — exponential backoff, jitter, and built-in presets.

Resilient JSON parsing with fallback defaults and path-based value extraction that never throws.

Generic circuit breaker for Go. Protect external calls with automatic failure detection and recovery

Panic recovery utilities for Go — safe goroutines, panic-to-error conversion, and HTTP handler protection

Generic Result type for Go — `Ok[T]` / `Err[T]` with mapping and chaining

Retry with exponential backoff, circuit breaker, and context cancellation for Go

Safe channel utilities for Go with panic-free send/receive, context-aware communication, and combinators

Coroutine-aware circuit breaker for resilient Kotlin services.

Fluent guard clause validation for Kotlin with descriptive error messages.

A lightweight, typed Result monad for Kotlin with railway-oriented error handling.

Coroutine-native retry with configurable backoff strategies for Kotlin.

Non-throwing JSON parsing with typed errors and path-based navigation.

HTTP client wrapper with automatic retries, exponential backoff, and jitter

Typed Result pattern for Laravel service-layer operations with named factory methods and specialized result types

Circuit breaker pattern with configurable thresholds and multiple storage backends

Composable retry utility with exponential backoff, jitter, and exception filtering

Safe JSON parsing with exceptions, schema validation, and typed getters

Atomic file writes with temp-file swap and file locking

Circuit breaker pattern for fault-tolerant service calls.

Decorator and utilities for deprecating functions, parameters, and classes with zero boilerplate

Add a timeout to any function call, sync or async.

Rust-inspired Result type for Python with pattern matching and type-safe error handling

Async retry with exponential backoff, circuit breaker, and cancellation for Python

JSON encoder that handles datetime, Decimal, UUID, dataclasses, and sets without crashing.

Runtime type checking decorators for function arguments

Minimal circuit breaker with configurable thresholds, error filtering, and exponential backoff

Expressive guard clause DSL for method precondition validation

Optional/Maybe monad with safe chaining and pattern matching

Result type with Ok/Err, map, flat_map, and pattern matching

Retry with exponential backoff, jitter, and circuit breaker

Safe timeout patterns without Thread.raise

Concise error handling with fallbacks, chained recovery, and timeout wrapping

Early-return guard clause macros for cleaner control flow

Extension traits for Result and Option with tap, map, and error accumulation

Async retry with exponential backoff and circuit breaker for Rust

Chainable Result monad for error handling without exceptions

Async retry with exponential backoff, circuit breaker, and abort signals

Safe JSON parsing and serialization with circular detection and depth limiting

Safe parsing for primitives — numbers, booleans, dates, JSON from unknown strings

Reliable timeout wrapper for async operations with AbortController support

Circuit breaker pattern for fault-tolerant async service calls

Runtime type guard utilities with TypeScript narrowing

Rust-inspired Result type for type-safe error handling without try/catch

Retry queue with exponential backoff for resilient async processing

Validate and sanitize regular expressions to prevent ReDoS attacks