tack-on

tack-on

Some neato functions inspired by the new bind operator and functional programming.

tack

Attach a function to a thing, without hanging it directly. Great to add functionality that should have been there from the start, without the risk of mutating global objects.

tack(func, injectPosition = 0, actionFunc?)

What?

import mapValues from 'lodash';
import { tack } from 'tack-on';

const map = tack(mapValues);
let succ = n => n + 1;

expect({ a: 1, b: 2 }::map(succ)).to.deep.equal({ a: 2, b: 3 });

Tacked functions assume composing behavior when bound to functions.

const succ = tack(n => n + 1);
const pred = tack(n => n - 1);

expect(succ::pred::succ::succ(0)).to.equal(2);

The position this is inserted into can be specified.

const toTriple = tack((a, b, c) => [a, b, c], 1);

expect('middle'::toTriple('start', 'end')).to.equal(['start', 'middle', 'end']);

A custom action function can be provided that will change the defaults for when to tack, when to compose and when to do call the original function.

const f = tack(
  func => func(2),
  0,
  t => t !== undefined ? 'tack' : 'nothing'
);

// f will tack to functions instead of composing with them.

expect(succ::f()).to.equal(3);

compose

Make functions composable with the bind operator. compose assumes functions that take only one argument.

What?

import { compose } from 'tack-on';

succ = compose(succ);
const pred = compose(n => n - 1);

expect(succ::pred::succ::succ::succ::pred(1)).to.equal(3)

const addThreeMorphism = succ::succ::succ;

expect(addThreeMorphism(3)).to.equal(6);