Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More
Socket
Sign inDemoInstall
Socket

fluent-curry

Package Overview
Dependencies
Maintainers
1
Versions
2
Alerts
File Explorer

Advanced tools

Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

fluent-curry

Curry functions using a type-safe fluent API.

  • 0.0.2
  • latest
  • Source
  • npm
  • Socket score

Version published
Maintainers
1
Created
Source

fluent-curry

Curry functions using a type-safe fluent API.

Example: Options object

For functions that take a single object parameter, the type of the curried result is infered from the object parameter type.

import { fluentCurry } from "fluent-curry";

const adLib = (args: { name: string; age: number; }) => {
  return `${args.name} is ${args.age}.`;
};

const curried = fluentCurry(adLib);

curried.name('Will').age(25).call() === adLib({ name: 'Will', age: 25 });

Example: Multiple paramters

For functions that take multiple parameters, we must supply an array of paramter names in the same order that they appear in the function signature.

const adLib = (name: string, age: number) => {
  return `${name} is ${age}.`;
};

const curried = fluentCurry(adLib, ['name', 'age']);

curried.name('Will').age(25).call() === adLib({ name: 'Will', age: 25 });

Partial Applications

fluent-curry makes working with partial applications easy. Create reusable logic without a cumbersome bind method.


const partialWill = curried.name('Will');

partialWill.age(25).call() === adLib({ name: 'Will', age: 25 });

Any parameters that have not been previously applied can be supplied in the call function as an options object.


// Call with Parameters

partialWill.call({ age: 25 }) === adLib({ name: 'Will', age: 25 });

curried.call({ name: 'Will', age: 25 }) === adLib({ name: 'Will', age: 25 });

Why?

Currying (and, relatedly, partial applications) are two powerful patterns in functional programming. However, the traditional approach to currying has poor syntax.

const func = (a, b, c) => {}
const curried = curry(func);

curried('foo')('bar')('foobar');

While terse, using positional arguments sacrifices readability. Furthermore, this syntax tends to trip up programmers with less functional programming experience.

Traditional currying also makes it difficult to skip over optional arguments or create partial applications--usually, libraries will rely on some sort of special skip value:

import { _ } from 'some-other-curry-library';

const partialBar = curried(_)('bar')(_);

While the approach taken by fluent-curry definitely requires more typing, it is always clear to the developer what argument is being passed. Arguments can also occur in any order, and can be easily left off to create partial applications.


const curried = fluentCurry((a: number, b: number, c: number) => {
  return a + b + c;
}, ['a', 'b', 'c'])

const abc = curried.a(1).b(2).c(3).call();
const bca = curried.b(2).c(3).a(1).call();
const cba = curried.c(3).b(2).a(1).call();
const ab = curried.a(1).b(2);

abc === bca === cba === ab.c(3).call();

FAQs

Package last updated on 21 Dec 2022

Did you know?

Socket

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

Related posts

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

Packages

npm

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc