OOFP — Functional Programming for TypeScript

Why OOFP?

Type-safe by default

Every function, every monad, every composition is fully typed. TypeScript inference works end-to-end with no casts needed.

Real-world patterns

Built for production applications. ReaderTaskEither provides dependency injection, async operations, and error handling in a single type.

Zero dependencies

No runtime dependencies. Tree-shakeable modular imports keep your bundle small.

Composable

Everything composes with pipe and flow. Build complex workflows from simple, reusable functions.

Quick Example

import * as RTE from "@oofp/core/reader-task-either";
import * as E from "@oofp/core/either";
import { pipe } from "@oofp/core/pipe";

interface AppContext {
  db: Database;
  logger: Logger;
}

const findUser = (id: string) =>
  pipe(
    RTE.ask<AppContext>(),
    RTE.chaint((ctx) => ctx.db.findUser(id)),
    RTE.tapRTE((user) => logAccess(user)),
  );

// Execute at the boundary
const result = await RTE.run(appContext)(findUser("123"))();

pipe(
  result,
  E.fold(
    (error) => console.error(error),
    (user) => console.log(user),
  ),
);

Packages

@oofp/core Algebraic data types: Maybe, Either, Task, TaskEither, Reader, RTE, and more.

@oofp/http Functional HTTP client built on ReaderTaskEither.

@oofp/query Functional query cache with TTL and invalidation.

@oofp/saga Saga pattern for transactional workflows with compensation.

@oofp/react React hooks for functional patterns (experimental).