monadical



_A small set of monadic data types to get you going functionally, with some optional extras_

Monadical provides data-types and functions such as Either or curry, allowing you to compose operations originating from different context such as generators or monads, with safety in mind.

Installation

To install the latest stable version, run either of the following via a terminal:

_using npm_
``shell script
npm install monadical
`

_using yarn_
`shell script
yarn add monadical
`


Usage & Compatibility

Using ES6, you can use the following import syntax:
`js
import Either, { Left, Right } from 'monadical/either';
`

So, to import the Maybe data-type with composing functions, you would write the following using ES6:
`js
import Maybe from 'monadical/maybe';
import compose from 'monadical/compose';
import chainC from 'monadical/chainC';
import isNumber from 'monadical/isNumber';

const add10 = amount => Maybe.nullable(isNumber(amount) ? amount + 10 : void 0);
const safelyAdd10 = compose(chainC(x => My amount is now: ${x}), add10);

console.assert(safelyAdd10(20) === 'My amount is now: 30')
console.assert(safelyAdd10(null) === void 0)
`

Supported Types

- get: (): T
- map: (f: (x: T) => U): Container
- join: (): Container
- _static_ of: (value: U): Container

#### Maybe

Operations:

- isNothing: (): boolean
- isJust: (): boolean
- _static_ just: (val: J): Just
- _static_ nothing: (_: N): Nothing
- _static_ of: (val: J): Just
- _static_ nullable: (val: J): Maybe

#### Just

Operations:

- isNothing: (): boolean
- isJust: (): boolean
- get value: (): J
- map: (func: (a: J) => J): Just
- chain: (func: (a: J) => T): T
- getOrElse: (_: any): J
- filter: (func: (a: J) => boolean): Maybe

#### Nothing

Operations:

- isNothing: (): boolean
- isJust: (): boolean
- map: (_: any): Nothing
- chain: (_: any): N
- getOrElse: (defaultVal: T): T
- filter: (_: any): Nothing

#### Either

Operations:

- get value: (): T
- _static_ left: (val: L): Left
- _static_ right: (val: R): Right
- _static_ of: (val: R): Right
- _static_ nullable: (value: T): Either

#### Left

Operations:

- isRight: (): boolean
- isLeft: (): boolean
- map: (func: (val: L) => T): Either
- getOrElse: (defaultVal: any): any
- orElse: (func: (val: L) => any): any
- chain: (func: (a: R) => T): Left
- getOrElseThrow: (func: (val: L) => Error): R | Error
- filter: (func: (val: R) => boolean): this

#### Right

Operations:

- get value: (): R
- isRight: (): boolean
- isLeft: (): boolean
- map: (func: (val: R) => T): Either
- getOrElse: (defaultVal: T): R
- orElse: (func: (val: R) => any): this
- chain: (func: (a: R) => T): T
- getOrElseThrow: (func: (val: L | R) => Error): R | Error
- filter: (func: (val: R) => boolean): Either

#### IO:

Operations:

- map: (func: Func1): IO>
- chain: (func: Func1Optional): any
- run: (): any
- _static_ of: (val: U): IO
- _static_ from: (func: Func1Optional): IO
- _static_ lift: (val: U): IO

#### Empty

Operations:

- map: (_: any): void
- fmap: (_: any): Empty

Monadic operations during programmable commas