remeda

What is remeda?

Remeda is a utility library for JavaScript and TypeScript that provides a collection of functions for working with arrays, objects, and other data types. It is designed to be a modern, functional alternative to libraries like Lodash, with a focus on immutability and type safety.

What are remeda's main functionalities?

Array Manipulation

Remeda provides a variety of functions for manipulating arrays, such as `filter`, `map`, and `reduce`. These functions can be composed using `R.pipe` to create complex transformations in a readable and functional style.

const arr = [1, 2, 3, 4, 5];
const result = R.pipe(
  arr,
  R.filter(x => x % 2 === 0),
  R.map(x => x * 2)
);
console.log(result); // [4, 8]

Object Manipulation

Remeda includes functions for working with objects, such as `omit`, `pick`, and `merge`. These functions allow you to create new objects with specific properties removed, selected, or combined.

const obj = { a: 1, b: 2, c: 3 };
const result = R.omit(obj, ['b']);
console.log(result); // { a: 1, c: 3 }

Functional Programming

Remeda supports functional programming techniques, such as partial application and currying. The `partial` function allows you to create new functions with some arguments pre-filled, making it easier to create reusable and composable functions.

const add = (a, b) => a + b;
const add10 = R.partial(add, 10);
console.log(add10(5)); // 15

Type Safety

Remeda is designed with TypeScript in mind, providing type-safe functions that help catch errors at compile time. This ensures that your code is more robust and less prone to runtime errors.

const arr: number[] = [1, 2, 3, 4, 5];
const result = R.map(arr, x => x * 2);
console.log(result); // [2, 4, 6, 8, 10]

Other packages similar to remeda

lodash

Lodash is a popular utility library that provides a wide range of functions for working with arrays, objects, and other data types. While Lodash is more widely used and has a larger community, Remeda offers a more modern and functional approach with better TypeScript support.

ramda

Ramda is a functional programming library for JavaScript that emphasizes immutability and function composition. Like Remeda, Ramda provides a collection of functions for working with data in a functional style. However, Remeda is designed to be more type-safe and user-friendly for TypeScript users.

fp-ts

fp-ts is a library for functional programming in TypeScript. It provides a comprehensive set of tools for working with functional programming concepts, such as monads and functors. While fp-ts is more powerful and flexible, it has a steeper learning curve compared to Remeda.

README

Remeda

The first "data-first" and "data-last" utility library designed especially for TypeScript.

Documentation

Read the full docs and API reference on remedajs.com/docs.

Migrating from Lodash or Ramda? Check the function mapping on remedajs.com/mapping.

Features

• First-class TypeScript support, with types that are as specific as possible.
• Supports data-first (R.filter(array, fn)) and data-last (R.filter(fn)(array)) approaches.
• Lazy evaluation support with pipe and piped.
• Runtime and types are both extensively tested, with full code coverage.
• Tree-shakable, supports CJS and ESM.
• Fully documented with JSDoc, supports in-editor function documentation.

Getting started

Installation

npm install remeda
pnpm add remeda
yarn add remeda
bun install remeda

Usage

// Import everything:
import * as R from "remeda";

// Or import methods individually:
// import { pipe, tap, unique, take } from "remeda";

R.pipe(
  [1, 2, 2, 3, 3, 4, 5, 6],
  R.tap((value) => console.log(`Got ${value}`)),
  R.unique(),
  R.take(3),
); // => [1, 2, 3]

// Console output:
// Got 1
// Got 2
// Got 2
// Got 3

Getting help

Questions, bug reports, and feature requests are tracked in GitHub issues.