Browse Kotlin Multiplatform libraries

Zero-overhead Result monad for modelling success or failure in operations, offering features like chaining, transformation, and binding support, inspired by Elm, Haskell, and Rust.

Lightweight, feature-rich declarative error handling framework for functional programming, offering 90+ operators. Ensures compile-time error handling and enhances code readability and extensibility through Railway Programming principles.

Fork of Result library adds a loading state, offering seamless integration and conversion utility functions. Mimics Result's API while enabling loading state handling for enhanced functionality.

Enhances interoperability with platform-specific APIs by providing a result class wrapper. Offers convenient methods for handling success and failure cases, including transformation functions and non-fatal exception handling.

Type-safe, coroutine-first SDK and Worker gateway enabling publishable-key access to D1, KV, R2, and realtime APIs; includes Result monad, D1 table API, KV JSON helpers, and Worker template.

Implements `Either` and `Option` types for managing dual-value and optional state scenarios. Enhances serialization, deserialization, and transformation capabilities, providing flexible error handling and state management.

Empowers creation of domain-specific types, addressing Primitive Obsession through a framework inspired by Refinement Type Theory. Useful for Domain-Driven Design, offers flexible type refinement.

For PocketBase: modular clients, coroutine-first APIs, result-based error handling, typed decoding helpers, cancellation-safe operations, auth workflows, realtime subscriptions, plus files and admin services.

Enhances projects with utility classes for collection handling and functional programming, featuring types like `Option`, `Either`, and `Try`, and iterators like `EmptyIterator` and `SingletonIterator`.

Enhances error handling with a custom `Result` type, allowing flexible error types and eliminating the need for wrapping results in Ok/Error objects, streamlining code efficiency.

Offers a library that enables functional inheritance-based alternatives to value classes, addressing compilation issues across languages and retaining type integrity for public APIs.

Represents a result type encompassing success or failure, offering customizable failure types, and features like `andThen`, `whenFailure`, and a `fold` method for pattern-matching-like functionality.

Extends retry functionality to handle operations returning Arrow's Either type, facilitating error handling without exceptions. Enhances retry logic with customizable policies.

Facilitates error handling and success management with a functional approach, improving code readability and maintainability through a clear representation of operation outcomes.

Functional monads for safer null and error handling: Maybe, Either, Try; error-accumulating types, evaluation combinators for combining results, and tuple utilities up to quintuple.

Facilitates safer error handling by representing computations that can fail, offering methods to map, recover, and transform results while avoiding exceptions.

Offers an oversimplified result monad library, facilitating error handling and result processing through chaining functions like `andThen`, `onOk`, and `onErr` for streamlined message processing.

Alternative to the Result type, enabling typed error handling. Supports operations like `getOrElse`, `map`, and `flatMap` for enhanced error management and control flow.

Rust-style Result and Option types offering some/none and ok/err constructors, chainable combinators, pattern-friendly APIs and ergonomic error/optional-value handling for safer, expressive code.

Lazy, composable, memoized computations that evaluate on demand and cache results; supports map/flatMap/zip, recursive memoization builders, Delay abstraction, and stack-safe composition via internal trampoline.