effepi

v0.3.0

Published

2 years ago

Fun functional programming with pipelinable functions

Downloads

0High
0Medium
0Low

octod

functional programming pipeline pipe typescript function library library

effepi

Fun functional programming with pipelinable functions.

What is effepi?

Effepi is a functional way to enqueue and use different functions. You can put your functions in a pipeline and resolve them both asynchronously or synchronously, creating new async functions or sync functions.

Install

Npm

npm i effepi

Yarn

yarn add effepi

Index

Install

npm i pipe

# or 

yarn add pipe

How to use it

import { pipe, math, misc } from 'effepi';

export const calculateVat = (vatPercentage: number) =>
  pipe<number, number>(misc.useCallValue())
    .pipe(math.divideBy(100))
    .pipe(math.multiplyBy(vatPercentage))
    .toSyncFunction();

vatCalculator(22)(100); // 22
vatCalculator(22)(1285); // 282.7

To create a pipeline, use the pipe function. This function can be used with any function, althought is recommended if you are building a function from a pipeline to use the useCallValue function.

const p = pipe(useCallValue()).toSyncFunction();

p(10) // returns 10
p('hello world') // returns 'hello world'

A pipeline can be memoized, it is useful when you have to call a pipeline a lot of times.

const test = pipe(useCallValue(), true)
  .pipe(add(10))
  .pipe(multiplyBy(2))
  .toSyncFunction();

test(1) // returns 22
test(1) // returns the cached previous result
test(2) // returns 24
test(2) // returns the cached previous result
test(2) // returns the cached previous result

iterating a pipeline

You can iterate a pipeline.

Each iteration returns an immutable pipeline result.

const pipeline = pipe(useCallValue())
  .pipe(pow(2))
  .pipe(add(10))
  .pipe(multiplyBy(4));

const iterpipe = pipeline.iter(10) // 10 is the call value

const first = iterpipe.next();
const second = first.next();
const third = second.next();
const last = third.next();

first.value() // 10
second.value() // 100
third.value() // 110
last.value() // 440

pipeline context

Each function passed in a pipeline can use the previous value and can access to the current pipeline context. A passed context can be enriched with a mutation function, which is the only way to mutate the pipeline from the inside of a function.

const aFunctionUsingContext = (previousValue, context) => {
  // mutations are always executed after the current function
  context.mutate = () => {
    const pipeline = [
      (arg: number) => {
        const isEven = arg % 2 === 0;

        console.log(isEven);
        
        return isEven;
      },
    ];

    return { pipeline };
  };
  console.log(previousValue);
  return previousValue;
};

const isEven = pipe(useCallValue())
  .pipe(aFunctionUsingContext) // uses console.log for context callValue
  .toSyncFunction(); // returns true if the number is even

isEven(10) // logs 10, logs true, returns true

A context has also the call method, which can be used to invoke a function with the previous value as argument.

pipe(useCallValue())
  .pipe(
    (value, context) => context.call(add(10))
  )
).resolveSync(0); // returns 10

Functions

Array functions

Array functions are under the array module.

import { array } from 'effepi';

applyEach

Applies the result of a pipeline to each element in an array of another pipeline.

Note: invoking a pipeline using this function with a sync method will throw an error.

const doMath = pipe(useCallValue())
  .pipe(sum(2))
  .pipe(multiplyBy(3));

pipe(useCallValue())
  .pipe(applyEach(doMath))
  .resolve([10, 20, 30]) // Promise([36, 66, 96])

applyEachSync

Is the same of applyEach, except it does not work with async functions

Note: invoking a pipeline using this function with an async method will throw an error.

const doMath = pipe(useCallValue())
  .pipe(sum(2))
  .pipe(multiplyBy(3));

pipe(useCallValue())
  .pipe(applyEach(doMath))
  .resolveSync([10, 20, 30]) // [36, 66, 96]