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();
	})();

}