rsite-funjs/src/Maybe.js

functional javascript

"use strict";

const T_Maybe=class Maybe {
  pure(o) {return Just(o)}
};

const Maybe=new T_Maybe()

const isMaybe=o=>T_Maybe.prototype.isPrototypeOf(o);

const TC_Nothing=class Nothing extends T_Maybe {
  constructor() {return super();}
  map(_) {return this}
  append(mo) {return mo}
  when(_) {return this}//applicative instance this <* o | this << o
  then(_) {return this}//applicative instance this *> o | this >> o
  or(o) {return o}
  app(o) {return this}// (<*>) :: f (a -> b) -> f a -> f b
  //mbind::m a->(a->m b)-> m b
  mbind(_){return this}//monad instance
  mplus(o) {return o}//monadplus instance
};

const Nothing=()=>new TC_Nothing();
const isNothing=o=>TC_Nothing.prototype.isPrototypeOf(o);

const TC_Just=class Just extends T_Maybe {
  constructor(o) {
    super()
    this.value=o
  }
  map(f) {return new Just(f(this.value))}
  append(mo) {return isJust(mo)?this.pure(this.value.append(fromJust(mo))):this.empty()}
  or(_) {return this}
  when(o) {return isNothing(o)?o:this}//applicative instance this <* o | this << o
  then(o) {return o.when(this)}//applicative instance this *> o | this >> o
  app(o) {return o.map(this.value)}// (<*>) :: f (a -> b) -> f a -> f b
  //mbind::m a->(a->m b)-> m b
  mbind(f){return f(this.value)}//monad instance
  mplus(_) {return this}//monadplus instance
};

const Just=o=>new TC_Just(o);
const isJust=o=>TC_Just.prototype.isPrototypeOf(o);

const fromJust=o=>{
  if(isJust(o)) return o.value;
  throw("`fromJust` of not `Maybe`");
}

Maybe.__proto__.empty=Nothing()
Maybe.__proto__.pure=o=>Just(o)

exports.Maybe=Maybe
exports.isMaybe=isMaybe;
exports.Nothing=Nothing;
exports.isNothing=isNothing;
exports.Just=Just;
exports.isJust=isJust;
exports.fromJust=fromJust;

// exports.bind=o=>o.bind;
// exports.pure=o=>o.pure;


// export {isMaybe,Nothing,isNothing,Just,isJust,fromJust};