limbda v0.3.2
limbda
Rationale
After having implemented array reduce with using ES6 features I remembered while having worked with Clojure for a while how nice it was that collection transformations could be done on any type of collection. One of the library's aims is to make transformations work for all collection types as well as implement some functional programming paradigms to make function composing easier.
This library is a playground for me at the same time. It's fun to experiment with basic datastructures and transformations. And also a good place to play with ES6 features also.
State
Creation of proper benchmarking is in progress.
Sample, sum 10 000 numbers:
limbda#reduce | Sum numbers 0.00011549035685890135
lodash#reduce | Sum numbers 0.00012098247137972124
Array#reduce | Sum numbers 0.00006934145322898773
Breaking changes might happen. Best thing to do if you'd like to sniff around is to check the tests to get a picture how the library methods work. (Tests keep the contract for the functions' interface, check them for change between commits before you upgrade to a new version.)
Install
npm install limbda
Usage
Import as you would any other packege in Node.js, eg.:
const limbda = require('limbda');
Documentation
isIterable
Check if x
implements the iterable interface/protocol. (ES6 rest/spread operations, also generators need iterables.)
isIterable(x: Any?) -> Boolean
reduce, map, filter
Reduce, map & filter work for all basic Javascript collection types: String, Array, Object, Map, Set & Arguments (Array-likes).
Transforming functions
When reducing, mapping or filtering an String, Array or Set, item will be a value. In case of key-value types, item will be an "Object Entry", a.k.a. an Array of 2 items, a pair, [key, value]
. See signatures.
The transforming functions should return a value so that collection transformation will have a "worthwhile" final value in the end.
reduce
reduce(reducer: Function, collection: AnyColl?, initialValue: Any?) -> Any?
reducerFunction(accumulator: Any?, item: Any?) -> Any?
# String, Array & Set reducer signature:
const reducerA = (accumulator, value) => accumulator + value;
# Object, Map reducer signature:
const reducerB = (accumulator, [key, value]) => accumulator + (key + value);
map
map(transformer: Function, collection: AnyColl?) -> Array
transformerFunction(value: Any?) -> Any?
# String, Array & Set transformer signature:
const transformerA = value => f(value);
# Object, Map transformer signature:
const transformerB = ([key, value]) => f(key, value);
filter
filter(filtering: Function, collection: AnyColl?) -> Array
filteringFunction(value: Any?) -> Bool?
# String, Array & Set filtering signature:
const filteringFnA = value => f(value);
# Object, Map filtering signature:
const filteringFnB = ([key, value]) => f(key, value);