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');

Motivations

I was very impressed by how Haskell was rendering complicated operations more simple, so I tried to implement Haskell's functions in javascript and this lead me to create this library.

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

But the approach is different from libraries such as Immutable. Instead of wrapping native types inside objects with extra methods, yambda can take (depending on the function) any types. 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 functions accept any types, 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 exposes functions. The goal is to compose or manipulate those functions in order to create new ones. yambda's functions's arguments have a specific order: the function's subject or taget 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.

Curring and arity

All functions of yambda are curried by default. Each function in the curry chain does not has not a fixed arity (may change in the futur). For mor information, see this example on the curry function.

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