What is it?
Lambda.js are string based lambdas for Node.js and the browser, that allow strings such as
'x+1' and 'x -> x+1' to be used as functions.
Origin
This is a spin-off project of Functional's (a library for functional programming in JavaScript) to-function.js by Oliver Steele.
Most of the source code and documentation is written by Oliver Steele and
contributers, so all credit goes to them. This project is just here to avoid
using the full library when only lambdas are needed (they play very
well with JavaScript 1.6's every(), filter(), forEach() etc). It also
detaches the lambda function from String.prototype to avoid cluttering it
with non-standard functions.
Usage
The only exported function is lambda(expression) which takes the "string
based lambda" as argument and turns that expression into a Function that
returns the value of the expression:
var square = lambda('x*x');
console.log(square.toString());
/* =>
function anonymous(x) {
return x * x;
}
*/
If the string contains a ->, this separates the parameters from the body:
lambda('x -> x + 1')(1); // => 2
lambda('x y -> x + 2*y')(1, 2); // => 5
lambda('x, y -> x + 2*y')(1, 2); // => 5
Otherwise, if the string contains a _, this is the only parameter:
lambda('_ + 1')(1); // => 2
If the string begins or ends with an operator or relation, prepend or append a
parameter (The documentation refers to this type of string as a section):
lambda('/2')(4); // => 2
lambda('2/')(4); // => 0.5
lambda('/')(2, 4); // => 0.5
Sections can end, but not begin with, -. (This is to avoid interpreting e.g.
-2*x as a section). On the other hand, a string that either begins or ends
with / is a section, so an expression that begins or ends with a regular
expression literal needs an explicit parameter.
Otherwise, each variable name is an implicit parameter:
lambda('x + 1')(1); // => 2
lambda('x + 2*y')(1, 2); // => 5
lambda('y + 2*x')(1, 2); // => 5
Implicit parameter detection ignores strings literals, variable names that
start with capitals and identifiers that precede : or follow .:
['probable', 'possible'].map(lambda('"im" + root')); // => ["improbable", "impossible"]
lambda('Math.cos(angle)')(Math.PI); // => -1
lambda('point.x')({x:1, y:2}); // => 1
lambda('({x:1, y:2})[key]')('x'); // => 1
Implicit parameter detection mistakenly looks inside regular expression literals for variable names. It also doesn't know to ignore JavaScript keywords and bound variables. (The only way you can get these last two is with a function literal inside the string. This is outside the intended use case for string lambdas.)
Use _ (to define a unary function) or ->, if the string contains anything
that looks like a free variable but shouldn't be used as a parameter, or to
specify parameters that are ordered differently from their first occurrence in
the string.
Chain ->s to create a function in uncurried form:
lambda('x -> y -> x + 2*y')(1)(2); // => 5
lambda('x -> y -> z -> x + 2*y+3*z')(1)(2)(3) // => 14