crocks/IO/index.js

A collection of well known Algebraic Datatypes for your utter enjoyment.

/** @license ISC License (c) copyright 2016 original and current authors */
/** @author Ian Hofmann-Hicks (evil) */

var VERSION = 2

var _implements = require('../core/implements')
var _inspect = require('../core/inspect')
var type = require('../core/types').type('IO')
var _type = require('../core/types').typeFn(type(), VERSION)
var fl = require('../core/flNames')

var compose = require('../core/compose')
var isFunction = require('../core/isFunction')
var isSameType = require('../core/isSameType')

var _of =
  function (x) { return IO(function () { return x; }); }

function IO(run) {
  var obj;

  if(!isFunction(run)) {
    throw new TypeError('IO: Must wrap a function')
  }

  var of =
    _of

  var inspect =
    function () { return ("IO" + (_inspect(run))); }

  function map(method) {
    return function(fn) {
      if(!isFunction(fn)) {
        throw new TypeError(("IO." + method + ": Function required"))
      }

      return IO(compose(fn, run))
    }
  }

  function ap(m) {
    if(!isSameType(IO, m)) {
      throw new TypeError('IO.ap: IO required')
    }
    return IO(function () {
      var fn = run()
      if(!isFunction(fn)) {
        throw new TypeError('IO.ap: Wrapped value must be a function')
      }

      return m.map(fn).run()
    })

  }

  function chain(method) {
    return function(fn) {
      if(!isFunction(fn)) {
        throw new TypeError(("IO." + method + ": Function required"))
      }

      return IO(function() {
        var m = fn(run())

        if(!isSameType(IO, m)) {
          throw new TypeError(("IO." + method + ": Function must return an IO"))
        }

        return m.run()
      })
    }
  }

  return ( obj = {
    inspect: inspect, toString: inspect,
    run: run, type: type, ap: ap, of: of,
    map: map('map'),
    chain: chain('chain')
  }, obj[fl.of] = of, obj[fl.map] = map(fl.map), obj[fl.chain] = chain(fl.chain), obj['@@type'] = _type, obj.constructor = IO, obj )
}

IO.of = _of
IO.type = type

IO[fl.of] = _of
IO['@@type'] = _type

IO['@@implements'] = _implements(
  [ 'ap', 'chain', 'map', 'of' ]
)

module.exports = IO