Tightrope Functional Utility Library

0.3.0 verified Thu Apr 23 auth: no javascript

tightrope is a modern, point-free functional programming utility library designed for JavaScript applications, currently at version 0.3.0. It provides a concise and immutable API for common data transformations and functional composition, emphasizing a declarative style of programming. Unlike larger general-purpose utility libraries, tightrope focuses specifically on point-free utilities, which can lead to more readable and maintainable code for those familiar with the paradigm. Its development cadence is typical for an early-stage library, with features added incrementally and potential breaking changes in minor versions until a stable 1.0 release. It targets Node.js environments version 18 and higher, leveraging modern JavaScript features.

Common errors

error TypeError: (0 , _tightrope.pipe) is not a function ↓

cause This error typically indicates an issue with module resolution, often when mixing CommonJS `require` with an ESM-first library like tightrope, or an incorrect bundling configuration.

fix

Ensure your project is configured for ESM. Use import { pipe } from 'tightrope' and set "type": "module" in your package.json if running in Node.js, or configure your bundler (Webpack, Rollup, Parcel, Vite) to correctly handle ESM imports.

error ReferenceError: map is not defined ↓

cause This occurs when trying to use a tightrope function (e.g., `map`) without explicitly importing it via destructuring.

fix

Always import individual utilities as named exports: import { map } from 'tightrope'. Do not try to access them directly from a top-level tightrope object or as a default import.

Warnings

breaking As a 0.x.x version library, tightrope does not guarantee API stability between minor versions. Breaking changes can and do occur, requiring careful review of release notes when upgrading. ↓

fix Always review the release notes (`CHANGELOG.md` on GitHub) for each new minor version before upgrading in production environments. Pin specific `0.x.x` versions if strict API stability is required.

gotcha tightrope strictly adheres to a point-free functional paradigm. Functions are automatically curried, and argument order is designed for partial application. This can be a learning curve for developers new to functional programming. ↓

fix Familiarize yourself with functional programming concepts like currying, partial application, and immutability. Consult the official tightrope documentation for specific function signatures and examples of point-free usage.

gotcha The library does not currently ship with TypeScript declaration files. While it can be used in TypeScript projects, type inference may be limited, and explicit type declarations (`@ts-ignore` or custom types) might be necessary. ↓

fix Consider contributing type definitions to the project or creating local `.d.ts` files for the functions you use. Use `@ts-ignore` sparingly for functions that are correctly used but lack type information.

gotcha tightrope is designed for immutable operations. All functions return new data structures rather than modifying existing ones. Attempting to mutate results from tightrope functions will lead to unexpected behavior and violate functional principles. ↓

fix Always treat the output of tightrope functions as new, immutable data. If mutation is absolutely necessary (though generally discouraged in functional paradigms), ensure it's performed on a deep clone of the data outside of the tightrope function chain.

Install

npm install tightrope

yarn add tightrope

pnpm add tightrope

Imports

pipe
wrong
```
const { pipe } = require('tightrope')
```
correct
```
import { pipe } from 'tightrope'
```
tightrope is ESM-first, targeting Node.js >=18. CommonJS `require()` may work via transpilation or bundlers, but direct usage is not officially supported and can lead to issues without proper configuration.
map
wrong
```
import map from 'tightrope'
```
correct
```
import { map } from 'tightrope'
```
All utilities are named exports; there is no default export. Attempting to import a default will result in `undefined`.
prop
wrong
```
import { prop as getProp } from 'tightrope'
```
correct
```
import { prop } from 'tightrope'
```
While aliasing is syntactically correct, it's generally unnecessary as `prop` is a common and clear functional name. Stick to direct imports for consistency.

Quickstart

This quickstart demonstrates composing functions using `pipe` to filter and map an array of objects in a point-free style. It shows how to extract specific data based on multiple criteria without explicit intermediate variables.

import { pipe, map, filter, prop, always } from 'tightrope';

const users = [
  { id: 1, name: 'Alice', active: true, age: 30 },
  { id: 2, name: 'Bob', active: false, age: 24 },
  { id: 3, name: 'Charlie', active: true, age: 35 }
];

const getActiveUserNamesOverAge = (minAge) => pipe(
  filter(user => user.active),
  filter(user => user.age > minAge),
  map(prop('name'))
);

const activeSeniorNames = getActiveUserNamesOverAge(30);

console.log(activeSeniorNames(users));
// Expected output: ['Charlie']

// Example using a simple constant and identity
const sayHello = always('Hello, tightrope!');
console.log(sayHello());