# monadanator

> When you want to make things pure and functional.

Latest version **2.0.0** (published 2016-07-25) · MIT license · 0 weekly downloads

## Install

```sh
npm install monadanator
pnpm add monadanator
yarn add monadanator
bun add monadanator
```

## Health

**Score 15/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 2.0.0 |
| Published | 2016-07-25 |
| First published | 2016-06-27 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | none |
| Module format | CommonJS |
| Dependencies | 2 |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Maintainers | gwash3189 |

## Links

- npm: https://www.npmjs.com/package/monadanator
- npm.io page: https://npm.io/package/monadanator

## Dependencies (2)

- [es6-promise](https://npm.io/package/es6-promise.md) ^3.2.1
- [isomorphic-fetch](https://npm.io/package/isomorphic-fetch.md) ^2.2.1

## Recent versions

- 2.0.0 (latest) — 2016-07-25
- 1.0.3 — 2016-07-09
- 1.0.2 — 2016-07-09
- 1.0.1 — 2016-07-08
- 1.0.0 — 2016-06-27

## README

# Monadanator

When you want to make things pure and functional.

# Usage

## Container

Basic container that both a functor and a monad. It responds to `map` and `flatMap`. In addition, it also responds to `of` and `ap`.

`of` describes a *pointed* monad where as `ap` describes an *applicative* monad.

### examples

```javascript
import { container } from 'monadanator'

container(3)
  .map(three => three * 2)
  .flatMap(six => container.of(2)
    .map(two => two * six)
  )
  .map(twelve => console.log(twelve))
```

```javascript

container
  .of(x => console.log(x))
  .ap('something that will get logged')
  .ap(container.of('another thing that will be logged'))
```


## IO
provides a function that acts just like container, but implements the expected IO Monad behaviour.

The only difference between an IO monad and a Container monad is that an IO monad waits to execute any calls to `map`, `flatMap` or `ap`. These calls will only be run when `perform` is called.

### examples

```javascript
import { io } from 'monadanator'

const helloWorld = io.of(window)
  .map(w => window.alert('hello world')) // no alert

helloWorld.perform() // alert's hello world
```

alternatively, you could use the `run` helper function

```javascript
import { io, helpers: { run } } from 'monadanator'

const helloWorld = io.of(window)
  .map(w => window.alert('hello world'));

const append = io.of(document)
  .map(doc => document.body.appendChild('hello!'))

run(
  helloWorld,
  append
) //alerts hello world & appends child

```

## Maybe

Maybe represents a point in your program where things could go wrong. It works exactly like a container, except when it receives a value of `undefined` or `null`. At which point, `map`, `flatMap` and `ap` will stop running.

There is also `error` method that will only run if the value contained within the Maybe monad is either `undefined` or `null`

### examples
``` javascript
import { maybe } from 'monadanator'
  maybe.of(true)
    .map(x => !x)
    .map(x => undefined) // everything past this point will never run
    .flatMap(x => maybe.of(3).map(x => * 2))
    .map(six => console.log(six))
    .error(_ => console.log('something went wrong')) // runs because the monad contains undefined

```

---
_Source: https://npm.io/package/monadanator · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._