requirebin sketch

index.js

// require() some stuff from npm (like you were using browserify)
// and then hit Run Code to run it on the right
const daggy = require('daggy')
const {Just, Nothing} = require('data.maybe')

const RemoteData = daggy.taggedSum({
  NotAsked: [],
  Loading: [],
  Failure: ['error'],
  Success: ['items'],
})
/*
RemoteData.Success('hi').cata({
  Success: console.log,
  NotAsked: () => console.log('not asked')
})
*/

const data = Just(10)
console.log(data === data.map(x => x + 1))
console.log(data.getOrElse(null))

minified.js

setTimeout(function(){
;require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
// Copyright (c) 2013-2014 Quildreen Motta <quildreen@gmail.com>
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation files
// (the "Software"), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

/**
 * @module lib/maybe
 */
module.exports = Maybe

// -- Aliases ----------------------------------------------------------
var clone         = Object.create
var unimplemented = function(){ throw new Error('Not implemented.') }
var noop          = function(){ return this                         }

// -- Implementation ---------------------------------------------------

/**
 * A structure for values that may not be present, or computations that may
 * fail. `Maybe(a)` explicitly models the effects that are implicit in
 * `Nullable` types, thus has none of the problems associated with
 * `null` or `undefined` — like `NullPointerExceptions`.
 *
 * The class models two different cases:
 *
 *  + `Just a` — represents a `Maybe(a)` that contains a value. `a` may
 *     be any value, including `null` or `undefined`.
 *
 *  + `Nothing` — represents a `Maybe(a)` that has no values. Or a
 *     failure that needs no additional information.
 *
 * Common uses of this structure includes modelling values that may or may
 * not be present in a collection, thus instead of needing a
 * `collection.has(a)`, the `collection.get(a)` operation gives you all
 * the information you need — `collection.get(a).is-nothing` being
 * equivalent to `collection.has(a)`; Similarly the same reasoning may
 * be applied to computations that may fail to provide a value, e.g.:
 * `collection.find(predicate)` can safely return a `Maybe(a)` instance,
 * even if the collection contains nullable values.
 *
 * Furthermore, the values of `Maybe(a)` can be combined and manipulated
 * by using the expressive monadic operations. This allows safely
 * sequencing operations that may fail, and safely composing values that
 * you don't know whether they're present or not, failing early
 * (returning a `Nothing`) if any of the operations fail.
 *
 * If one wants to store additional information about failures, the
 * [Either][] and [Validation][] structures provide such a capability, and
 * should be used instead of the `Maybe(a)` structure.
 *
 * [Either]: https://github.com/folktale/data.either
 * [Validation]: https://github.com/folktale/data.validation
 *
 *
 * @class
 */
function Maybe() {}

// The case for successful values
Just.prototype = clone(Maybe.prototype)
function Just(a){
  this.value = a
}

// The case for failure values
Nothing.prototype = clone(Maybe.prototype)
function Nothing(){}


// -- Constructors -----------------------------------------------------

/**
 * Constructs a new `Maybe[α]` structure with an absent value. Commonly used
 * to represent a failure.
 *
 * @summary Void → Maybe[α]
 */
Maybe.Nothing = function() {
  return new Nothing
}
Maybe.prototype.Nothing = Maybe.Nothing

/**
 * Constructs a new `Maybe[α]` structure that holds the single value
 * `α`. Commonly used to represent a success.
 *
 * `α` can be any value, including `null`, `undefined` or another
 * `Maybe[α]` structure.
 *
 * @summary α → Maybe[α]
 */
Maybe.Just = function(a) {
  return new Just(a)
}
Maybe.prototype.Just = Maybe.Just


// -- Conversions ------------------------------------------------------

/**
 * Constructs a new `Maybe[α]` structure from a nullable type.
 *
 * If the value is either `null` or `undefined`, this function returns a
 * `Nothing`, otherwise the value is wrapped in a `Just(α)`.
 *
 * @summary α → Maybe[α]
 */
Maybe.fromNullable = function(a) {
  return a != null?       new Just(a)
  :      /* otherwise */  new Nothing
}
Maybe.prototype.fromNullable = Maybe.fromNullable

/**
 * Constructs a new `Maybe[β]` structure from an `Either[α, β]` type.
 *
 * The left side of the `Either` becomes `Nothing`, and the right side
 * is wrapped in a `Just(β)`.
 *
 * @summary Either[α, β] → Maybe[β]
 */
Maybe.fromEither = function(a) {
  return a.fold(Maybe.Nothing, Maybe.Just)
}
Maybe.prototype.fromEither = Maybe.fromEither

/**
 * Constructs a new `Maybe[β]` structure from a `Validation[α, β]` type.
 *
 * The failure side of the `Validation` becomes `Nothing`, and the right
 * side is wrapped in a `Just(β)`.
 *
 * @method
 * @summary Validation[α, β] → Maybe[β]
 */
Maybe.fromValidation           = Maybe.fromEither
Maybe.prototype.fromValidation = Maybe.fromEither


// -- Predicates -------------------------------------------------------

/**
 * True if the `Maybe[α]` structure contains a failure (i.e.: `Nothing`).
 *
 * @summary Boolean
 */
Maybe.prototype.isNothing   = false
Nothing.prototype.isNothing = true


/**
 * True if the `Maybe[α]` structure contains a single value (i.e.: `Just(α)`).
 *
 * @summary Boolean
 */
Maybe.prototype.isJust = false
Just.prototype.isJust  = true


// -- Applicative ------------------------------------------------------

/**
 * Creates a new `Maybe[α]` structure holding the single value `α`.
 *
 * `α` can be any value, including `null`, `undefined`, or another
 * `Maybe[α]` structure.
 *
 * @summary α → Maybe[α]
 */
Maybe.of = function(a) {
  return new Just(a)
}
Maybe.prototype.of = Maybe.of


/**
 * Applies the function inside the `Maybe[α]` structure to another
 * applicative type.
 *
 * The `Maybe[α]` structure should contain a function value, otherwise a
 * `TypeError` is thrown.
 *
 * @method
 * @summary (@Maybe[α → β], f:Applicative[_]) => f[α] → f[β]
 */
Maybe.prototype.ap = unimplemented

Nothing.prototype.ap = noop

Just.prototype.ap = function(b) {
  return b.map(this.value)
}




// -- Functor ----------------------------------------------------------

/**
 * Transforms the value of the `Maybe[α]` structure using a regular unary
 * function.
 *
 * @method
 * @summary @Maybe[α] => (α → β) → Maybe[β]
 */
Maybe.prototype.map   = unimplemented
Nothing.prototype.map = noop

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


// -- Chain ------------------------------------------------------------

/**
 * Transforms the value of the `Maybe[α]` structure using an unary function
 * to monads.
 *
 * @method
 * @summary (@Maybe[α], m:Monad[_]) => (α → m[β]) → m[β]
 */
Maybe.prototype.chain   = unimplemented
Nothing.prototype.chain = noop

Just.prototype.chain = function(f) {
  return f(this.value)
}


// -- Show -------------------------------------------------------------

/**
 * Returns a textual representation of the `Maybe[α]` structure.
 *
 * @method
 * @summary @Maybe[α] => Void → String
 */
Maybe.prototype.toString = unimplemented

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

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


// -- Eq ---------------------------------------------------------------

/**
 * Tests if a `Maybe[α]` structure is equal to another `Maybe[α]` structure.
 *
 * @method
 * @summary @Maybe[α] => Maybe[α] → Boolean
 */
Maybe.prototype.isEqual = unimplemented

Nothing.prototype.isEqual = function(b) {
  return b.isNothing
}

Just.prototype.isEqual = function(b) {
  return b.isJust
  &&     b.value === this.value
}


// -- Extracting and recovering ----------------------------------------

/**
 * Extracts the value out of the `Maybe[α]` structure, if it
 * exists. Otherwise throws a `TypeError`.
 *
 * @method
 * @summary @Maybe[α] => Void → a,      :: partial, throws
 * @see {@link module:lib/maybe~Maybe#getOrElse} — A getter that can handle failures
 * @throws {TypeError} if the structure has no value (`Nothing`).
 */
Maybe.prototype.get = unimplemented

Nothing.prototype.get = function() {
  throw new TypeError("Can't extract the value of a Nothing.")
}

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


/**
 * Extracts the value out of the `Maybe[α]` structure. If there is no value,
 * returns the given default.
 *
 * @method
 * @summary @Maybe[α] => α → α
 */
Maybe.prototype.getOrElse = unimplemented

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

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


/**
 * Transforms a failure into a new `Maybe[α]` structure. Does nothing if the
 * structure already contains a value.
 *
 * @method
 * @summary @Maybe[α] => (Void → Maybe[α]) → Maybe[α]
 */
Maybe.prototype.orElse = unimplemented

Nothing.prototype.orElse = function(f) {
  return f()
}

Just.prototype.orElse = function(_) {
  return this
}


/**
 * Catamorphism.
 * 
 * @method
 * @summary @Maybe[α] => { Nothing: Void → β, Just: α → β } → β
 */
Maybe.prototype.cata = unimplemented

Nothing.prototype.cata = function(pattern) {
  return pattern.Nothing()
}

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


/**
 * JSON serialisation
 *
 * @method
 * @summary @Maybe[α] => Void → Object
 */
Maybe.prototype.toJSON = unimplemented

Nothing.prototype.toJSON = function() {
  return { '#type': 'folktale:Maybe.Nothing' }
}

Just.prototype.toJSON = function() {
  return { '#type': 'folktale:Maybe.Just'
         , value: this.value }
}

},{}],"data.maybe":[function(require,module,exports){
// Copyright (c) 2013-2014 Quildreen Motta <quildreen@gmail.com>
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation files
// (the "Software"), to deal in the Software without restriction,
// including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software,
// and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

module.exports = require('./maybe')
},{"./maybe":1}]},{},[])
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","lib/maybe.js","lib/index.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxXA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","// Copyright (c) 2013-2014 Quildreen Motta <quildreen@gmail.com>\n//\n// Permission is hereby granted, free of charge, to any person\n// obtaining a copy of this software and associated documentation files\n// (the \"Software\"), to deal in the Software without restriction,\n// including without limitation the rights to use, copy, modify, merge,\n// publish, distribute, sublicense, and/or sell copies of the Software,\n// and to permit persons to whom the Software is furnished to do so,\n// subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be\n// included in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\n// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\n// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n/**\n * @module lib/maybe\n */\nmodule.exports = Maybe\n\n// -- Aliases ----------------------------------------------------------\nvar clone         = Object.create\nvar unimplemented = function(){ throw new Error('Not implemented.') }\nvar noop          = function(){ return this                         }\n\n// -- Implementation ---------------------------------------------------\n\n/**\n * A structure for values that may not be present, or computations that may\n * fail. `Maybe(a)` explicitly models the effects that are implicit in\n * `Nullable` types, thus has none of the problems associated with\n * `null` or `undefined` — like `NullPointerExceptions`.\n *\n * The class models two different cases:\n *\n *  + `Just a` — represents a `Maybe(a)` that contains a value. `a` may\n *     be any value, including `null` or `undefined`.\n *\n *  + `Nothing` — represents a `Maybe(a)` that has no values. Or a\n *     failure that needs no additional information.\n *\n * Common uses of this structure includes modelling values that may or may\n * not be present in a collection, thus instead of needing a\n * `collection.has(a)`, the `collection.get(a)` operation gives you all\n * the information you need — `collection.get(a).is-nothing` being\n * equivalent to `collection.has(a)`; Similarly the same reasoning may\n * be applied to computations that may fail to provide a value, e.g.:\n * `collection.find(predicate)` can safely return a `Maybe(a)` instance,\n * even if the collection contains nullable values.\n *\n * Furthermore, the values of `Maybe(a)` can be combined and manipulated\n * by using the expressive monadic operations. This allows safely\n * sequencing operations that may fail, and safely composing values that\n * you don't know whether they're present or not, failing early\n * (returning a `Nothing`) if any of the operations fail.\n *\n * If one wants to store additional information about failures, the\n * [Either][] and [Validation][] structures provide such a capability, and\n * should be used instead of the `Maybe(a)` structure.\n *\n * [Either]: https://github.com/folktale/data.either\n * [Validation]: https://github.com/folktale/data.validation\n *\n *\n * @class\n */\nfunction Maybe() {}\n\n// The case for successful values\nJust.prototype = clone(Maybe.prototype)\nfunction Just(a){\n  this.value = a\n}\n\n// The case for failure values\nNothing.prototype = clone(Maybe.prototype)\nfunction Nothing(){}\n\n\n// -- Constructors -----------------------------------------------------\n\n/**\n * Constructs a new `Maybe[α]` structure with an absent value. Commonly used\n * to represent a failure.\n *\n * @summary Void → Maybe[α]\n */\nMaybe.Nothing = function() {\n  return new Nothing\n}\nMaybe.prototype.Nothing = Maybe.Nothing\n\n/**\n * Constructs a new `Maybe[α]` structure that holds the single value\n * `α`. Commonly used to represent a success.\n *\n * `α` can be any value, including `null`, `undefined` or another\n * `Maybe[α]` structure.\n *\n * @summary α → Maybe[α]\n */\nMaybe.Just = function(a) {\n  return new Just(a)\n}\nMaybe.prototype.Just = Maybe.Just\n\n\n// -- Conversions ------------------------------------------------------\n\n/**\n * Constructs a new `Maybe[α]` structure from a nullable type.\n *\n * If the value is either `null` or `undefined`, this function returns a\n * `Nothing`, otherwise the value is wrapped in a `Just(α)`.\n *\n * @summary α → Maybe[α]\n */\nMaybe.fromNullable = function(a) {\n  return a != null?       new Just(a)\n  :      /* otherwise */  new Nothing\n}\nMaybe.prototype.fromNullable = Maybe.fromNullable\n\n/**\n * Constructs a new `Maybe[β]` structure from an `Either[α, β]` type.\n *\n * The left side of the `Either` becomes `Nothing`, and the right side\n * is wrapped in a `Just(β)`.\n *\n * @summary Either[α, β] → Maybe[β]\n */\nMaybe.fromEither = function(a) {\n  return a.fold(Maybe.Nothing, Maybe.Just)\n}\nMaybe.prototype.fromEither = Maybe.fromEither\n\n/**\n * Constructs a new `Maybe[β]` structure from a `Validation[α, β]` type.\n *\n * The failure side of the `Validation` becomes `Nothing`, and the right\n * side is wrapped in a `Just(β)`.\n *\n * @method\n * @summary Validation[α, β] → Maybe[β]\n */\nMaybe.fromValidation           = Maybe.fromEither\nMaybe.prototype.fromValidation = Maybe.fromEither\n\n\n// -- Predicates -------------------------------------------------------\n\n/**\n * True if the `Maybe[α]` structure contains a failure (i.e.: `Nothing`).\n *\n * @summary Boolean\n */\nMaybe.prototype.isNothing   = false\nNothing.prototype.isNothing = true\n\n\n/**\n * True if the `Maybe[α]` structure contains a single value (i.e.: `Just(α)`).\n *\n * @summary Boolean\n */\nMaybe.prototype.isJust = false\nJust.prototype.isJust  = true\n\n\n// -- Applicative ------------------------------------------------------\n\n/**\n * Creates a new `Maybe[α]` structure holding the single value `α`.\n *\n * `α` can be any value, including `null`, `undefined`, or another\n * `Maybe[α]` structure.\n *\n * @summary α → Maybe[α]\n */\nMaybe.of = function(a) {\n  return new Just(a)\n}\nMaybe.prototype.of = Maybe.of\n\n\n/**\n * Applies the function inside the `Maybe[α]` structure to another\n * applicative type.\n *\n * The `Maybe[α]` structure should contain a function value, otherwise a\n * `TypeError` is thrown.\n *\n * @method\n * @summary (@Maybe[α → β], f:Applicative[_]) => f[α] → f[β]\n */\nMaybe.prototype.ap = unimplemented\n\nNothing.prototype.ap = noop\n\nJust.prototype.ap = function(b) {\n  return b.map(this.value)\n}\n\n\n\n\n// -- Functor ----------------------------------------------------------\n\n/**\n * Transforms the value of the `Maybe[α]` structure using a regular unary\n * function.\n *\n * @method\n * @summary @Maybe[α] => (α → β) → Maybe[β]\n */\nMaybe.prototype.map   = unimplemented\nNothing.prototype.map = noop\n\nJust.prototype.map = function(f) {\n  return this.of(f(this.value))\n}\n\n\n// -- Chain ------------------------------------------------------------\n\n/**\n * Transforms the value of the `Maybe[α]` structure using an unary function\n * to monads.\n *\n * @method\n * @summary (@Maybe[α], m:Monad[_]) => (α → m[β]) → m[β]\n */\nMaybe.prototype.chain   = unimplemented\nNothing.prototype.chain = noop\n\nJust.prototype.chain = function(f) {\n  return f(this.value)\n}\n\n\n// -- Show -------------------------------------------------------------\n\n/**\n * Returns a textual representation of the `Maybe[α]` structure.\n *\n * @method\n * @summary @Maybe[α] => Void → String\n */\nMaybe.prototype.toString = unimplemented\n\nNothing.prototype.toString = function() {\n  return 'Maybe.Nothing'\n}\n\nJust.prototype.toString = function() {\n  return 'Maybe.Just(' + this.value + ')'\n}\n\n\n// -- Eq ---------------------------------------------------------------\n\n/**\n * Tests if a `Maybe[α]` structure is equal to another `Maybe[α]` structure.\n *\n * @method\n * @summary @Maybe[α] => Maybe[α] → Boolean\n */\nMaybe.prototype.isEqual = unimplemented\n\nNothing.prototype.isEqual = function(b) {\n  return b.isNothing\n}\n\nJust.prototype.isEqual = function(b) {\n  return b.isJust\n  &&     b.value === this.value\n}\n\n\n// -- Extracting and recovering ----------------------------------------\n\n/**\n * Extracts the value out of the `Maybe[α]` structure, if it\n * exists. Otherwise throws a `TypeError`.\n *\n * @method\n * @summary @Maybe[α] => Void → a,      :: partial, throws\n * @see {@link module:lib/maybe~Maybe#getOrElse} — A getter that can handle failures\n * @throws {TypeError} if the structure has no value (`Nothing`).\n */\nMaybe.prototype.get = unimplemented\n\nNothing.prototype.get = function() {\n  throw new TypeError(\"Can't extract the value of a Nothing.\")\n}\n\nJust.prototype.get = function() {\n  return this.value\n}\n\n\n/**\n * Extracts the value out of the `Maybe[α]` structure. If there is no value,\n * returns the given default.\n *\n * @method\n * @summary @Maybe[α] => α → α\n */\nMaybe.prototype.getOrElse = unimplemented\n\nNothing.prototype.getOrElse = function(a) {\n  return a\n}\n\nJust.prototype.getOrElse = function(_) {\n  return this.value\n}\n\n\n/**\n * Transforms a failure into a new `Maybe[α]` structure. Does nothing if the\n * structure already contains a value.\n *\n * @method\n * @summary @Maybe[α] => (Void → Maybe[α]) → Maybe[α]\n */\nMaybe.prototype.orElse = unimplemented\n\nNothing.prototype.orElse = function(f) {\n  return f()\n}\n\nJust.prototype.orElse = function(_) {\n  return this\n}\n\n\n/**\n * Catamorphism.\n * \n * @method\n * @summary @Maybe[α] => { Nothing: Void → β, Just: α → β } → β\n */\nMaybe.prototype.cata = unimplemented\n\nNothing.prototype.cata = function(pattern) {\n  return pattern.Nothing()\n}\n\nJust.prototype.cata = function(pattern) {\n  return pattern.Just(this.value);\n}\n\n\n/**\n * JSON serialisation\n *\n * @method\n * @summary @Maybe[α] => Void → Object\n */\nMaybe.prototype.toJSON = unimplemented\n\nNothing.prototype.toJSON = function() {\n  return { '#type': 'folktale:Maybe.Nothing' }\n}\n\nJust.prototype.toJSON = function() {\n  return { '#type': 'folktale:Maybe.Just'\n         , value: this.value }\n}\n","// Copyright (c) 2013-2014 Quildreen Motta <quildreen@gmail.com>\n//\n// Permission is hereby granted, free of charge, to any person\n// obtaining a copy of this software and associated documentation files\n// (the \"Software\"), to deal in the Software without restriction,\n// including without limitation the rights to use, copy, modify, merge,\n// publish, distribute, sublicense, and/or sell copies of the Software,\n// and to permit persons to whom the Software is furnished to do so,\n// subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be\n// included in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\n// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\n// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = require('./maybe')"]}
require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({"daggy":[function(require,module,exports){
/**
  # Daggy

  Library for creating tagged constructors.
**/
(function(global, factory) {
    'use strict';

    if(typeof define === 'function' && define.amd) {
        define(['exports'], factory);
    } else if(typeof exports !== 'undefined') {
        factory(exports);
    } else {
        global.daggy = {};
        factory(global.daggy);
    }
})(this, function(exports) {
    function create(proto) {
        function Ctor() {}
        Ctor.prototype = proto;
        return new Ctor();
    }
    exports.create = create;

    /**
      ## `daggy.getInstance(self, constructor)`

      Returns `self` if it's an `instanceof constructor`, otherwise
      creates a new object with `constructor`'s prototype.

      Allows creating constructors that can be used with or without
      the new keyword but always have the correct prototype.

      ```javascript
      function WrappedArray() {
          var self = daggy.getInstance(this, WrappedArray);
          self._array = [].slice.apply(arguments);
          return self;
      }
      new WrappedArray(1, 2, 3) instanceof WrappedArray; // true
      WrappedArray(1, 2, 3) instanceof WrappedArray; // true
      ```
    **/
    function getInstance(self, constructor) {
        return self instanceof constructor ? self : create(constructor.prototype);
    }
    exports.getInstance = getInstance;

    /**
      ## `daggy.tagged(arguments)`

      Creates a new constructor with the given field names as
      arguments and properties. Allows `instanceof` checks with
      returned constructor.

      ```javascript
      var Tuple3 = daggy.tagged('x', 'y', 'z');

      var _123 = Tuple3(1, 2, 3); // optional new keyword
      _123.x == 1 && _123.y == 2 && _123.z == 3; // true
      _123 instanceof Tuple3; // true
      ```
    **/
    function tagged() {
        var fields = [].slice.apply(arguments);
        function wrapped() {
            var self = getInstance(this, wrapped),
                i;

            if(arguments.length != fields.length)
                throw new TypeError('Expected ' + fields.length + ' arguments, got ' + arguments.length);

            for(i = 0; i < fields.length; i++)
                self[fields[i]] = arguments[i];

            return self;
        }
        wrapped._length = fields.length;
        return wrapped;
    }
    exports.tagged = tagged;

    /**
      ## `daggy.taggedSum(constructors)`

      Creates a constructor for each key in `constructors`. Returns a
      function with each constructor as a property. Allows
      `instanceof` checks for each constructor and the returned
      function.

      ```javascript
      var Option = daggy.taggedSum({
          Some: ['x'],
          None: []
      });

      Option.Some(1) instanceof Option.Some; // true
      Option.Some(1) instanceof Option; // true
      Option.None instanceof Option; // true

      function incOrZero(o) {
          return o.cata({
              Some: function(x) {
                  return x + 1;
              },
              None: function() {
                  return 0;
              }
          });
      }
      incOrZero(Option.Some(1)); // 2
      incOrZero(Option.None); // 0
      ```
    **/
    function taggedSum(constructors) {
        var key;

        function definitions() {
            throw new TypeError('Tagged sum was called instead of one of its properties.');
        }

        function makeCata(key) {
            return function(dispatches) {
                var fields = constructors[key],
                    args = [],
                    i;

                if(!dispatches[key])
                    throw new TypeError("Constructors given to cata didn't include: " + key);

                for(i = 0; i < fields.length; i++)
                    args.push(this[fields[i]]);

                return dispatches[key].apply(this, args);
            };
        }

        function makeProto(key) {
            var proto = create(definitions.prototype);
            proto.cata = makeCata(key);
            return proto;
        }

        for(key in constructors) {
            if(!constructors[key].length) {
                definitions[key] = makeProto(key);
                continue;
            }
            definitions[key] = tagged.apply(null, constructors[key]);
            definitions[key].prototype = makeProto(key);
        }

        return definitions;
    }
    exports.taggedSum = taggedSum;
});

},{}]},{},[])
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","daggy.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/**\n  # Daggy\n\n  Library for creating tagged constructors.\n**/\n(function(global, factory) {\n    'use strict';\n\n    if(typeof define === 'function' && define.amd) {\n        define(['exports'], factory);\n    } else if(typeof exports !== 'undefined') {\n        factory(exports);\n    } else {\n        global.daggy = {};\n        factory(global.daggy);\n    }\n})(this, function(exports) {\n    function create(proto) {\n        function Ctor() {}\n        Ctor.prototype = proto;\n        return new Ctor();\n    }\n    exports.create = create;\n\n    /**\n      ## `daggy.getInstance(self, constructor)`\n\n      Returns `self` if it's an `instanceof constructor`, otherwise\n      creates a new object with `constructor`'s prototype.\n\n      Allows creating constructors that can be used with or without\n      the new keyword but always have the correct prototype.\n\n      ```javascript\n      function WrappedArray() {\n          var self = daggy.getInstance(this, WrappedArray);\n          self._array = [].slice.apply(arguments);\n          return self;\n      }\n      new WrappedArray(1, 2, 3) instanceof WrappedArray; // true\n      WrappedArray(1, 2, 3) instanceof WrappedArray; // true\n      ```\n    **/\n    function getInstance(self, constructor) {\n        return self instanceof constructor ? self : create(constructor.prototype);\n    }\n    exports.getInstance = getInstance;\n\n    /**\n      ## `daggy.tagged(arguments)`\n\n      Creates a new constructor with the given field names as\n      arguments and properties. Allows `instanceof` checks with\n      returned constructor.\n\n      ```javascript\n      var Tuple3 = daggy.tagged('x', 'y', 'z');\n\n      var _123 = Tuple3(1, 2, 3); // optional new keyword\n      _123.x == 1 && _123.y == 2 && _123.z == 3; // true\n      _123 instanceof Tuple3; // true\n      ```\n    **/\n    function tagged() {\n        var fields = [].slice.apply(arguments);\n        function wrapped() {\n            var self = getInstance(this, wrapped),\n                i;\n\n            if(arguments.length != fields.length)\n                throw new TypeError('Expected ' + fields.length + ' arguments, got ' + arguments.length);\n\n            for(i = 0; i < fields.length; i++)\n                self[fields[i]] = arguments[i];\n\n            return self;\n        }\n        wrapped._length = fields.length;\n        return wrapped;\n    }\n    exports.tagged = tagged;\n\n    /**\n      ## `daggy.taggedSum(constructors)`\n\n      Creates a constructor for each key in `constructors`. Returns a\n      function with each constructor as a property. Allows\n      `instanceof` checks for each constructor and the returned\n      function.\n\n      ```javascript\n      var Option = daggy.taggedSum({\n          Some: ['x'],\n          None: []\n      });\n\n      Option.Some(1) instanceof Option.Some; // true\n      Option.Some(1) instanceof Option; // true\n      Option.None instanceof Option; // true\n\n      function incOrZero(o) {\n          return o.cata({\n              Some: function(x) {\n                  return x + 1;\n              },\n              None: function() {\n                  return 0;\n              }\n          });\n      }\n      incOrZero(Option.Some(1)); // 2\n      incOrZero(Option.None); // 0\n      ```\n    **/\n    function taggedSum(constructors) {\n        var key;\n\n        function definitions() {\n            throw new TypeError('Tagged sum was called instead of one of its properties.');\n        }\n\n        function makeCata(key) {\n            return function(dispatches) {\n                var fields = constructors[key],\n                    args = [],\n                    i;\n\n                if(!dispatches[key])\n                    throw new TypeError(\"Constructors given to cata didn't include: \" + key);\n\n                for(i = 0; i < fields.length; i++)\n                    args.push(this[fields[i]]);\n\n                return dispatches[key].apply(this, args);\n            };\n        }\n\n        function makeProto(key) {\n            var proto = create(definitions.prototype);\n            proto.cata = makeCata(key);\n            return proto;\n        }\n\n        for(key in constructors) {\n            if(!constructors[key].length) {\n                definitions[key] = makeProto(key);\n                continue;\n            }\n            definitions[key] = tagged.apply(null, constructors[key]);\n            definitions[key].prototype = makeProto(key);\n        }\n\n        return definitions;\n    }\n    exports.taggedSum = taggedSum;\n});\n"]}
// require() some stuff from npm (like you were using browserify)
// and then hit Run Code to run it on the right
const daggy = require('daggy')
const {Just, Nothing} = require('data.maybe')

const RemoteData = daggy.taggedSum({
  NotAsked: [],
  Loading: [],
  Failure: ['error'],
  Success: ['items'],
})
/*
RemoteData.Success('hi').cata({
  Success: console.log,
  NotAsked: () => console.log('not asked')
})
*/

const data = Just(10)
console.log(data === data.map(x => x + 1))
console.log(data.getOrElse(null))

;}, 0)

package.json

{
  "name": "requirebin-sketch",
  "version": "1.0.0",
  "dependencies": {
    "data.maybe": "1.2.2",
    "daggy": "0.0.1"
  }
}

page-body.html

<!-- contents of this file will be placed inside the <body> -->

page-head.html

<!-- contents of this file will be placed inside the <head> -->

requirebin.md

made with requirebin