diff options
Diffstat (limited to 'js/dojo/dojox/lang/functional/multirec.js')
| -rw-r--r-- | js/dojo/dojox/lang/functional/multirec.js | 169 |
1 files changed, 169 insertions, 0 deletions
diff --git a/js/dojo/dojox/lang/functional/multirec.js b/js/dojo/dojox/lang/functional/multirec.js new file mode 100644 index 0000000..0f50668 --- /dev/null +++ b/js/dojo/dojox/lang/functional/multirec.js @@ -0,0 +1,169 @@ +//>>built +// wrapped by build app +define("dojox/lang/functional/multirec", ["dijit","dojo","dojox","dojo/require!dojox/lang/functional/lambda,dojox/lang/functional/util"], function(dijit,dojo,dojox){ +dojo.provide("dojox.lang.functional.multirec"); + +dojo.require("dojox.lang.functional.lambda"); +dojo.require("dojox.lang.functional.util"); + +// This module provides recursion combinators: +// - a multi-way recursion combinator. + +// Acknoledgements: +// - recursion combinators are inspired by Manfred von Thun's article +// "Recursion Theory and Joy" +// (http://www.latrobe.edu.au/philosophy/phimvt/joy/j05cmp.html) + +// Notes: +// - recursion combinators produce a function, which implements +// their respective recusion patterns. String lambdas are inlined, if possible. + +(function(){ + var df = dojox.lang.functional, inline = df.inlineLambda, + _x ="_x", _y_r_y_o = ["_y.r", "_y.o"]; + + df.multirec = function( + /*Function|String|Array*/ cond, + /*Function|String|Array*/ then, + /*Function|String|Array*/ before, + /*Function|String|Array*/ after){ + // summary: + // Generates a function for the multi-way recursion pattern. + // All parameter functions are called in the context of "this" object. + // cond: + // The lambda expression, which is used to detect the termination of recursion. + // It accepts the same parameter as the generated recursive function itself. + // This function should return "true", if the recursion should be stopped, + // and the "then" part should be executed. Otherwise the recursion will proceed. + // then: + // The lambda expression, which is called upon termination of the recursion. + // It accepts the same parameters as the generated recursive function itself. + // The returned value will be returned as the value of the generated function. + // before: + // The lambda expression, which is called before the recursive step. + // It accepts the same parameter as the generated recursive function itself. + // The returned value should be an array, which is used to call + // the generated function recursively. Each member of the array should be + // an array of parameters. The length of it defines how many times + // the generated function is called recursively. + // above: + // The lambda expression, which is called after the recursive step. + // It accepts two parameters: the array of returned values from recursive steps, + // and the original array of parameters used with all other functions. + // The returned value will be returned as the value of the generated function. + + var c, t, b, a, cs, ts, bs, as, dict1 = {}, dict2 = {}, + add2dict = function(x){ dict1[x] = 1; }; + if(typeof cond == "string"){ + cs = inline(cond, _x, add2dict); + }else{ + c = df.lambda(cond); + cs = "_c.apply(this, _x)"; + dict2["_c=_t.c"] = 1; + } + if(typeof then == "string"){ + ts = inline(then, _x, add2dict); + }else{ + t = df.lambda(then); + ts = "_t.apply(this, _x)"; + } + if(typeof before == "string"){ + bs = inline(before, _x, add2dict); + }else{ + b = df.lambda(before); + bs = "_b.apply(this, _x)"; + dict2["_b=_t.b"] = 1; + } + if(typeof after == "string"){ + as = inline(after, _y_r_y_o, add2dict); + }else{ + a = df.lambda(after); + as = "_a.call(this, _y.r, _y.o)"; + dict2["_a=_t.a"] = 1; + } + var locals1 = df.keys(dict1), locals2 = df.keys(dict2), + f = new Function([], "var _y={a:arguments},_x,_r,_z,_i".concat( // Function + locals1.length ? "," + locals1.join(",") : "", + locals2.length ? ",_t=arguments.callee," + locals2.join(",") : "", + t ? (locals2.length ? ",_t=_t.t" : "_t=arguments.callee.t") : "", + ";for(;;){for(;;){if(_y.o){_r=", + as, + ";break}_x=_y.a;if(", + cs, + "){_r=", + ts, + ";break}_y.o=_x;_x=", + bs, + ";_y.r=[];_z=_y;for(_i=_x.length-1;_i>=0;--_i){_y={p:_y,a:_x[_i],z:_z}}}if(!(_z=_y.z)){return _r}_z.r.push(_r);_y=_y.p}" + )); + if(c){ f.c = c; } + if(t){ f.t = t; } + if(b){ f.b = b; } + if(a){ f.a = a; } + return f; + }; +})(); + +/* +For documentation only: + +1) The original recursive version: + +var multirec1 = function(cond, then, before, after){ + var cond = df.lambda(cond), + then = df.lambda(then), + before = df.lambda(before), + after = df.lambda(after); + return function(){ + if(cond.apply(this, arguments)){ + return then.apply(this, arguments); + } + var args = before.apply(this, arguments), + ret = new Array(args.length); + for(var i = 0; i < args.length; ++i){ + ret[i] = arguments.callee.apply(this, args[i]); + } + return after.call(this, ret, arguments); + }; +}; + +2) The original iterative version (before minification and inlining): + +var multirec2 = function(cond, then, before, after){ + var cond = df.lambda(cond), + then = df.lambda(then), + before = df.lambda(before), + after = df.lambda(after); + return function(){ + var top = {args: arguments}, args, ret, parent, i; + for(;;){ + for(;;){ + if(top.old){ + ret = after.call(this, top.ret, top.old); + break; + } + args = top.args; + if(cond.apply(this, args)){ + ret = then.apply(this, args); + break; + } + top.old = args; + args = before.apply(this, args); + top.ret = []; + parent = top; + for(i = args.length - 1; i >= 0; --i){ + top = {prev: top, args: args[i], parent: parent}; + } + } + if(!(parent = top.parent)){ + return ret; + } + parent.ret.push(ret); + top = top.prev; + } + }; +}; + +*/ + +}); |