Minimal maybe example

maybe-private.js

/**
 * Example with no .value in instances. Its can be much slower,
 * but if you prefer pureness, that is your choice
 */


export const just = data => new Just( data )
export const of = just
export const nothing = () => new Nothing

const allocation = new WeakMap

class Just {
  constructor(value) { allocation.set(this, value) }

  map(fn) {
    return new Just(fn( allocation.get(this) ))
  }
  
  chain( fn ) {
    return fn( allocation.get(this) )
  }
  filter( cond ) {
    const value = allocation.get(this)
    return cond( value )
      ? new Just( value )
      : new Nothing
  }
  fold( fnN, fnJ ) {
    return fnJ( allocation.get(this) )
  }
}

class Nothing {
  map(fn) {
    return this
  }
  
  chain( fn ) {
    return this
  }
  filter( cond ) {
    return this
  }
  fold( fnN, fnJ ) {
    return fnN()
  }
}

maybe.js

export const just = data => new Just( data )
export const of = just
export const nothing = () => new Nothing

// Optimisation: you can create and use same Nothing value
// and became even faster

class Just {
  constructor(value) { this.value = value }

  map(fn) {
    return new Just(fn( this.value ))
  }
  
  chain( fn ) {
    return fn( this.value )
  }
  filter( cond ) {
    return cond( this.value )
      ? new Just( this.value )
      : new Nothing
  }
  fold( fnN, fnJ ) {
    return fnJ( this.value )
  }
}

class Nothing {
  map(fn) {
    return this
  }
  
  chain( fn ) {
    return this
  }
  filter( cond ) {
    return this
  }
  fold( fnN, fnJ ) {
    return fnN()
  }
}