Attaches a given function to an object as a method.

Returns all property names of a given object that reference a function.

Extract the names of all parameters for a given function object.

Lifts func to become a Closure, that is that free variables referenced in func will be bound to the values of an object that can be passed in as the second parameter. Keys of this object are mapped to the free variables.

Please see Closure for a more detailed explanation and examples.

Like asScript but makes f a method of obj as optName or the name of the function.

Composes a set of synchronous functions: compose(f,g,h)(arg1, arg2) = h(g(f(arg1, arg2)))

Composes functions that are asynchronous and expecting continuations to be called in node.js callback style (error is first argument, real arguments follow). A call like composeAsync(f,g,h)(arg1, arg2) has a flow of control like: f(arg1, arg2, thenDo1) -> thenDo1(err, fResult) -> g(fResult, thenDo2) -> thenDo2(err, gResult) -> -> h(fResult, thenDo3) -> thenDo2(err, hResult)

Creates and initializes a worker queue.

Return a version of func with args applied.

Call func after wait milliseconds elapsed since the last invocation. Unlike throttle an invocation will restart the wait period. This is useful if you have a stream of events that you want to wait for to finish and run a subsequent function afterwards. When you pass arguments to the debounced functions then the arguments from the last call will be use for the invocation.

Like debounce but remembers the debounced function once created and repeated calls to debounceNamed with the identical name will use the same debounced function. This allows to debounce functions in a central place that might be called various times in different contexts without having to manually store the debounced function.

Delays calling func for timeout seconds(!).

Accepts multiple functions and returns an array of wrapped functions. Those wrapped functions ensure that only one of the original function is run (the first on to be invoked).

This is useful if you have multiple asynchronous choices of how the control flow might continue but want to ensure that a continuation is only triggered once, like in a timeout situation:

function outerFunction(callback) {
  function timeoutAction() { callback(new Error('timeout!')); }
  function otherAction() { callback(null, "All OK"); }
  setTimeout(timeoutAction, 200);
  doSomethingAsync(otherAction);
}

To ensure that callback only runs once you would normally have to write boilerplate like this:

var ran = false;
function timeoutAction() { if (ran) return; ran = true; callback(new Error('timeout!')); }
function otherAction() { if (ran) return; ran = true; callback(null, "All OK"); }

Since this can get tedious an error prone, especially if more than two choices are involved, either can be used like this:

Works like either but usage does not require to wrap all functions at once.

Useful when you have to stringify code but not want to construct strings by hand.

Swaps the first two args

Creates a function from a string.

Treats passed function as class (constructor).

Get the original function that was augmented by wrap. getOriginal will traversed as many wrappers as necessary.

Returns the var mapping for a given lively closure.

Similar to debounce but instead of taking a custom time interval we instead wait until the execution of the wrapped function has finished.

Like guard but remembers the last invocation via a name. Repeated calls to guardNamed with the same name will therefore be guarded as if we were calling the same guarded closure repeatedly.

Returns wether or not a given function is a "built in". Built in functions are native to the runtime and their implementation can not be inspected from Javascript.

Return the names of the functions defined on the prototype.

Wraps a function to log to the console every time it is applied.

Wrap a function to log to console once it succesfully completes.

Wraps a given function to automatically log all the errors encountered to the console.

Throws a well behaved error on purpopse, when accessing unimplemented functionality.

Ensure that func is only executed once. Multiple calls will not call func again but will return the original result.

Returns all local (non-prototype) property names of a given object that reference a function.

Return a qualified name for a given function object.

Change an objects method for a single invocation.

Given a lively closure, modifies the var binding.

Exec func at most once every wait ms even when called more often useful to calm down eagerly running updaters and such. This may very likely drop the last couple of calls so if you need a guarantee for the last call to "complete successfully" throttle is not the right choice.

Like throttle but remembers the throttled function once created and repeated calls to throttleNamed with the identical name will use the same throttled function. This allows to throttle functions in a central place that might be called various times in different contexts without having to manually store the throttled function.

Returns synchronous runtime of calling func in ms.

Like timeToRun but calls function n times instead of once. Returns the average runtime of a call in ms.

Wraps a function such that it traces all subsequent function calls to a stack object.

Wait for waitTesterFunc to return true, then run thenDo, passing failure/timout err as first parameter. A timout occurs after timeoutMs. During the wait period waitTesterFunc might be called multiple times.

Wait for multiple asynchronous functions. Once all have called the continuation, call thenDo.

Returns the current stackframes of the execution as a string.

Returns a modified version of func that will have null always curried as first arg. Usful e.g. to make a nodejs-style callback work with a then-able.

This functions helps when you have a long running computation that multiple call sites (independent from each other) depend on. This function does the housekeeping to start the long running computation just once and returns an object that allows to schedule callbacks once the workerFunc is done. This is how it works: If id does not exist, workerFunc is called, otherwise ignored. workerFunc is expected to call thenDoFunc with arguments: error, arg1, ..., argN if called subsequently before workerFunc is done, the other thenDoFunc will "pile up" and called with the same arguments as the first thenDoFunc once workerFunc is done.

A wrapper is another function that is being called with the arguments of func and a proceed function that, when called, runs the originally wrapped function.

Function wrappers used for wrapping, cop, and other method manipulations attach a property "originalFunction" to the wrapper. By convention this property references the wrapped method like wrapper -> cop wrapper -> real method. tThis method gives access to the linked list starting with the outmost wrapper.