or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

function-utilities.mdindex.mdlist-operations.mdmathematical-operations.mdobject-operations.mdstring-processing.md
tile.json

tessl/npm-prelude-ls

A functionally oriented utility library for LiveScript with curried functions for lists, objects, strings, numbers, and function composition.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/prelude-ls@1.2.x

To install, run

npx @tessl/cli install tessl/npm-prelude-ls@1.2.0

index.mddocs/

prelude-ls

prelude-ls is a functionally oriented utility library for LiveScript and JavaScript that provides a comprehensive collection of curried functions for data manipulation. It offers 137 functions across five modules covering list operations, object manipulation, string processing, mathematical operations, and function utilities, designed for elegant functional programming patterns and function composition.

Package Information

  • Package Name: prelude-ls
  • Package Type: npm
  • Language: LiveScript (compiled to JavaScript)
  • Installation: npm install prelude-ls

Core Imports

const prelude = require('prelude-ls');
// Access all functions: prelude.map, prelude.filter, prelude.fold, etc.

ES6 destructuring:

const { map, filter, fold, curry, split, keys } = require('prelude-ls');

Module-specific imports:

const List = require('prelude-ls/lib/List');
const Func = require('prelude-ls/lib/Func');
const Str = require('prelude-ls/lib/Str');
const Obj = require('prelude-ls/lib/Obj');
const Num = require('prelude-ls/lib/Num');

Basic Usage

const { map, filter, fold, curry, split, join } = require('prelude-ls');

// Functional programming with curried functions
const numbers = [1, 2, 3, 4, 5];
const processNumbers = fold((acc, x) => acc + x, 0);
const doubled = map(x => x * 2);
const evens = filter(x => x % 2 === 0);

const result = processNumbers(evens(doubled(numbers)));
// Result: 12 (sum of [2, 4, 6, 8, 10])

// String processing
const words = split(' ', 'hello world from prelude');
const capitalized = map(word => word.charAt(0).toUpperCase() + word.slice(1));
const result2 = join(' ', capitalized(words));
// Result: "Hello World From Prelude"

Architecture

prelude-ls is organized around five specialized modules that work together seamlessly:

  • Function Module (Func): Core functional programming utilities including currying, composition, and higher-order functions
  • List Module (List): Comprehensive array operations with 69 functions covering iteration, transformation, folding, sorting, and searching
  • Object Module (Obj): Object manipulation utilities for conversion, iteration, and property operations
  • String Module (Str): String processing functions including splitting, joining, case conversion, and character manipulation
  • Number Module (Num): Mathematical operations, trigonometric functions, and number property testing

Key Design Principles:

  • Currying: 85 functions are automatically curried for partial application and function composition
  • Immutability: All operations return new values without modifying original data
  • Functional Style: Designed for point-free programming and function composition
  • LiveScript Integration: Optimized for LiveScript syntax but works perfectly with JavaScript

Capabilities

List Operations

Comprehensive array manipulation with functional programming patterns. Includes iteration, transformation, folding, sorting, searching, and mathematical operations on arrays.

// Core iteration and transformation
function each(fn, array);
function map(fn, array);
function filter(predicate, array);
function fold(fn, initial, array);

// Array structure operations
function head(array);
function tail(array);
function reverse(array);
function flatten(array);

List Operations

Object Operations

Object manipulation utilities for converting between objects and arrays, iterating over properties, and transforming object structures.

// Object conversion
function keys(object);
function values(object);
function objToPairs(object);
function pairsToObj(pairs);

// Object transformation
function map(fn, object);
function filter(predicate, object);

Object Operations

String Processing

String manipulation functions including splitting, joining, case conversion, and character-level operations. Many functions inherit list operations for treating strings as character arrays.

// String splitting and joining
function split(separator, string);
function join(separator, array);
function words(string);
function lines(string);

// Case conversion
function capitalize(string);
function camelize(string);
function dasherize(string);

String Processing

Function Utilities

Core functional programming utilities including currying, function composition, argument manipulation, and memoization.

// Function transformation
function curry(fn);
function flip(fn);
function apply(fn, args);

// Function composition
function over(fn, gn, x, y);
function fix(fn);

Function Utilities

Mathematical Operations

Comprehensive mathematical functions including basic arithmetic, trigonometry, logarithmic operations, and number property testing.

// Basic operations
function max(a, b);
function min(a, b);
function abs(n);
function signum(n);

// Division operations
function div(a, b);
function mod(a, b);
function quot(a, b);
function rem(a, b);

// Trigonometric functions
function sin(x);
function cos(x);
function tan(x);

Mathematical Operations

Core Types

// Built-in utility functions
function id(x);                    // Identity function
function isType(type, value);      // Type checking
function replicate(n, value);      // Create array with n copies of value

// Constants
const VERSION = "1.2.1";           // Library version

Common Patterns

Function Composition

const { map, filter, fold, curry } = require('prelude-ls');

// Create reusable functions through currying
const double = map(x => x * 2);
const evens = filter(x => x % 2 === 0);
const sum = fold((a, b) => a + b, 0);

// Compose operations
const processNumbers = numbers => sum(evens(double(numbers)));

Data Pipeline Processing

const { split, map, filter, join } = require('prelude-ls');

const processText = text => 
  join(' ', 
    filter(word => word.length > 3,
      map(word => word.toLowerCase(),
        split(' ', text))));