FxTS is a functional programming library for TypeScript.

Provides lazy evaluation for memory-efficient data processing with functions like pipe, map, filter, and take.
Handles concurrent requests efficiently with concurrent and toAsync.
Offers excellent TypeScript support with strong type inference.
Follows standard iteration protocols (Iterable/AsyncIterable).

Why FxTS?

	FxTS	lodash	Native (Array + Iterator Helpers)
Lazy evaluation	✅	🔶 `_.chain` only	✅ ES2025
AsyncIterable pipelines	✅	❌	❌ (proposal stage)
Concurrency control with backpressure	✅ `concurrentPool`	❌	❌
Curried, data-last composition (`pipe`)	✅	🔶 `lodash/fp`	❌
Early termination across async work (`take`)	✅	❌	🔶 sync only
Literal-preserving inference (`Record<"a"…>`)	✅	❌	—
Deep utils (`isEqual`, `cloneDeep`, `merge`)	✅	✅	❌

Migrating from p-limit/p-map? See the migration guide.

Installation

npm install @fxts/core

Usage

Use pipe for function composition or fx for method chaining:

import { each, filter, fx, map, pipe, range, take } from "@fxts/core";
pipe(
  range(10),
  map((a) => a + 10),
  filter((a) => a % 2 === 0),
  take(2),
  each((a) => console.log(a)),
);
// chaining
fx(range(10))
  .map((a) => a + 10)
  .filter((a) => a % 2 === 0)
  .take(2)
  .each((a) => console.log(a));

Usage (concurrent)

Handle multiple async operations in parallel with concurrent:

import { concurrent, countBy, flat, fx, map, pipe, toAsync } from "@fxts/core";
// maybe 1 seconds api
const fetchWiki = (page: string) =>
  fetch(`https://en.wikipedia.org/w/api.php?action=parse&page=${page}`);
const countWords = async (concurrency: number) =>
  pipe(
    ["html", "css", "javascript", "typescript"],
    toAsync,
    map(fetchWiki),
    map((res) => res.text()),
    map((words) => words.split(" ")),
    flat,
    concurrent(concurrency),
    countBy((word) => word),
  );
await countWords(); // 4 seconds
await countWords(2); // 2 seconds

Documentation

For more information, visit fxts.dev.

For LLM-friendly documentation, see llms.txt.

Contributing