Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojox.lang.functional"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox.lang.functional"] = true;
dojo.provide("dojox.lang.functional");

// This module adds high-level functions and related constructs:
//      - list comprehensions similar to JavaScript 1.7
//      - anonymous functions built from the string
//      - zip combiners
//      - "reduce" family of functions
//      - currying and partial functions
//      - argument pre-processing: mixer and flip
//      - miscellaneous useful functions

// Acknoledgements:
//      - parts of this module (most notably lambda, constFun, invoke, pluck, and partial) 
//              are based on work by Oliver Steele (http://osteele.com/sources/javascript/functional/functional.js)
//              which was published under MIT License
//      - Simple "maybe" monad was donated by Alex Russell.

// Notes:
//      - Dojo provides following high-level functions in dojo/_base/array.js: 
//              forEach, map, filter, every, some
//      - These functions implemented with optional lambda expression as a parameter.
//      - missing high-level functions are provided with the compatible API: 
//              foldl, foldl1, scanl, scanl1, foldr, foldr1, scanr, scanr1,
//              reduce, reduceRight
//      - lambda() and listcomp() produce functions, which after the compilation step are 
//              as fast as regular JS functions (at least theoretically).

(function(){
        var d = dojo, df = dojox.lang.functional, g_re = /\bfor\b|\bif\b/gm, empty = {};
        
        // split() is augmented on IE6 to ensure the uniform behavior
        var split = "ab".split(/a*/).length > 1 ? String.prototype.split :
                        function(sep){
                                 var r = this.split.call(this, sep),
                                         m = sep.exec(this);
                                 if(m && m.index == 0){ r.unshift(""); }
                                 return r;
                        };
        var lambda = function(/*String*/ s){
                var args = [], sects = split.call(s, /\s*->\s*/m);
                if(sects.length > 1){
                        while(sects.length){
                                s = sects.pop();
                                args = sects.pop().split(/\s*,\s*|\s+/m);
                                if(sects.length){ sects.push("(function(" + args + "){return (" + s + ")})"); }
                        }
                } else if(s.match(/\b_\b/)) {
                        args = ["_"];
                } else {
                        var l = s.match(/^\s*(?:[+*\/%&|\^\.=<>]|!=)/m),
                                r = s.match(/[+\-*\/%&|\^\.=<>!]\s*$/m);
                        if(l || r){
                                if(l){
                                        args.push("$1");
                                        s = "$1" + s;
                                }
                                if(r){
                                        args.push("$2");
                                        s = s + "$2";
                                }
                        } else {
                                var vars = s.
                                        replace(/(?:\b[A-Z]|\.[a-zA-Z_$])[a-zA-Z_$\d]*|[a-zA-Z_$][a-zA-Z_$\d]*:|this|true|false|null|undefined|typeof|instanceof|in|delete|new|void|arguments|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|escape|eval|isFinite|isNaN|parseFloat|parseInt|unescape|dojo|dijit|dojox|'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"/g, "").
                                        match(/([a-z_$][a-z_$\d]*)/gi) || [];
                                var t = {};
                                d.forEach(vars, function(v){
                                        if(!(v in t)){
                                                args.push(v);
                                                t[v] = 1;
                                        }
                                });
                        }
                }
                return {args: args, body: "return (" + s + ");"};       // Object
        };
        
        var listcomp = function(/*String*/ s){
                var frag = s.split(g_re), act = s.match(g_re),
                        head = ["var r = [];"], tail = [];
                for(var i = 0; i < act.length;){
                        var a = act[i], f = frag[++i];
                        if(a == "for" && !/^\s*\(\s*(;|var)/.test(f)){
                                f = f.replace(/^\s*\(/, "(var ");
                        }
                        head.push(a, f, "{");
                        tail.push("}");
                }
                return head.join("") + "r.push(" + frag[0] + ");" + tail.join("") + "return r;";        // String
        };
        
        var currying = function(/*Object*/ info){
                return function(){      // Function
                        if(arguments.length + info.args.length < info.arity){
                                return currying({func: info.func, arity: info.arity, 
                                        args: Array.prototype.concat.apply(info.args, arguments)});
                        }
                        return info.func.apply(this, Array.prototype.concat.apply(info.args, arguments));
                };
        };
        
        var identity = function(x){ return x; };
        var compose = function(/*Array*/ a){
                return a.length ? function(){
                        var i = a.length - 1, x = df.lambda(a[i]).apply(this, arguments);
                        for(--i; i >= 0; --i){ x = df.lambda(a[i]).call(this, x); }
                        return x;
                } : identity;
        };
        
        d.mixin(df, {
                // lambda
                buildLambda: function(/*String*/ s){
                        // summary: builds a function from a snippet, returns a string, 
                        //      which represents the function.
                        // description: This method returns a textual representation of a function 
                        //      built from the snippet. It is meant to be evaled in the proper context, 
                        //      so local variables can be pulled from the environment.
                        s = lambda(s);
                        return "function(" + s.args.join(",") + "){" + s.body + "}";    // String
                },
                lambda: function(/*Function|String|Array*/ s){
                        // summary: builds a function from a snippet, or array (composing), returns 
                        //      a function object; functions are passed through unmodified.
                        // description: This method is used to normalize a functional representation
                        //      (a text snippet, an array, or a function) to a function object.
                        if(typeof s == "function"){ return s; }
                        if(s instanceof Array){ return compose(s); }
                        s = lambda(s);
                        return new Function(s.args, s.body);    // Function
                },
                // sequence generators
                repeat: function(/*Number*/ n, /*Function|String|Array*/ f, /*Object*/ z, /*Object?*/ o){
                        // summary: builds an array by repeatedly applying a unary function N times 
                        //      with a seed value Z.
                        o = o || d.global; f = df.lambda(f);
                        var t = new Array(n);
                        t[0] = z;
                        for(var i = 1; i < n; t[i] = z = f.call(o, z), ++i);
                        return t;       // Array
                },
                until: function(/*Function|String|Array*/ pr, /*Function|String|Array*/ f, /*Object*/ z, /*Object?*/ o){
                        // summary: builds an array by repeatedly applying a unary function with 
                        //      a seed value Z until the predicate is satisfied.
                        o = o || d.global; f = df.lambda(f); pr = df.lambda(pr);
                        var t = [];
                        for(; !pr.call(o, z); t.push(z), z = f.call(o, z));
                        return t;       // Array
                },
                buildListcomp: function(/*String*/ s){
                        // summary: builds a function from a text snippet, which represents a valid
                        //      JS 1.7 list comprehension, returns a string, which represents the function.
                        // description: This method returns a textual representation of a function 
                        //      built from the list comprehension text snippet (conformant to JS 1.7). 
                        //      It is meant to be evaled in the proper context, so local variable can be 
                        //      pulled from the environment.
                        return "function(){" + listcomp(s) + "}";       // String
                },
                compileListcomp: function(/*String*/ s){
                        // summary: builds a function from a text snippet, which represents a valid
                        //      JS 1.7 list comprehension, returns a function object.
                        // description: This method returns a function built from the list 
                        //      comprehension text snippet (conformant to JS 1.7). It is meant to be 
                        //      reused several times.
                        return new Function([], listcomp(s));   // Function
                },
                listcomp: function(/*String*/ s){
                        // summary: executes the list comprehension building an array.
                        return (new Function([], listcomp(s)))();       // Array
                },
                // classic reduce-class functions
                foldl: function(/*Array*/ a, /*Function*/ f, /*Object*/ z, /*Object?*/ o){
                        // summary: repeatedly applies a binary function to an array from left 
                        //      to right using a seed value as a starting point; returns the final 
                        //      value.
                        a = typeof a == "string" ? a.split("") : a; o = o || d.global; f = df.lambda(f);
                        for(var i = 0; i < a.length; z = f.call(o, z, a[i], i, a), ++i);
                        return z;       // Object
                },
                foldl1: function(/*Array*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
                        // summary: repeatedly applies a binary function to an array from left 
                        //      to right; returns the final value.
                        a = typeof a == "string" ? a.split("") : a; o = o || d.global; f = df.lambda(f);
                        var z = a[0];
                        for(var i = 1; i < a.length; z = f.call(o, z, a[i], i, a), ++i);
                        return z;       // Object
                },
                scanl: function(/*Array*/ a, /*Function|String|Array*/ f, /*Object*/ z, /*Object?*/ o){
                        // summary: repeatedly applies a binary function to an array from left 
                        //      to right using a seed value as a starting point; returns an array
                        //      of values produced by foldl() at that point.
                        a = typeof a == "string" ? a.split("") : a; o = o || d.global; f = df.lambda(f);
                        var n = a.length, t = new Array(n + 1);
                        t[0] = z;
                        for(var i = 0; i < n; z = f.call(o, z, a[i], i, a), t[++i] = z);
                        return t;       // Array
                },
                scanl1: function(/*Array*/ a, /*Function|String|Array*/ f, /*Object*/ z, /*Object?*/ o){
                        // summary: repeatedly applies a binary function to an array from left 
                        //      to right; returns an array of values produced by foldl1() at that 
                        //      point.
                        a = typeof a == "string" ? a.split("") : a; o = o || d.global; f = df.lambda(f);
                        var n = a.length, t = new Array(n), z = a[0];
                        t[0] = z;
                        for(var i = 1; i < n; z = f.call(o, z, a[i], i, a), t[i++] = z);
                        return t;       // Array
                },
                foldr: function(/*Array*/ a, /*Function|String|Array*/ f, /*Object*/ z, /*Object?*/ o){
                        // summary: repeatedly applies a binary function to an array from right
                        //      to left using a seed value as a starting point; returns the final 
                        //      value.
                        a = typeof a == "string" ? a.split("") : a; o = o || d.global; f = df.lambda(f);
                        for(var i = a.length; i > 0; --i, z = f.call(o, z, a[i], i, a));
                        return z;       // Object
                },
                foldr1: function(/*Array*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
                        // summary: repeatedly applies a binary function to an array from right
                        //      to left; returns the final value.
                        a = typeof a == "string" ? a.split("") : a; o = o || d.global; f = df.lambda(f);
                        var n = a.length, z = a[n - 1];
                        for(var i = n - 1; i > 0; --i, z = f.call(o, z, a[i], i, a));
                        return z;       // Object
                },
                scanr: function(/*Array*/ a, /*Function|String|Array*/ f, /*Object*/ z, /*Object?*/ o){
                        // summary: repeatedly applies a binary function to an array from right
                        //      to left using a seed value as a starting point; returns an array
                        //      of values produced by foldr() at that point.
                        a = typeof a == "string" ? a.split("") : a; o = o || d.global; f = df.lambda(f);
                        var n = a.length, t = new Array(n + 1);
                        t[n] = z;
                        for(var i = n; i > 0; --i, z = f.call(o, z, a[i], i, a), t[i] = z);
                        return t;       // Array
                },
                scanr1: function(/*Array*/ a, /*Function|String|Array*/ f, /*Object*/ z, /*Object?*/ o){
                        // summary: repeatedly applies a binary function to an array from right
                        //      to left; returns an array of values produced by foldr1() at that 
                        //      point.
                        a = typeof a == "string" ? a.split("") : a; o = o || d.global; f = df.lambda(f);
                        var n = a.length, t = new Array(n), z = a[n - 1];
                        t[n - 1] = z;
                        for(var i = n - 1; i > 0; --i, z = f.call(o, z, a[i], i, a), t[i] = z);
                        return t;       // Array
                },
                // JS 1.6 standard array functions, which can take a lambda as a parameter.
                // Consider using dojo._base.array functions, if you don't need the lambda support.
                filter: function(/*Array*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
                        // summary: creates a new array with all elements that pass the test 
                        //      implemented by the provided function.
                        a = typeof a == "string" ? a.split("") : a; o = o || d.global; f = df.lambda(f);
                        var n = a.length, t = [], v;
                        for(var i = 0; i < n; ++i){
                                v = a[i];
                                if(f.call(o, v, i, a)){ t.push(v); }
                        }
                        return t;       // Array
                },
                forEach: function(/*Array*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
                        // summary: executes a provided function once per array element.
                        a = typeof a == "string" ? a.split("") : a; o = o || d.global; f = df.lambda(f);
                        var n = a.length;
                        for(var i = 0; i < n; f.call(o, a[i], i, a), ++i);
                },
                map: function(/*Array*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
                        // summary: creates a new array with the results of calling 
                        //      a provided function on every element in this array.
                        a = typeof a == "string" ? a.split("") : a; o = o || d.global; f = df.lambda(f);
                        var n = a.length, t = new Array(n);
                        for(var i = 0; i < n; t[i] = f.call(o, a[i], i, a), ++i);
                        return t;       // Array
                },
                every: function(/*Array*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
                        // summary: tests whether all elements in the array pass the test 
                        //      implemented by the provided function.
                        a = typeof a == "string" ? a.split("") : a; o = o || d.global; f = df.lambda(f);
                        var n = a.length;
                        for(var i = 0; i < n; ++i){
                                if(!f.call(o, a[i], i, a)){
                                        return false;   // Boolean
                                }
                        }
                        return true;    // Boolean
                },
                some: function(/*Array*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
                        // summary: tests whether some element in the array passes the test 
                        //      implemented by the provided function.
                        a = typeof a == "string" ? a.split("") : a; o = o || d.global; f = df.lambda(f);
                        var n = a.length;
                        for(var i = 0; i < n; ++i){
                                if(f.call(o, a[i], i, a)){
                                        return true;    // Boolean
                                }
                        }
                        return false;   // Boolean
                },
                // JS 1.8 standard array functions, which can take a lambda as a parameter.
                reduce: function(/*Array*/ a, /*Function*/ f, /*Object?*/ z){
                        // summary: apply a function simultaneously against two values of the array 
                        //      (from left-to-right) as to reduce it to a single value.
                        return arguments.length < 3 ? df.foldl1(a, f) : df.foldl(a, f, z);      // Object
                },
                reduceRight: function(/*Array*/ a, /*Function*/ f, /*Object?*/ z){
                        // summary: apply a function simultaneously against two values of the array 
                        //      (from right-to-left) as to reduce it to a single value.
                        return arguments.length < 3 ? df.foldr1(a, f) : df.foldr(a, f, z);      // Object
                },
                // currying and partial functions
                curry: function(/*Function|String|Array*/ f, /*Number?*/ arity){
                        // summary: curries a function until the arity is satisfied, at 
                        //      which point it returns the calculated value.
                        f = df.lambda(f);
                        arity = typeof arity == "number" ? arity : f.length;
                        return currying({func: f, arity: arity, args: []});     // Function
                },
                arg: {},        // marker for missing arguments
                partial: function(/*Function|String|Array*/ f){
                        // summary: creates a function where some arguments are bound, and
                        //      some arguments (marked as dojox.lang.functional.arg) are will be 
                        //      accepted by the final function in the order they are encountered.
                        // description: This method is used to produce partially bound 
                        //      functions. If you want to change the order of arguments, use
                        //      dojox.lang.functional.mixer() or dojox.lang.functional.flip().
                        var a = arguments, args = new Array(a.length - 1), p = [];
                        f = df.lambda(f);
                        for(var i = 1; i < a.length; ++i){
                                var t = a[i];
                                args[i - 1] = t;
                                if(t == df.arg){
                                        p.push(i - 1);
                                }
                        }
                        return function(){      // Function
                                var t = Array.prototype.slice.call(args, 0); // clone the array
                                for(var i = 0; i < p.length; ++i){
                                        t[p[i]] = arguments[i];
                                }
                                return f.apply(this, t);
                        };
                },
                // argument pre-processing
                mixer: function(/*Function|String|Array*/ f, /*Array*/ mix){
                        // summary: changes the order of arguments using an array of
                        //      numbers mix --- i-th argument comes from mix[i]-th place
                        //      of supplied arguments.
                        f = df.lambda(f);
                        return function(){      // Function
                                var t = new Array(mix.length);
                                for(var i = 0; i < mix.length; ++i){
                                        t[i] = arguments[mix[i]];
                                }
                                return f.apply(this, t);
                        };
                },
                flip: function(/*Function|String|Array*/ f){
                        // summary: changes the order of arguments by reversing their
                        //      order.
                        f = df.lambda(f);
                        return function(){      // Function
                                // reverse arguments
                                var a = arguments, l = a.length - 1, t = new Array(l + 1), i;
                                for(i = 0; i <= l; ++i){
                                        t[l - i] = a[i];
                                }
                                return f.apply(this, t);
                        };
                },
                // combiners
                zip: function(){
                        // summary: returns an array of arrays, where the i-th array 
                        //      contains the i-th element from each of the argument arrays.
                        // description: This is the venerable zip combiner (for example,
                        //      see Python documentation for general details). The returned
                        //      array is truncated to match the length of the shortest input
                        //      array.
                        var n = arguments[0].length, m = arguments.length, i;
                        for(i = 1; i < m; n = Math.min(n, arguments[i++].length));
                        var t = new Array(n), j;
                        for(i = 0; i < n; ++i){
                                var p = new Array(m);
                                for(j = 0; j < m; p[j] = arguments[j][i], ++j);
                                t[i] = p;
                        }
                        return t;       // Array
                },
                unzip: function(/*Array*/ a){
                        // summary: similar to dojox.lang.functional.zip(), but takes 
                        //      a single array of arrays as the input.
                        // description: This function is similar to dojox.lang.functional.zip() 
                        //      and can be used to unzip objects packed by 
                        //      dojox.lang.functional.zip(). It is here mostly to provide 
                        //      a short-cut for the different method signature.
                        return df.zip.apply(null, a);   // Array
                },
                // miscelaneous functional adapters
                constFun: function(/*Object*/ x){
                        // summary: returns a function, which produces a constant value 
                        //      regardless of supplied parameters.
                        return function(){ return x; }; // Function
                },
                invoke: function(/*String*/ m){
                        // summary: returns a function, which invokes a method on supplied 
                        //      object using optional parameters.
                        return function(/*Object*/ o){  // Function
                                return o[m].apply(o, Array.prototype.slice.call(arguments, 1));
                        };
                },
                pluck: function(/*String*/ m){
                        // summary: returns a function, which returns a named object member.
                        return function(/*Object*/ o){  // Function
                                return o[m];
                        };
                },
                // object helpers
                forIn: function(/*Object*/ obj, /*Function|String|Array*/ f, /*Object?*/ o){
                        // summary: iterates over all object members skipping members, which 
                        //      are present in the empty object (IE and/or 3rd-party libraries).
                        o = o || d.global; f = df.lambda(f);
                        for(var i in obj){
                                if(i in empty){ continue; }
                                f.call(o, obj[i], i, obj);
                        }
                },
                forEachReversed: function(/*Array*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
                        // summary: executes a provided function once per array element.
                        a = typeof a == "string" ? a.split("") : a; o = o || d.global; f = df.lambda(f);
                        for(var i = a.length - 1; i >= 0; f.call(o, a[i], i, a), --i);
                }
        });

        // monads
        dojo.declare("dojox.lang.functional.MaybeMonad", null, {
                constructor: function(/*Object*/ value){
                        // summary: constructs a monad optionally initializing all additional members
                        if(arguments.length){
                                this.value = value;
                        }
                },
                bind: function(/*dojox.lang.functional.Monad*/ monad, /*Function|String|Array*/ f, /*Object?*/ o){
                        // summary: this is the classic bind method, which applies a function to a monad,
                        //      and returns a result as a monad; it is meant to be overwritten to incorporate
                        //      side effects
                        if(!("value" in monad)){
                                return new this.constructor();  // dojox.lang.functional.MaybeMonad
                        }
                        // => possible side-effects go here
                        o = o || d.global; f = df.lambda(f);
                        return f.call(o, monad.value);  // dojox.lang.functional.Monad
                },
                // class-specific methods
                isNothing: function(){
                        // summary: check if there is no bound value.
                        return !("value" in this);      // Boolean
                }
        });
        df.MaybeMonad.returnMonad = function(/*Object*/ value){
                // summary: puts a valye in the Maybe monad.
                return new df.MaybeMonad(value);        // dojox.lang.functional.MaybeMonad
        };
        df.MaybeMonad.zero = new df.MaybeMonad();
})();

}