* A pub/sub which is responsible for a single event type. A * multi-event type event bus is created by pubSub by collecting * several of these. *

* Like cons in Lisp

* A wrapper around the browser XmlHttpRequest object that raises an * event whenever a new part of the response is available. * * In older browsers

* pubSub is a curried interface for listening to and emitting * events. * * If we get a bus: * * var bus = pubSub(); * * We can listen to ev

* Get a new key->node mapping * * @param {String|Number} key * @param {Object|Array|String|Number|null} node a value found in the json

* Define variable argument functions but cut out all that tedious messing about * with the arguments object. Delivers the variable-length part of the

* Generic form for a function to get a property from an object * * var o = { * foo:'bar' * } * * var getFoo = attr('foo') * * fetFoo

* Creates a module mapping that includes plugin prefix, module * name, and path. If parentModuleMap is provided it will * also norma

pass me an object with only one child at each level and will return a nodeStack * and pathStack which describes the only possibly descent top-to-bot

* Helper function for iterating over an array. If the func returns * a true value, it will break out of the loop.

* Convert a list back to a js native array

* A more optimised version of compose that takes exactly two functions * @param f1 * @param f2

* Constructs an error with a pointer to an URL with more information. * @param {String} id the error ID that maps to an ID on a web page. *

* Cycles over properties in an object and calls a function for each * property value. If the function returns a truthy value, then the * ite

* XmlHttpRequest's getAllResponseHeaders() method returns a string of response * headers according to the format described here: * http://www.w3.org

* Return a list like the one given but with the first instance equal * to item removed

* Call a single function with the given arguments array. * Basically, a functional-style version of the OO-style Function#apply for * when we don't ca

* foldR implementation. Reduce a list down to a single value. * * @pram {Function} fn (rightEval, curVal) -> result

* Given a relative module name, like ./something, normalize it to * a real name that can be mapped to a path. * @param {String} name

* Returns true if the given function holds for every item in * the list, false otherwise

sinon stub is only really used to record arguments given. * However, we want to preserve the arguments given at the time of calling, because the

* Partially completes generateClauseReaderIfTokenFound above.

* Make a string version of the callback arguments given from oboe * @param {[[*]]} callbackArgs

* Create a function which is the intersection of two other functions. * * Like the && operator, if the first is truthy, the second is never called, *

* Call every function in a list of functions with the same arguments * * This doesn't make any sense if we're doing pure functional because * it do

* Converts an array to a list * * asList([a,b,c]) * * is equivalent to: * * cons(a, cons(b, cons(c, emptyList)))

* The instance API is the thing that is returned when oboe() is called. * it allows: * * - listeners for various events to be added and removed

* Map a function over a list

* Simple function to mix in properties from source into target, * but only if target does not already have a property of the same name.

* The pattern adaptor listens for newListener and removeListener * events. When patterns are added or removed it compiles the JSONPath * and wire

* Reverse the order of a list

* Internal method to transfer globalQueue items to this context's * defQueue.

* Add a callback where, if .forget() is called during the callback's * execution, the callback will be de-registered

* Add a new value to the object we are building up to represent the * parsed JSON

* A bridge used to assign stateless functions to listen to clarinet. * * As well as the parameter from clarinet, each callback will also be passed

* I don't like saying this: * * foo !=== undefined * * because of the double-negative. I find this: * * defined(foo) * * easier to read.

* Helper function for iterating over an array backwards. If the func * returns a true value, it will break out of the loop.

* foldR implementation. Reduce a list down to a single value. * * @pram {Function} fn (rightEval, curVal) -> result

* Create a function which always returns the same * value * * var return3 = functor(3); * * return3() // gives 3 * return3() // still gives 3 * return

* Given an event from a script node, get the requirejs info from it, * and then removes the event listeners on the node. * @param {E