yambda

This is a work in progress, more functions and documentation will come soon.

Documentation

Getting started

Installation

$ npm install --save yambda

Usage

Importing all the library:

import y from 'yambda';

y.typeOf('foo');

Importing only one function :

import typeOf from 'yambda/typeOf';

typeOf('foo');

Motivation

I was very impressed by how Haskell render complicated operations in a simply way, so I try to implement Haskell functions in javascript and this lead me to create this library.

The idea was also to enable functions such as map() or reduce() on whatever. So this mean to consider any types as functor, applicative or monad.

But the approach is different from library such as Immutable. Instead of wrapping a native types inside an object with more methods, yambda can take (depending on the function) any types and return a value with the same type. The problem with wrapping is that you need 3 step to do a simple operation:

import { Map } from 'immutable';
import map from 'yambda/map';

const inc = (x) => x + 1;
const obj = { foo: 1, bar: 2 };

const res = Map(obj).map(inc).toJS(); // { foo: 2, bar: 3 }

// with yambda
const res2 = map(inc, obj); // { foo: 2, bar: 3 }

yambda try also to be compatible with any libraries. When function accept any type, it will try to use the object method first. So this mean that if you are working with Immutable, you can also do:

import { Map } from 'immutable';
import map from 'yambda/map';

const inc = (x) => x + 1;
const obj = { foo: 1, bar: 2 };

const myMap = Map(obj);
const res = map(inc, myMap); // Map({ foo: 2, bar: 3 })

Functional

yambda only expose functions. The goal is to compose an manipulate those functions in order to create new ones. yambda's functions have a specific order in their arguments such as the subject of the function is always (when it makes sens) the last one in order to facilitate composition:

import map from 'yambda/map';

map(fn, subject);

Pure and Immutable

All functions of yambda are pure and immutable.

Curried but not fixed arity

All functions of yambda are curried by default but not they have not a fixed arity (may change in the futur).

Inspiration

Thanks to those projects, I learnt a lot and they gave me the desire to create this library.

• Haskell
• Fantasy Land Specification
• Functional Programming Jargon
• Lodash
• Rambda
• Immutable

Contributing

Every ideas and contributions are welcomed.

Licence

MIT © 2016-present Renaud Tertrais