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.

Bugs of Feature Request?

If you have found a bug, please feel free to open an issue or to create a pull request with the fix.

If you want a specific feature, please check if there is an open pull requests about it, otherwise create an issue with the proper template. If you have implemented it yourself, a pull request is really welcome.

Install

Npm

npm i effepi

Yarn

yarn add effepi

Index

effepi
What is effepi?
Install
- Npm
- Yarn
- Index
Install
How to use it
- iterating a pipeline
- pipeline context
Functions
- Array functions
  - applyEach
  - applyEachSync
  - concat
  - filter
  - filterWith
  - find
  - findExact
  - join
  - length
  - nth
  - reverse
- Boolean functions
  - F
  - T
  - inverse
- Math functions
  - add
  - changeSign
  - decrement
  - divideBy
  - increment
  - isNegative
  - isPositive
  - multiplyBy
  - negative
  - positive
  - pow
  - root
  - subtract
  - takeBetween
  - takeGreater
  - takeGreaterThan
  - takeLower
  - takeLowerThan
  - takeOuter
- Logical operators functions
  - createSwitch
  - fold
  - ifElse
- Object functions
  - exclude
  - hasProperty
  - keys
  - maybe
  - merge
  - pick
- Misc functions
  - adapt
  - apply
  - applySync
  - callWith
  - put
  - safeCall
  - useCallValue
  - useValue
- String functions
  - camelCase
  - chars
  - concat
  - includes
  - length
  - lowercase
  - pascalCase
  - repeat
  - replaceAll
  - toBinaryArray
  - uppercase
- Type functions
  - exactTypeOf
  - ofType
  - toArray
  - toBoolean
  - toDate
  - toNumber
  - toSet
  - toString
- Contributing
- Licence

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]