Maybe.js

var toString = require('ramda/src/toString');
var curry = require('ramda/src/curry');

var util = require('./internal/util.js');

function Maybe(x) {
  return x == null ? _nothing : Maybe.Just(x);
}

Maybe.prototype['@@type'] = 'ramda-fantasy/Maybe';

function Just(x) {
  this.value = x;
}
util.extend(Just, Maybe);

Just.prototype.isJust = true;
Just.prototype.isNothing = false;

function Nothing() {}
util.extend(Nothing, Maybe);

Nothing.prototype.isNothing = true;
Nothing.prototype.isJust = false;

var _nothing = new Nothing();

Maybe.Nothing = function() {
  return _nothing;
};

Maybe.Just = function(x) {
  return new Just(x);
};

Maybe.of = Maybe.Just;

Maybe.prototype.of = Maybe.Just;

Maybe.isJust = function(x) {
  return x.isJust;
};

Maybe.isNothing = function(x) {
  return x.isNothing;
};

Maybe.maybe = curry(function(nothingVal, justFn, m) {
  return m.reduce(function(_, x) {
    return justFn(x);
  }, nothingVal);
});

Maybe.toMaybe = Maybe;

// semigroup
Just.prototype.concat = function(that) {
  return that.isNothing ? this : this.of(
    this.value.concat(that.value)
  );
};

Nothing.prototype.concat = util.identity;

// functor
Just.prototype.map = function(f) {
  return this.of(f(this.value));
};

Nothing.prototype.map = util.returnThis;

// apply
// takes a Maybe that wraps a function (`app`) and applies its `map`
// method to this Maybe's value, which must be a function.
Just.prototype.ap = function(m) {
  return m.map(this.value);
};

Nothing.prototype.ap = util.returnThis;

// applicative
// `of` inherited from `Maybe`


// chain
//  f must be a function which returns a value
//  f must return a value of the same Chain
//  chain must return a value of the same Chain
Just.prototype.chain = util.baseMap;

Nothing.prototype.chain = util.returnThis;


//chainRec
Maybe.chainRec = Maybe.prototype.chainRec = function(f, i) {
  var res, state = util.chainRecNext(i);
  while (state.isNext) {
    res = f(util.chainRecNext, util.chainRecDone, state.value);
    if (Maybe.isNothing(res)) {
      return res;
    }
    state = res.value;
  }
  return Maybe.Just(state.value);
};


//
Just.prototype.datatype = Just;

Nothing.prototype.datatype = Nothing;

// monad
// A value that implements the Monad specification must also implement the Applicative and Chain specifications.
// see above.

// equality method to enable testing
Just.prototype.equals = util.getEquals(Just);

Nothing.prototype.equals = function(that) {
  return that === _nothing;
};

Maybe.prototype.isNothing = function() {
  return this === _nothing;
};

Maybe.prototype.isJust = function() {
  return this instanceof Just;
};

Just.prototype.getOrElse = function() {
  return this.value;
};

Nothing.prototype.getOrElse = function(a) {
  return a;
};

Just.prototype.reduce = function(f, x) {
  return f(x, this.value);
};

Nothing.prototype.reduce = function(f, x) {
  return x;
};

Just.prototype.toString = function() {
  return 'Maybe.Just(' + toString(this.value) + ')';
};

Nothing.prototype.toString = function() {
  return 'Maybe.Nothing()';
};

module.exports = Maybe;