Open-source alternatives to Returns

Toolz is a Python library that implements functional programming utilities for iterable transformation, dictionary manipulation, function composition, and lazy evaluation. It provides a set of pure functions designed to work with Python's built-in data structures, enabling concise and composable data processing workflows. What distinguishes toolz is its support for curried partial application, allowing functions to be incrementally applied and reused. It includes dictionary-centric operations that handle nested structures, and offers iterable chain transformers that combine mapping, filtering

PureScript is a statically typed, purely functional programming language that compiles to JavaScript. It is designed as a cross-platform frontend language for building safe web applications, utilizing a static type system and a JavaScript compiler to ensure program correctness across browser and server environments. The language is distinguished by its emphasis on mathematical purity, featuring a robust type system with first-class support for monads. It provides a sophisticated toolset for static verification, including algebraic data types, type classes, and automatic type inference to reje

Ramda is a functional JavaScript standard library and toolset for immutable data transformation and composition. It provides a comprehensive suite of pure utility functions designed to enable declarative data processing pipelines. The library is distinguished by its use of automatic function currying and a data-last argument order. These design patterns allow multi-argument functions to be partially applied, simplifying the construction of processing chains where data is passed through a sequence of operations. The toolkit covers broad data manipulation capabilities, including list processin

re-frame is a functional framework for building single-page applications in ClojureScript. It provides a centralized, immutable database that serves as the single source of truth for the entire application state, enforcing a strict unidirectional data flow where events trigger state transitions and subsequent view updates. The framework distinguishes itself through a reactive signal graph and an interceptor-based middleware pipeline. By treating application logic as a sequence of data-driven events and declarative side effects, it decouples business logic from the view layer. This architectur

SwiftTips is a curated collection of guides, libraries, and design patterns focused on Swift language mastery, application architecture, and API design. It provides a technical resource for implementing advanced coding techniques and architectural best practices. The project emphasizes creating type-safe and conversational interfaces through strategic protocol composition and generics. It offers specialized patterns for building modular UI systems and managing complex view hierarchies, alongside comprehensive strategies for unit testing and dependency injection. The resource covers a broad s

neverthrow is a TypeScript result type library that implements railway oriented programming. It provides a functional error handling framework using type-safe wrappers to represent operation outcomes as either success or failure variants, eliminating the need to throw exceptions. The library features adapters that convert throwing functions and asynchronous promises into typed result objects. This allows asynchronous rejections and unsafe code to be handled as explicit return values rather than uncaught exceptions. The framework covers a broad range of functional computation capabilities, in

Arrow is a functional programming library for Kotlin that provides tools for implementing data-oriented programming patterns. It serves as a framework for typed error handling, a concurrency toolkit, and a library for the manipulation of immutable data. The project distinguishes itself through specialized capabilities for managing application failures using explicit types instead of exceptions and implementing resilience patterns such as circuit breakers and retry policies for distributed services. It also provides optics to update and query deeply nested immutable data structures without man

Cats is a Scala functional programming library and type class library designed to implement algebraic patterns and functional abstractions. It provides a standardized set of interfaces and a modular toolkit of functional wrappers and containers to enable ad-hoc polymorphism and generic programming across disparate types. The project serves as a functional abstraction standard, offering a monad transformer suite to compose nested effectful contexts and handle multiple computational side effects within a single pipeline. It further enables the construction of embedded domain-specific languages

Coconut is a functional programming language that compiles to Python. It functions as a source-to-source compiler, translating high-level functional syntax into compatible Python code to maintain runtime compatibility. The language introduces a logic system for pattern matching and destructuring complex data structures. It provides a mechanism for tail call optimization to prevent stack overflow errors during deep recursive function calls and employs a lazy evaluation engine to defer computations until results are explicitly required. The project includes support for algebraic data types, pi

c3c is the compiler for the C3 programming language, transforming source code into executable binaries, static libraries, or dynamic libraries using an LLVM backend. It implements a system based on result-based error handling, scoped memory pooling, and a semantic macro system. The compiler provides first-class support for hardware-backed SIMD vectors that map directly to processor instructions and enables runtime polymorphism through interface-based dynamic dispatch. The project covers a broad set of low-level capabilities, including manual and pooled memory management, inline assembly inte

Remeda is a type-safe functional utility library for TypeScript designed for building data transformation pipelines. It provides a toolkit of helper functions for manipulating arrays and objects while maintaining strict type integrity throughout the process. The library is characterized by its support for both data-first and data-last calling styles. It utilizes lazy evaluation to process data collections, evaluating transformations only when the final result is requested to avoid creating intermediate collection copies. The toolkit covers collection manipulation, function composition, and t

Borgo is a statically typed language and compiler that transforms high-level syntax into Go source code. It functions as a transpiler designed to leverage the Go runtime while introducing a type system centered on algebraic data types and result-based error handling. The language distinguishes itself by replacing Go's multiple return values with result and option types, using a dedicated operator for concise error propagation. It implements sum types with exhaustive pattern matching and provides a tool to generate bindings for existing Go packages, automatically converting multi-value returns

Dollar is a functional programming library for Swift that provides a comprehensive toolkit for collection manipulation, string processing, mathematical calculations, and date and time management. It serves as a utility suite for filtering, aggregating, and restructuring arrays and dictionaries. The project implements functional programming patterns such as currying, memoization, and function composition. It also features a chainable wrapper interface that allows multiple data transformations to be applied sequentially before extracting a final result. The library covers a wide range of capab

Error-or is a library that implements the result pattern to replace exception-based control flow with structured data. It provides a discriminated union implementation that encapsulates either a successful value or an error state within a single type, ensuring that operation outcomes are treated as first-class values. The library enables functional error handling by providing a fluent interface for chaining sequential operations. This monadic pipeline composition allows developers to define dependent operations that automatically short-circuit and return an error if any individual step in the

Just is a collection of JavaScript utility libraries designed for data manipulation, functional programming, performance optimization, statistical analysis, and string processing. It provides a set of tools for deep cloning, filtering, and transforming complex objects and arrays. The project is structured as a series of zero-dependency modules, allowing utilities to be used independently to minimize bundle size. It implements functional programming patterns including currying, piping, and partial application, and provides execution control through memoization, debouncing, and throttling. The

Lodash is a JavaScript utility library and data manipulation toolkit. It provides a collection of modular functions for transforming, filtering, and validating arrays, objects, strings, and numbers. The project functions as a functional programming toolkit, offering capabilities for function composition, currying, and lazy evaluation. It includes mechanisms for execution control, such as debouncing and throttling, to manage the timing and frequency of function invocations. The library covers a broad surface of data operations, including deep cloning and merging of complex nested structures,

Functional-Light-JS is a JavaScript functional programming library designed to implement functional patterns within JavaScript applications. It serves as a toolkit for declarative data processing, immutable data management, and the construction of complex logic through higher-order functions. The library focuses on a pragmatic implementation of functional programming, providing utilities for curried argument application and function composition. It emphasizes the use of pure functions to calculate state updates and manage application data without side effects. The project covers broad capabi

This is the open-source iOS application for Kickstarter, a platform that lets users discover and back creative projects, manage pledges, and track campaign updates from their mobile device. The app is built around a view model architecture that maps input signals to output signals in a pure functional core, isolating side effects to the boundary layer for testability. The project employs a reactive view model pattern with signal-driven state management, using Swift protocols for component design to enable dependency injection and mock-based testing. User interfaces are assembled entirely in c

This project is a compatibility layer and abstraction library for building native C++ addons for Node.js. It provides a consistent C++ API that allows a single codebase to compile against multiple versions of the V8 JavaScript engine by hiding version-specific differences behind macros and inline functions. The toolkit differentiates itself through specialized wrappers and managers, including a monadic wrapper for handles to avoid explicit null checks, a persistent reference manager for objects that must survive handle scope disposal, and a buffer abstraction API for version-compatible memory

Boost is a collection of portable, high-performance source libraries that extend the C++ standard library. It provides a wide range of reusable components, data structures, and algorithms designed to add capabilities to the base language across different platforms. The project is distinguished by its extensive focus on compile-time template metaprogramming and generic programming. It implements advanced architectural patterns such as policy-based design, concept-based type validation, and the use of SFINAE for conditional template resolution to minimize runtime overhead. The library covers a

This project provides a structural pattern for organizing React and TypeScript applications by decoupling business logic from user interface components and external infrastructure. It implements a layered architecture that isolates core domain rules, ensuring that the application remains independent of specific frameworks, libraries, or external service implementations. The architecture relies on dependency injection and inversion principles to manage service implementations, allowing for modularity and easier testing. By utilizing a functional core and imperative shell, the system separates

Effector is a reactive state management library and data flow orchestrator designed for building complex, event-driven applications. It models application logic as a directed acyclic graph, where state updates and asynchronous side effects propagate automatically through declarative pipelines. By decoupling business logic from user interface layers, it allows developers to maintain state in independent containers that communicate via standard interfaces, ensuring the system remains framework-agnostic. The library distinguishes itself through its robust support for isolated execution scopes, w

Carp is a statically typed Lisp compiler that compiles Lisp-like syntax directly to C source code, enabling seamless integration with existing C libraries and low-level system programming. It manages memory deterministically at compile time using ownership tracking and linear types, eliminating garbage collection pauses and runtime overhead while ensuring type safety through an inferred static type system. The language distinguishes itself through compile-time macro expansion and metaprogramming capabilities, allowing code generation and transformation before final binary output. It enforces

This repository is a collection of JavaScript coding challenges and a comprehensive interview guide. It provides reference implementations and educational examples designed to help developers master language fundamentals and prepare for technical interviews. The project covers a wide array of specialized implementations, including functional programming patterns like currying and partial application, as well as asynchronous patterns for concurrency control. It also includes practical examples of Document Object Model manipulation and the implementation of common data structures such as stacks

ts-toolbelt is a collection of specialized utilities for manipulating and validating TypeScript types. It provides a toolkit for performing complex transformations on objects, unions, and functions to enforce strict data consistency at compile time. The library features dedicated transformers for function types, including utilities for currying, composition, and signature extraction. It also includes an object type manipulator for deep merging, patching, and reshaping complex structures. The capability surface extends to literal string processing, type-level arithmetic, and tuple operations.

Lancet is a comprehensive extension of the Go standard library, providing a collection of reusable functions and data structures designed to reduce boilerplate code in applications. It serves as a general-purpose toolkit across multiple domains, including concurrency, security, networking, and functional logic. The project distinguishes itself through specialized toolkits for Go concurrency, such as keyed locking and channel-based stream processing, and a dedicated functional programming kit that supports currying and function composition. It also includes a dedicated cryptography library imp