linq 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 67233bc3ad787b03aacc9e27ed2cc2eae58444a3
-  data.tar.gz: 99f43e87ec3e84fe9e4179117317226f6b201864
+  metadata.gz: ac15f012b9305f37758b8b21340827d593637cfe
+  data.tar.gz: 3dbd640de40cee2ab964633ae7bca683d07578ea
 SHA512:
-  metadata.gz: 0ada646d74a47364d6575e4ee65dd7fce85becc7ce587b9029e94826b9edfaadeab9121ec484a64facd7662572947243a4bc7335753012b148780c4a59fb1aca
-  data.tar.gz: 3a245111d93398046230ca4714ae7abd0e9c08a7bb57ed10f2d52d64b946bcdc598d8830f1652cbc4f355f8286b5fa0a24c2c05f17a145825bd51914b6ef36d0
+  metadata.gz: 2f0820c0bc3857fe3aa12b77c120c460f0bc2e419268328c86637b52db8f3cc17c1312c4580dbf66ba64917fe3f6526599431c9c7b0e68d586019d766bfd11d6
+  data.tar.gz: a6074ca14f8ba775d0fc1baef7d3be13d0933521f212c1930560b8d465bcb53c829fac5e8be7002f596673e5a9caba44e21eeef094826cfa562ed0ea289c784e

data/README.md

@@ -1,39 +1,103 @@
-# Linq
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/linq`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'linq'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install linq
-
-## Usage
-
-TODO: Write usage instructions here
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-1. Fork it ( https://github.com/[my-github-username]/linq/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+# Linq
+
+Language-Integrated Query (LINQ) is a set of features introduced in Visual Studio 2008 (That moment for #C, VisualBasic) that extends powerful query capabilities to the language syntax. This gem is wrapper for linq.js JavaScript plugin. LINQ introduces standard, easily-learned patterns for querying and updating data, and the technology can be extended to support potentially any kind of data store.
+
+## Features
+
+- Implement all .NET 4.0 methods and many extra methods (inspiration from Rx, Achiral, Haskell, Ruby, etc...)
+- Complete lazy evaluation
+- Two versions - linq.js and jquery.linq.js (jQuery plugin)
+- Binding for Reactive Extensions for JavaScript(RxJS)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'linq'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install linq
+
+Add to javascript manifest `application.js`
+    
+	//= require linq
+
+## Examples of usage
+```javascript
+var jsonArray = [
+    { "user": { "id": 100, "screen_name": "d_linq" }, "text": "to objects" },
+    { "user": { "id": 130, "screen_name": "c_bill" }, "text": "g" },
+    { "user": { "id": 155, "screen_name": "b_mskk" }, "text": "kabushiki kaisha" },
+    { "user": { "id": 301, "screen_name": "a_xbox" }, "text": "halo reach" }
+]
+
+var queryResult = Enumerable.From(jsonArray)
+    .Where(function (x) { return x.user.id < 200 })
+    .OrderBy(function (x) { return x.user.screen_name })
+    .Select(function (x) { return x.user.screen_name + ':' + x.text })
+    .ToArray();
+    
+// shortcut! string lambda selector
+var queryResult2 = Enumerable.From(jsonArray)
+    .Where("$.user.id < 200")
+    .OrderBy("$.user.screen_name")
+    .Select("$.user.screen_name + ':' + $.text")
+    .ToArray();
+```    
+
+More tricky:
+
+```javascript	  
+// anonymous function
+Enumerable.Range(1, 10)
+    .Where(function(i) { return i % 3 == 0; })
+    .Select(function(i) { return i * 10; });
+    
+// lambda expression
+Enumerable.Range(1, 10).Where("i => i % 3 == 0").Select("i => i * 10");
+
+// $ is default iterator variable like Scala's "_" or Groovy's "it"
+Enumerable.Range(1, 10).Where("$ % 3 == 0").Select("$ * 10");
+
+ // "" is shorthand of "x => x" (identity function)
+Enumerable.Range(4, 7).Join(Enumerable.Range(8, 5), "", "", "outer,inner=>outer*inner");
+
+// Enumerable.From is wrap from primitive array, string(to charArray), object(to KeyValuePair[]) etc..
+var array = [100, 200, 30, 40, 500, 40, 200];
+var ex1 = Enumerable.From(array).Distinct().ToArray(); // [100, 200, 30, 40, 500]
+var ex2 = Enumerable.From("foobar").ToArray(); // ["f", "o", "o", "b", "a", "r"];
+var ex3 = Enumerable.From({foo:10, bar:20}).ToArray(); // [{Key:"foo",Value:10}, {Key:"bar",Value:20}]
+
+// object literal
+Enumerable.From(array).Select("val,i=>{Value:val, Index:i}")
+```
+And Jquery:
+
+```javascript
+// $.Enumerable
+$.Enumerable.Range(1, 10).Where("$ % 2 == 0").ForEach("alert($)");
+
+// TojQuery - Enumerable to jQuery
+$.Enumerable.Range(1, 10)
+    .Select(function (i) { return $("<option>").text(i)[0] })
+    .TojQuery()
+    .appendTo("#select1");
+
+// toEnumerable - jQuery to Enumerable
+var sum = $("#select1").children()
+    .toEnumerable()
+    .Select("parseInt($.text())")
+    .Sum(); // 55
+```
+
+
+Full [documentation is on the wiki][wiki]
+
+[wiki]: https://github.com/khusnetdinov/linq/wiki

data/app/assests/javascripts/linq.jquery.js

@@ -0,0 +1,28 @@
+// extension for jQuery
+
+(function (root) {
+    if (root.Enumerable == null) {
+        throw new Error("can't find Enumerable. linq.jquery.js must load after linq.js");
+    }
+    if (root.jQuery == null) {
+        throw new Error("can't find jQuery. linq.jquery.js must load after jQuery");
+    }
+
+    var Enumerable = root.Enumerable;
+    var $ = root.jQuery;
+
+    $.fn.toEnumerable = function () {
+        /// <summary>each contains elements. to Enumerable&lt;jQuery&gt;.</summary>
+        return Enumerable.from(this).select(function (e) { return $(e) });
+    };
+
+    Enumerable.prototype.tojQuery = function () {
+        /// <summary>Enumerable to jQuery. All elements add to blank jQuery object.</summary>
+        return this.aggregate($(), function (j, x) { return j.add(x); });
+    };
+
+    Enumerable.prototype.tojQueryAsArray = function () {
+        /// <summary>Enumerable to jQuery. This behavior is $(this.toArray()).</summary>
+        return $(this.toArray());
+    };
+})(this);

data/app/assests/javascripts/linq.js

@@ -0,0 +1,3 @@
+//= require linq.lib
+//= require linq.rx
+//= require link.jquery

data/app/assests/javascripts/linq.lib.js

@@ -0,0 +1,2997 @@
+/*--------------------------------------------------------------------------
+ * linq.js - LINQ for JavaScript
+ * ver 3.0.3-Beta4 (Oct. 9th, 2012)
+ *
+ * created and maintained by neuecc <ils@neue.cc>
+ * licensed under MIT License
+ * http://linqjs.codeplex.com/
+ *------------------------------------------------------------------------*/
+
+(function (root, undefined) {
+    // ReadOnly Function
+    var Functions = {
+        Identity: function (x) { return x; },
+        True: function () { return true; },
+        Blank: function () { }
+    };
+
+    // const Type
+    var Types = {
+        Boolean: typeof true,
+        Number: typeof 0,
+        String: typeof "",
+        Object: typeof {},
+        Undefined: typeof undefined,
+        Function: typeof function () { }
+    };
+
+    // private utility methods
+    var Utils = {
+        // Create anonymous function from lambda expression string
+        createLambda: function (expression) {
+            if (expression == null) return Functions.Identity;
+            if (typeof expression == Types.String) {
+                if (expression == "") {
+                    return Functions.Identity;
+                }
+                else if (expression.indexOf("=>") == -1) {
+                    var regexp = new RegExp("[$]+", "g");
+
+                    var maxLength = 0;
+                    var match;
+                    while (match = regexp.exec(expression)) {
+                        var paramNumber = match[0].length;
+                        if (paramNumber > maxLength) {
+                            maxLength = paramNumber;
+                        }
+                    }
+
+                    var argArray = [];
+                    for (var i = 1; i <= maxLength; i++) {
+                        var dollar = "";
+                        for (var j = 0; j < i; j++) {
+                            dollar += "$";
+                        }
+                        argArray.push(dollar);
+                    }
+
+                    var args = Array.prototype.join.call(argArray, ",");
+
+                    return new Function(args, "return " + expression);
+                }
+                else {
+                    var expr = expression.match(/^[(\s]*([^()]*?)[)\s]*=>(.*)/);
+                    return new Function(expr[1], "return " + expr[2]);
+                }
+            }
+            return expression;
+        },
+
+        isIEnumerable: function (obj) {
+            if (typeof Enumerator !== Types.Undefined) {
+                try {
+                    new Enumerator(obj); // check JScript(IE)'s Enumerator
+                    return true;
+                }
+                catch (e) { }
+            }
+
+            return false;
+        },
+
+        // IE8's defineProperty is defined but cannot use, therefore check defineProperties
+        defineProperty: (Object.defineProperties != null)
+            ? function (target, methodName, value) {
+                Object.defineProperty(target, methodName, {
+                    enumerable: false,
+                    configurable: true,
+                    writable: true,
+                    value: value
+                })
+            }
+            : function (target, methodName, value) {
+                target[methodName] = value;
+            },
+
+        compare: function (a, b) {
+            return (a === b) ? 0
+                 : (a > b) ? 1
+                 : -1;
+        },
+
+        dispose: function (obj) {
+            if (obj != null) obj.dispose();
+        }
+    };
+
+    // IEnumerator State
+    var State = { Before: 0, Running: 1, After: 2 };
+
+    // "Enumerator" is conflict JScript's "Enumerator"
+    var IEnumerator = function (initialize, tryGetNext, dispose) {
+        var yielder = new Yielder();
+        var state = State.Before;
+
+        this.current = yielder.current;
+
+        this.moveNext = function () {
+            try {
+                switch (state) {
+                    case State.Before:
+                        state = State.Running;
+                        initialize();
+                        // fall through
+                    case State.Running:
+                        if (tryGetNext.apply(yielder)) {
+                            return true;
+                        }
+                        else {
+                            this.dispose();
+                            return false;
+                        }
+                    case State.After:
+                        return false;
+                }
+            }
+            catch (e) {
+                this.dispose();
+                throw e;
+            }
+        };
+
+        this.dispose = function () {
+            if (state != State.Running) return;
+
+            try {
+                dispose();
+            }
+            finally {
+                state = State.After;
+            }
+        };
+    };
+
+    // for tryGetNext
+    var Yielder = function () {
+        var current = null;
+        this.current = function () { return current; };
+        this.yieldReturn = function (value) {
+            current = value;
+            return true;
+        };
+        this.yieldBreak = function () {
+            return false;
+        };
+    };
+
+    // Enumerable constuctor
+    var Enumerable = function (getEnumerator) {
+        this.getEnumerator = getEnumerator;
+    };
+
+    // Utility
+
+    Enumerable.Utils = {}; // container
+
+    Enumerable.Utils.createLambda = function (expression) {
+        return Utils.createLambda(expression);
+    };
+
+    Enumerable.Utils.createEnumerable = function (getEnumerator) {
+        return new Enumerable(getEnumerator);
+    };
+
+    Enumerable.Utils.createEnumerator = function (initialize, tryGetNext, dispose) {
+        return new IEnumerator(initialize, tryGetNext, dispose);
+    };
+
+    Enumerable.Utils.extendTo = function (type) {
+        var typeProto = type.prototype;
+        var enumerableProto;
+
+        if (type === Array) {
+            enumerableProto = ArrayEnumerable.prototype;
+            Utils.defineProperty(typeProto, "getSource", function () {
+                return this;
+            });
+        }
+        else {
+            enumerableProto = Enumerable.prototype;
+            Utils.defineProperty(typeProto, "getEnumerator", function () {
+                return Enumerable.from(this).getEnumerator();
+            });
+        }
+
+        for (var methodName in enumerableProto) {
+            var func = enumerableProto[methodName];
+
+            // already extended
+            if (typeProto[methodName] == func) continue;
+
+            // already defined(example Array#reverse/join/forEach...)
+            if (typeProto[methodName] != null) {
+                methodName = methodName + "ByLinq";
+                if (typeProto[methodName] == func) continue; // recheck
+            }
+
+            if (func instanceof Function) {
+                Utils.defineProperty(typeProto, methodName, func);
+            }
+        }
+    };
+
+    // Generator
+
+    Enumerable.choice = function () // variable argument
+    {
+        var args = arguments;
+
+        return new Enumerable(function () {
+            return new IEnumerator(
+                function () {
+                    args = (args[0] instanceof Array) ? args[0]
+                        : (args[0].getEnumerator != null) ? args[0].toArray()
+                        : args;
+                },
+                function () {
+                    return this.yieldReturn(args[Math.floor(Math.random() * args.length)]);
+                },
+                Functions.Blank);
+        });
+    };
+
+    Enumerable.cycle = function () // variable argument
+    {
+        var args = arguments;
+
+        return new Enumerable(function () {
+            var index = 0;
+            return new IEnumerator(
+                function () {
+                    args = (args[0] instanceof Array) ? args[0]
+                        : (args[0].getEnumerator != null) ? args[0].toArray()
+                        : args;
+                },
+                function () {
+                    if (index >= args.length) index = 0;
+                    return this.yieldReturn(args[index++]);
+                },
+                Functions.Blank);
+        });
+    };
+
+    Enumerable.empty = function () {
+        return new Enumerable(function () {
+            return new IEnumerator(
+                Functions.Blank,
+                function () { return false; },
+                Functions.Blank);
+        });
+    };
+
+    Enumerable.from = function (obj) {
+        if (obj == null) {
+            return Enumerable.empty();
+        }
+        if (obj instanceof Enumerable) {
+            return obj;
+        }
+        if (typeof obj == Types.Number || typeof obj == Types.Boolean) {
+            return Enumerable.repeat(obj, 1);
+        }
+        if (typeof obj == Types.String) {
+            return new Enumerable(function () {
+                var index = 0;
+                return new IEnumerator(
+                    Functions.Blank,
+                    function () {
+                        return (index < obj.length) ? this.yieldReturn(obj.charAt(index++)) : false;
+                    },
+                    Functions.Blank);
+            });
+        }
+        if (typeof obj != Types.Function) {
+            // array or array like object
+            if (typeof obj.length == Types.Number) {
+                return new ArrayEnumerable(obj);
+            }
+
+            // JScript's IEnumerable
+            if (!(obj instanceof Object) && Utils.isIEnumerable(obj)) {
+                return new Enumerable(function () {
+                    var isFirst = true;
+                    var enumerator;
+                    return new IEnumerator(
+                        function () { enumerator = new Enumerator(obj); },
+                        function () {
+                            if (isFirst) isFirst = false;
+                            else enumerator.moveNext();
+
+                            return (enumerator.atEnd()) ? false : this.yieldReturn(enumerator.item());
+                        },
+                        Functions.Blank);
+                });
+            }
+
+            // WinMD IIterable<T>
+            if (typeof Windows === Types.Object && typeof obj.first === Types.Function) {
+                return new Enumerable(function () {
+                    var isFirst = true;
+                    var enumerator;
+                    return new IEnumerator(
+                        function () { enumerator = obj.first(); },
+                        function () {
+                            if (isFirst) isFirst = false;
+                            else enumerator.moveNext();
+
+                            return (enumerator.hasCurrent) ? this.yieldReturn(enumerator.current) : this.yieldBreak();
+                        },
+                        Functions.Blank);
+                });
+            }
+        }
+
+        // case function/object : Create keyValuePair[]
+        return new Enumerable(function () {
+            var array = [];
+            var index = 0;
+
+            return new IEnumerator(
+                function () {
+                    for (var key in obj) {
+                        var value = obj[key];
+                        if (!(value instanceof Function) && Object.prototype.hasOwnProperty.call(obj, key)) {
+                            array.push({ key: key, value: value });
+                        }
+                    }
+                },
+                function () {
+                    return (index < array.length)
+                        ? this.yieldReturn(array[index++])
+                        : false;
+                },
+                Functions.Blank);
+        });
+    },
+
+    Enumerable.make = function (element) {
+        return Enumerable.repeat(element, 1);
+    };
+
+    // Overload:function(input, pattern)
+    // Overload:function(input, pattern, flags)
+    Enumerable.matches = function (input, pattern, flags) {
+        if (flags == null) flags = "";
+        if (pattern instanceof RegExp) {
+            flags += (pattern.ignoreCase) ? "i" : "";
+            flags += (pattern.multiline) ? "m" : "";
+            pattern = pattern.source;
+        }
+        if (flags.indexOf("g") === -1) flags += "g";
+
+        return new Enumerable(function () {
+            var regex;
+            return new IEnumerator(
+                function () { regex = new RegExp(pattern, flags); },
+                function () {
+                    var match = regex.exec(input);
+                    return (match) ? this.yieldReturn(match) : false;
+                },
+                Functions.Blank);
+        });
+    };
+
+    // Overload:function(start, count)
+    // Overload:function(start, count, step)
+    Enumerable.range = function (start, count, step) {
+        if (step == null) step = 1;
+
+        return new Enumerable(function () {
+            var value;
+            var index = 0;
+
+            return new IEnumerator(
+                function () { value = start - step; },
+                function () {
+                    return (index++ < count)
+                        ? this.yieldReturn(value += step)
+                        : this.yieldBreak();
+                },
+                Functions.Blank);
+        });
+    };
+
+    // Overload:function(start, count)
+    // Overload:function(start, count, step)
+    Enumerable.rangeDown = function (start, count, step) {
+        if (step == null) step = 1;
+
+        return new Enumerable(function () {
+            var value;
+            var index = 0;
+
+            return new IEnumerator(
+                function () { value = start + step; },
+                function () {
+                    return (index++ < count)
+                        ? this.yieldReturn(value -= step)
+                        : this.yieldBreak();
+                },
+                Functions.Blank);
+        });
+    };
+
+    // Overload:function(start, to)
+    // Overload:function(start, to, step)
+    Enumerable.rangeTo = function (start, to, step) {
+        if (step == null) step = 1;
+
+        if (start < to) {
+            return new Enumerable(function () {
+                var value;
+
+                return new IEnumerator(
+                function () { value = start - step; },
+                function () {
+                    var next = value += step;
+                    return (next <= to)
+                        ? this.yieldReturn(next)
+                        : this.yieldBreak();
+                },
+                Functions.Blank);
+            });
+        }
+        else {
+            return new Enumerable(function () {
+                var value;
+
+                return new IEnumerator(
+                function () { value = start + step; },
+                function () {
+                    var next = value -= step;
+                    return (next >= to)
+                        ? this.yieldReturn(next)
+                        : this.yieldBreak();
+                },
+                Functions.Blank);
+            });
+        }
+    };
+
+    // Overload:function(element)
+    // Overload:function(element, count)
+    Enumerable.repeat = function (element, count) {
+        if (count != null) return Enumerable.repeat(element).take(count);
+
+        return new Enumerable(function () {
+            return new IEnumerator(
+                Functions.Blank,
+                function () { return this.yieldReturn(element); },
+                Functions.Blank);
+        });
+    };
+
+    Enumerable.repeatWithFinalize = function (initializer, finalizer) {
+        initializer = Utils.createLambda(initializer);
+        finalizer = Utils.createLambda(finalizer);
+
+        return new Enumerable(function () {
+            var element;
+            return new IEnumerator(
+                function () { element = initializer(); },
+                function () { return this.yieldReturn(element); },
+                function () {
+                    if (element != null) {
+                        finalizer(element);
+                        element = null;
+                    }
+                });
+        });
+    };
+
+    // Overload:function(func)
+    // Overload:function(func, count)
+    Enumerable.generate = function (func, count) {
+        if (count != null) return Enumerable.generate(func).take(count);
+        func = Utils.createLambda(func);
+
+        return new Enumerable(function () {
+            return new IEnumerator(
+                Functions.Blank,
+                function () { return this.yieldReturn(func()); },
+                Functions.Blank);
+        });
+    };
+
+    // Overload:function()
+    // Overload:function(start)
+    // Overload:function(start, step)
+    Enumerable.toInfinity = function (start, step) {
+        if (start == null) start = 0;
+        if (step == null) step = 1;
+
+        return new Enumerable(function () {
+            var value;
+            return new IEnumerator(
+                function () { value = start - step; },
+                function () { return this.yieldReturn(value += step); },
+                Functions.Blank);
+        });
+    };
+
+    // Overload:function()
+    // Overload:function(start)
+    // Overload:function(start, step)
+    Enumerable.toNegativeInfinity = function (start, step) {
+        if (start == null) start = 0;
+        if (step == null) step = 1;
+
+        return new Enumerable(function () {
+            var value;
+            return new IEnumerator(
+                function () { value = start + step; },
+                function () { return this.yieldReturn(value -= step); },
+                Functions.Blank);
+        });
+    };
+
+    Enumerable.unfold = function (seed, func) {
+        func = Utils.createLambda(func);
+
+        return new Enumerable(function () {
+            var isFirst = true;
+            var value;
+            return new IEnumerator(
+                Functions.Blank,
+                function () {
+                    if (isFirst) {
+                        isFirst = false;
+                        value = seed;
+                        return this.yieldReturn(value);
+                    }
+                    value = func(value);
+                    return this.yieldReturn(value);
+                },
+                Functions.Blank);
+        });
+    };
+
+    Enumerable.defer = function (enumerableFactory) {
+
+        return new Enumerable(function () {
+            var enumerator;
+
+            return new IEnumerator(
+                function () { enumerator = Enumerable.from(enumerableFactory()).getEnumerator(); },
+                function () {
+                    return (enumerator.moveNext())
+                        ? this.yieldReturn(enumerator.current())
+                        : this.yieldBreak();
+                },
+                function () {
+                    Utils.dispose(enumerator);
+                });
+        });
+    };
+
+    // Extension Methods
+
+    /* Projection and Filtering Methods */
+
+    // Overload:function(func)
+    // Overload:function(func, resultSelector<element>)
+    // Overload:function(func, resultSelector<element, nestLevel>)
+    Enumerable.prototype.traverseBreadthFirst = function (func, resultSelector) {
+        var source = this;
+        func = Utils.createLambda(func);
+        resultSelector = Utils.createLambda(resultSelector);
+
+        return new Enumerable(function () {
+            var enumerator;
+            var nestLevel = 0;
+            var buffer = [];
+
+            return new IEnumerator(
+                function () { enumerator = source.getEnumerator(); },
+                function () {
+                    while (true) {
+                        if (enumerator.moveNext()) {
+                            buffer.push(enumerator.current());
+                            return this.yieldReturn(resultSelector(enumerator.current(), nestLevel));
+                        }
+
+                        var next = Enumerable.from(buffer).selectMany(function (x) { return func(x); });
+                        if (!next.any()) {
+                            return false;
+                        }
+                        else {
+                            nestLevel++;
+                            buffer = [];
+                            Utils.dispose(enumerator);
+                            enumerator = next.getEnumerator();
+                        }
+                    }
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    // Overload:function(func)
+    // Overload:function(func, resultSelector<element>)
+    // Overload:function(func, resultSelector<element, nestLevel>)
+    Enumerable.prototype.traverseDepthFirst = function (func, resultSelector) {
+        var source = this;
+        func = Utils.createLambda(func);
+        resultSelector = Utils.createLambda(resultSelector);
+
+        return new Enumerable(function () {
+            var enumeratorStack = [];
+            var enumerator;
+
+            return new IEnumerator(
+                function () { enumerator = source.getEnumerator(); },
+                function () {
+                    while (true) {
+                        if (enumerator.moveNext()) {
+                            var value = resultSelector(enumerator.current(), enumeratorStack.length);
+                            enumeratorStack.push(enumerator);
+                            enumerator = Enumerable.from(func(enumerator.current())).getEnumerator();
+                            return this.yieldReturn(value);
+                        }
+
+                        if (enumeratorStack.length <= 0) return false;
+                        Utils.dispose(enumerator);
+                        enumerator = enumeratorStack.pop();
+                    }
+                },
+                function () {
+                    try {
+                        Utils.dispose(enumerator);
+                    }
+                    finally {
+                        Enumerable.from(enumeratorStack).forEach(function (s) { s.dispose(); });
+                    }
+                });
+        });
+    };
+
+    Enumerable.prototype.flatten = function () {
+        var source = this;
+
+        return new Enumerable(function () {
+            var enumerator;
+            var middleEnumerator = null;
+
+            return new IEnumerator(
+                function () { enumerator = source.getEnumerator(); },
+                function () {
+                    while (true) {
+                        if (middleEnumerator != null) {
+                            if (middleEnumerator.moveNext()) {
+                                return this.yieldReturn(middleEnumerator.current());
+                            }
+                            else {
+                                middleEnumerator = null;
+                            }
+                        }
+
+                        if (enumerator.moveNext()) {
+                            if (enumerator.current() instanceof Array) {
+                                Utils.dispose(middleEnumerator);
+                                middleEnumerator = Enumerable.from(enumerator.current())
+                                    .selectMany(Functions.Identity)
+                                    .flatten()
+                                    .getEnumerator();
+                                continue;
+                            }
+                            else {
+                                return this.yieldReturn(enumerator.current());
+                            }
+                        }
+
+                        return false;
+                    }
+                },
+                function () {
+                    try {
+                        Utils.dispose(enumerator);
+                    }
+                    finally {
+                        Utils.dispose(middleEnumerator);
+                    }
+                });
+        });
+    };
+
+    Enumerable.prototype.pairwise = function (selector) {
+        var source = this;
+        selector = Utils.createLambda(selector);
+
+        return new Enumerable(function () {
+            var enumerator;
+
+            return new IEnumerator(
+                function () {
+                    enumerator = source.getEnumerator();
+                    enumerator.moveNext();
+                },
+                function () {
+                    var prev = enumerator.current();
+                    return (enumerator.moveNext())
+                        ? this.yieldReturn(selector(prev, enumerator.current()))
+                        : false;
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    // Overload:function(func)
+    // Overload:function(seed,func<value,element>)
+    Enumerable.prototype.scan = function (seed, func) {
+        var isUseSeed;
+        if (func == null) {
+            func = Utils.createLambda(seed); // arguments[0]
+            isUseSeed = false;
+        } else {
+            func = Utils.createLambda(func);
+            isUseSeed = true;
+        }
+        var source = this;
+
+        return new Enumerable(function () {
+            var enumerator;
+            var value;
+            var isFirst = true;
+
+            return new IEnumerator(
+                function () { enumerator = source.getEnumerator(); },
+                function () {
+                    if (isFirst) {
+                        isFirst = false;
+                        if (!isUseSeed) {
+                            if (enumerator.moveNext()) {
+                                return this.yieldReturn(value = enumerator.current());
+                            }
+                        }
+                        else {
+                            return this.yieldReturn(value = seed);
+                        }
+                    }
+
+                    return (enumerator.moveNext())
+                        ? this.yieldReturn(value = func(value, enumerator.current()))
+                        : false;
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    // Overload:function(selector<element>)
+    // Overload:function(selector<element,index>)
+    Enumerable.prototype.select = function (selector) {
+        selector = Utils.createLambda(selector);
+
+        if (selector.length <= 1) {
+            return new WhereSelectEnumerable(this, null, selector);
+        }
+        else {
+            var source = this;
+
+            return new Enumerable(function () {
+                var enumerator;
+                var index = 0;
+
+                return new IEnumerator(
+                    function () { enumerator = source.getEnumerator(); },
+                    function () {
+                        return (enumerator.moveNext())
+                            ? this.yieldReturn(selector(enumerator.current(), index++))
+                            : false;
+                    },
+                    function () { Utils.dispose(enumerator); });
+            });
+        }
+    };
+
+    // Overload:function(collectionSelector<element>)
+    // Overload:function(collectionSelector<element,index>)
+    // Overload:function(collectionSelector<element>,resultSelector)
+    // Overload:function(collectionSelector<element,index>,resultSelector)
+    Enumerable.prototype.selectMany = function (collectionSelector, resultSelector) {
+        var source = this;
+        collectionSelector = Utils.createLambda(collectionSelector);
+        if (resultSelector == null) resultSelector = function (a, b) { return b; };
+        resultSelector = Utils.createLambda(resultSelector);
+
+        return new Enumerable(function () {
+            var enumerator;
+            var middleEnumerator = undefined;
+            var index = 0;
+
+            return new IEnumerator(
+                function () { enumerator = source.getEnumerator(); },
+                function () {
+                    if (middleEnumerator === undefined) {
+                        if (!enumerator.moveNext()) return false;
+                    }
+                    do {
+                        if (middleEnumerator == null) {
+                            var middleSeq = collectionSelector(enumerator.current(), index++);
+                            middleEnumerator = Enumerable.from(middleSeq).getEnumerator();
+                        }
+                        if (middleEnumerator.moveNext()) {
+                            return this.yieldReturn(resultSelector(enumerator.current(), middleEnumerator.current()));
+                        }
+                        Utils.dispose(middleEnumerator);
+                        middleEnumerator = null;
+                    } while (enumerator.moveNext());
+                    return false;
+                },
+                function () {
+                    try {
+                        Utils.dispose(enumerator);
+                    }
+                    finally {
+                        Utils.dispose(middleEnumerator);
+                    }
+                });
+        });
+    };
+
+    // Overload:function(predicate<element>)
+    // Overload:function(predicate<element,index>)
+    Enumerable.prototype.where = function (predicate) {
+        predicate = Utils.createLambda(predicate);
+
+        if (predicate.length <= 1) {
+            return new WhereEnumerable(this, predicate);
+        }
+        else {
+            var source = this;
+
+            return new Enumerable(function () {
+                var enumerator;
+                var index = 0;
+
+                return new IEnumerator(
+                    function () { enumerator = source.getEnumerator(); },
+                    function () {
+                        while (enumerator.moveNext()) {
+                            if (predicate(enumerator.current(), index++)) {
+                                return this.yieldReturn(enumerator.current());
+                            }
+                        }
+                        return false;
+                    },
+                    function () { Utils.dispose(enumerator); });
+            });
+        }
+    };
+
+
+    // Overload:function(selector<element>)
+    // Overload:function(selector<element,index>)
+    Enumerable.prototype.choose = function (selector) {
+        selector = Utils.createLambda(selector);
+        var source = this;
+
+        return new Enumerable(function () {
+            var enumerator;
+            var index = 0;
+
+            return new IEnumerator(
+                function () { enumerator = source.getEnumerator(); },
+                function () {
+                    while (enumerator.moveNext()) {
+                        var result = selector(enumerator.current(), index++);
+                        if (result != null) {
+                            return this.yieldReturn(result);
+                        }
+                    }
+                    return this.yieldBreak();
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    Enumerable.prototype.ofType = function (type) {
+        var typeName;
+        switch (type) {
+            case Number:
+                typeName = Types.Number;
+                break;
+            case String:
+                typeName = Types.String;
+                break;
+            case Boolean:
+                typeName = Types.Boolean;
+                break;
+            case Function:
+                typeName = Types.Function;
+                break;
+            default:
+                typeName = null;
+                break;
+        }
+        return (typeName === null)
+            ? this.where(function (x) { return x instanceof type; })
+            : this.where(function (x) { return typeof x === typeName; });
+    };
+
+    // mutiple arguments, last one is selector, others are enumerable
+    Enumerable.prototype.zip = function () {
+        var args = arguments;
+        var selector = Utils.createLambda(arguments[arguments.length - 1]);
+
+        var source = this;
+        // optimized case:argument is 2
+        if (arguments.length == 2) {
+            var second = arguments[0];
+
+            return new Enumerable(function () {
+                var firstEnumerator;
+                var secondEnumerator;
+                var index = 0;
+
+                return new IEnumerator(
+                function () {
+                    firstEnumerator = source.getEnumerator();
+                    secondEnumerator = Enumerable.from(second).getEnumerator();
+                },
+                function () {
+                    if (firstEnumerator.moveNext() && secondEnumerator.moveNext()) {
+                        return this.yieldReturn(selector(firstEnumerator.current(), secondEnumerator.current(), index++));
+                    }
+                    return false;
+                },
+                function () {
+                    try {
+                        Utils.dispose(firstEnumerator);
+                    } finally {
+                        Utils.dispose(secondEnumerator);
+                    }
+                });
+            });
+        }
+        else {
+            return new Enumerable(function () {
+                var enumerators;
+                var index = 0;
+
+                return new IEnumerator(
+                function () {
+                    var array = Enumerable.make(source)
+                        .concat(Enumerable.from(args).takeExceptLast().select(Enumerable.from))
+                        .select(function (x) { return x.getEnumerator() })
+                        .toArray();
+                    enumerators = Enumerable.from(array);
+                },
+                function () {
+                    if (enumerators.all(function (x) { return x.moveNext() })) {
+                        var array = enumerators
+                            .select(function (x) { return x.current() })
+                            .toArray();
+                        array.push(index++);
+                        return this.yieldReturn(selector.apply(null, array));
+                    }
+                    else {
+                        return this.yieldBreak();
+                    }
+                },
+                function () {
+                    Enumerable.from(enumerators).forEach(Utils.dispose);
+                });
+            });
+        }
+    };
+
+    // mutiple arguments
+    Enumerable.prototype.merge = function () {
+        var args = arguments;
+        var source = this;
+
+        return new Enumerable(function () {
+            var enumerators;
+            var index = -1;
+
+            return new IEnumerator(
+                function () {
+                    enumerators = Enumerable.make(source)
+                        .concat(Enumerable.from(args).select(Enumerable.from))
+                        .select(function (x) { return x.getEnumerator() })
+                        .toArray();
+                },
+                function () {
+                    while (enumerators.length > 0) {
+                        index = (index >= enumerators.length - 1) ? 0 : index + 1;
+                        var enumerator = enumerators[index];
+
+                        if (enumerator.moveNext()) {
+                            return this.yieldReturn(enumerator.current());
+                        }
+                        else {
+                            enumerator.dispose();
+                            enumerators.splice(index--, 1);
+                        }
+                    }
+                    return this.yieldBreak();
+                },
+                function () {
+                    Enumerable.from(enumerators).forEach(Utils.dispose);
+                });
+        });
+    };
+
+    /* Join Methods */
+
+    // Overload:function (inner, outerKeySelector, innerKeySelector, resultSelector)
+    // Overload:function (inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector)
+    Enumerable.prototype.join = function (inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector) {
+        outerKeySelector = Utils.createLambda(outerKeySelector);
+        innerKeySelector = Utils.createLambda(innerKeySelector);
+        resultSelector = Utils.createLambda(resultSelector);
+        compareSelector = Utils.createLambda(compareSelector);
+        var source = this;
+
+        return new Enumerable(function () {
+            var outerEnumerator;
+            var lookup;
+            var innerElements = null;
+            var innerCount = 0;
+
+            return new IEnumerator(
+                function () {
+                    outerEnumerator = source.getEnumerator();
+                    lookup = Enumerable.from(inner).toLookup(innerKeySelector, Functions.Identity, compareSelector);
+                },
+                function () {
+                    while (true) {
+                        if (innerElements != null) {
+                            var innerElement = innerElements[innerCount++];
+                            if (innerElement !== undefined) {
+                                return this.yieldReturn(resultSelector(outerEnumerator.current(), innerElement));
+                            }
+
+                            innerElement = null;
+                            innerCount = 0;
+                        }
+
+                        if (outerEnumerator.moveNext()) {
+                            var key = outerKeySelector(outerEnumerator.current());
+                            innerElements = lookup.get(key).toArray();
+                        } else {
+                            return false;
+                        }
+                    }
+                },
+                function () { Utils.dispose(outerEnumerator); });
+        });
+    };
+
+    // Overload:function (inner, outerKeySelector, innerKeySelector, resultSelector)
+    // Overload:function (inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector)
+    Enumerable.prototype.groupJoin = function (inner, outerKeySelector, innerKeySelector, resultSelector, compareSelector) {
+        outerKeySelector = Utils.createLambda(outerKeySelector);
+        innerKeySelector = Utils.createLambda(innerKeySelector);
+        resultSelector = Utils.createLambda(resultSelector);
+        compareSelector = Utils.createLambda(compareSelector);
+        var source = this;
+
+        return new Enumerable(function () {
+            var enumerator = source.getEnumerator();
+            var lookup = null;
+
+            return new IEnumerator(
+                function () {
+                    enumerator = source.getEnumerator();
+                    lookup = Enumerable.from(inner).toLookup(innerKeySelector, Functions.Identity, compareSelector);
+                },
+                function () {
+                    if (enumerator.moveNext()) {
+                        var innerElement = lookup.get(outerKeySelector(enumerator.current()));
+                        return this.yieldReturn(resultSelector(enumerator.current(), innerElement));
+                    }
+                    return false;
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    /* Set Methods */
+
+    Enumerable.prototype.all = function (predicate) {
+        predicate = Utils.createLambda(predicate);
+
+        var result = true;
+        this.forEach(function (x) {
+            if (!predicate(x)) {
+                result = false;
+                return false; // break
+            }
+        });
+        return result;
+    };
+
+    // Overload:function()
+    // Overload:function(predicate)
+    Enumerable.prototype.any = function (predicate) {
+        predicate = Utils.createLambda(predicate);
+
+        var enumerator = this.getEnumerator();
+        try {
+            if (arguments.length == 0) return enumerator.moveNext(); // case:function()
+
+            while (enumerator.moveNext()) // case:function(predicate)
+            {
+                if (predicate(enumerator.current())) return true;
+            }
+            return false;
+        }
+        finally {
+            Utils.dispose(enumerator);
+        }
+    };
+
+    Enumerable.prototype.isEmpty = function () {
+        return !this.any();
+    };
+
+    // multiple arguments
+    Enumerable.prototype.concat = function () {
+        var source = this;
+
+        if (arguments.length == 1) {
+            var second = arguments[0];
+
+            return new Enumerable(function () {
+                var firstEnumerator;
+                var secondEnumerator;
+
+                return new IEnumerator(
+                function () { firstEnumerator = source.getEnumerator(); },
+                function () {
+                    if (secondEnumerator == null) {
+                        if (firstEnumerator.moveNext()) return this.yieldReturn(firstEnumerator.current());
+                        secondEnumerator = Enumerable.from(second).getEnumerator();
+                    }
+                    if (secondEnumerator.moveNext()) return this.yieldReturn(secondEnumerator.current());
+                    return false;
+                },
+                function () {
+                    try {
+                        Utils.dispose(firstEnumerator);
+                    }
+                    finally {
+                        Utils.dispose(secondEnumerator);
+                    }
+                });
+            });
+        }
+        else {
+            var args = arguments;
+
+            return new Enumerable(function () {
+                var enumerators;
+
+                return new IEnumerator(
+                    function () {
+                        enumerators = Enumerable.make(source)
+                            .concat(Enumerable.from(args).select(Enumerable.from))
+                            .select(function (x) { return x.getEnumerator() })
+                            .toArray();
+                    },
+                    function () {
+                        while (enumerators.length > 0) {
+                            var enumerator = enumerators[0];
+
+                            if (enumerator.moveNext()) {
+                                return this.yieldReturn(enumerator.current());
+                            }
+                            else {
+                                enumerator.dispose();
+                                enumerators.splice(0, 1);
+                            }
+                        }
+                        return this.yieldBreak();
+                    },
+                    function () {
+                        Enumerable.from(enumerators).forEach(Utils.dispose);
+                    });
+            });
+        }
+    };
+
+    Enumerable.prototype.insert = function (index, second) {
+        var source = this;
+
+        return new Enumerable(function () {
+            var firstEnumerator;
+            var secondEnumerator;
+            var count = 0;
+            var isEnumerated = false;
+
+            return new IEnumerator(
+                function () {
+                    firstEnumerator = source.getEnumerator();
+                    secondEnumerator = Enumerable.from(second).getEnumerator();
+                },
+                function () {
+                    if (count == index && secondEnumerator.moveNext()) {
+                        isEnumerated = true;
+                        return this.yieldReturn(secondEnumerator.current());
+                    }
+                    if (firstEnumerator.moveNext()) {
+                        count++;
+                        return this.yieldReturn(firstEnumerator.current());
+                    }
+                    if (!isEnumerated && secondEnumerator.moveNext()) {
+                        return this.yieldReturn(secondEnumerator.current());
+                    }
+                    return false;
+                },
+                function () {
+                    try {
+                        Utils.dispose(firstEnumerator);
+                    }
+                    finally {
+                        Utils.dispose(secondEnumerator);
+                    }
+                });
+        });
+    };
+
+    Enumerable.prototype.alternate = function (alternateValueOrSequence) {
+        var source = this;
+
+        return new Enumerable(function () {
+            var buffer;
+            var enumerator;
+            var alternateSequence;
+            var alternateEnumerator;
+
+            return new IEnumerator(
+                function () {
+                    if (alternateValueOrSequence instanceof Array || alternateValueOrSequence.getEnumerator != null) {
+                        alternateSequence = Enumerable.from(Enumerable.from(alternateValueOrSequence).toArray()); // freeze
+                    }
+                    else {
+                        alternateSequence = Enumerable.make(alternateValueOrSequence);
+                    }
+                    enumerator = source.getEnumerator();
+                    if (enumerator.moveNext()) buffer = enumerator.current();
+                },
+                function () {
+                    while (true) {
+                        if (alternateEnumerator != null) {
+                            if (alternateEnumerator.moveNext()) {
+                                return this.yieldReturn(alternateEnumerator.current());
+                            }
+                            else {
+                                alternateEnumerator = null;
+                            }
+                        }
+
+                        if (buffer == null && enumerator.moveNext()) {
+                            buffer = enumerator.current(); // hasNext
+                            alternateEnumerator = alternateSequence.getEnumerator();
+                            continue; // GOTO
+                        }
+                        else if (buffer != null) {
+                            var retVal = buffer;
+                            buffer = null;
+                            return this.yieldReturn(retVal);
+                        }
+
+                        return this.yieldBreak();
+                    }
+                },
+                function () {
+                    try {
+                        Utils.dispose(enumerator);
+                    }
+                    finally {
+                        Utils.dispose(alternateEnumerator);
+                    }
+                });
+        });
+    };
+
+    // Overload:function(value)
+    // Overload:function(value, compareSelector)
+    Enumerable.prototype.contains = function (value, compareSelector) {
+        compareSelector = Utils.createLambda(compareSelector);
+        var enumerator = this.getEnumerator();
+        try {
+            while (enumerator.moveNext()) {
+                if (compareSelector(enumerator.current()) === value) return true;
+            }
+            return false;
+        }
+        finally {
+            Utils.dispose(enumerator);
+        }
+    };
+
+    Enumerable.prototype.defaultIfEmpty = function (defaultValue) {
+        var source = this;
+        if (defaultValue === undefined) defaultValue = null;
+
+        return new Enumerable(function () {
+            var enumerator;
+            var isFirst = true;
+
+            return new IEnumerator(
+                function () { enumerator = source.getEnumerator(); },
+                function () {
+                    if (enumerator.moveNext()) {
+                        isFirst = false;
+                        return this.yieldReturn(enumerator.current());
+                    }
+                    else if (isFirst) {
+                        isFirst = false;
+                        return this.yieldReturn(defaultValue);
+                    }
+                    return false;
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    // Overload:function()
+    // Overload:function(compareSelector)
+    Enumerable.prototype.distinct = function (compareSelector) {
+        return this.except(Enumerable.empty(), compareSelector);
+    };
+
+    Enumerable.prototype.distinctUntilChanged = function (compareSelector) {
+        compareSelector = Utils.createLambda(compareSelector);
+        var source = this;
+
+        return new Enumerable(function () {
+            var enumerator;
+            var compareKey;
+            var initial;
+
+            return new IEnumerator(
+                function () {
+                    enumerator = source.getEnumerator();
+                },
+                function () {
+                    while (enumerator.moveNext()) {
+                        var key = compareSelector(enumerator.current());
+
+                        if (initial) {
+                            initial = false;
+                            compareKey = key;
+                            return this.yieldReturn(enumerator.current());
+                        }
+
+                        if (compareKey === key) {
+                            continue;
+                        }
+
+                        compareKey = key;
+                        return this.yieldReturn(enumerator.current());
+                    }
+                    return this.yieldBreak();
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    // Overload:function(second)
+    // Overload:function(second, compareSelector)
+    Enumerable.prototype.except = function (second, compareSelector) {
+        compareSelector = Utils.createLambda(compareSelector);
+        var source = this;
+
+        return new Enumerable(function () {
+            var enumerator;
+            var keys;
+
+            return new IEnumerator(
+                function () {
+                    enumerator = source.getEnumerator();
+                    keys = new Dictionary(compareSelector);
+                    Enumerable.from(second).forEach(function (key) { keys.add(key); });
+                },
+                function () {
+                    while (enumerator.moveNext()) {
+                        var current = enumerator.current();
+                        if (!keys.contains(current)) {
+                            keys.add(current);
+                            return this.yieldReturn(current);
+                        }
+                    }
+                    return false;
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    // Overload:function(second)
+    // Overload:function(second, compareSelector)
+    Enumerable.prototype.intersect = function (second, compareSelector) {
+        compareSelector = Utils.createLambda(compareSelector);
+        var source = this;
+
+        return new Enumerable(function () {
+            var enumerator;
+            var keys;
+            var outs;
+
+            return new IEnumerator(
+                function () {
+                    enumerator = source.getEnumerator();
+
+                    keys = new Dictionary(compareSelector);
+                    Enumerable.from(second).forEach(function (key) { keys.add(key); });
+                    outs = new Dictionary(compareSelector);
+                },
+                function () {
+                    while (enumerator.moveNext()) {
+                        var current = enumerator.current();
+                        if (!outs.contains(current) && keys.contains(current)) {
+                            outs.add(current);
+                            return this.yieldReturn(current);
+                        }
+                    }
+                    return false;
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    // Overload:function(second)
+    // Overload:function(second, compareSelector)
+    Enumerable.prototype.sequenceEqual = function (second, compareSelector) {
+        compareSelector = Utils.createLambda(compareSelector);
+
+        var firstEnumerator = this.getEnumerator();
+        try {
+            var secondEnumerator = Enumerable.from(second).getEnumerator();
+            try {
+                while (firstEnumerator.moveNext()) {
+                    if (!secondEnumerator.moveNext()
+                    || compareSelector(firstEnumerator.current()) !== compareSelector(secondEnumerator.current())) {
+                        return false;
+                    }
+                }
+
+                if (secondEnumerator.moveNext()) return false;
+                return true;
+            }
+            finally {
+                Utils.dispose(secondEnumerator);
+            }
+        }
+        finally {
+            Utils.dispose(firstEnumerator);
+        }
+    };
+
+    Enumerable.prototype.union = function (second, compareSelector) {
+        compareSelector = Utils.createLambda(compareSelector);
+        var source = this;
+
+        return new Enumerable(function () {
+            var firstEnumerator;
+            var secondEnumerator;
+            var keys;
+
+            return new IEnumerator(
+                function () {
+                    firstEnumerator = source.getEnumerator();
+                    keys = new Dictionary(compareSelector);
+                },
+                function () {
+                    var current;
+                    if (secondEnumerator === undefined) {
+                        while (firstEnumerator.moveNext()) {
+                            current = firstEnumerator.current();
+                            if (!keys.contains(current)) {
+                                keys.add(current);
+                                return this.yieldReturn(current);
+                            }
+                        }
+                        secondEnumerator = Enumerable.from(second).getEnumerator();
+                    }
+                    while (secondEnumerator.moveNext()) {
+                        current = secondEnumerator.current();
+                        if (!keys.contains(current)) {
+                            keys.add(current);
+                            return this.yieldReturn(current);
+                        }
+                    }
+                    return false;
+                },
+                function () {
+                    try {
+                        Utils.dispose(firstEnumerator);
+                    }
+                    finally {
+                        Utils.dispose(secondEnumerator);
+                    }
+                });
+        });
+    };
+
+    /* Ordering Methods */
+
+    Enumerable.prototype.orderBy = function (keySelector) {
+        return new OrderedEnumerable(this, keySelector, false);
+    };
+
+    Enumerable.prototype.orderByDescending = function (keySelector) {
+        return new OrderedEnumerable(this, keySelector, true);
+    };
+
+    Enumerable.prototype.reverse = function () {
+        var source = this;
+
+        return new Enumerable(function () {
+            var buffer;
+            var index;
+
+            return new IEnumerator(
+                function () {
+                    buffer = source.toArray();
+                    index = buffer.length;
+                },
+                function () {
+                    return (index > 0)
+                        ? this.yieldReturn(buffer[--index])
+                        : false;
+                },
+                Functions.Blank);
+        });
+    };
+
+    Enumerable.prototype.shuffle = function () {
+        var source = this;
+
+        return new Enumerable(function () {
+            var buffer;
+
+            return new IEnumerator(
+                function () { buffer = source.toArray(); },
+                function () {
+                    if (buffer.length > 0) {
+                        var i = Math.floor(Math.random() * buffer.length);
+                        return this.yieldReturn(buffer.splice(i, 1)[0]);
+                    }
+                    return false;
+                },
+                Functions.Blank);
+        });
+    };
+
+    Enumerable.prototype.weightedSample = function (weightSelector) {
+        weightSelector = Utils.createLambda(weightSelector);
+        var source = this;
+
+        return new Enumerable(function () {
+            var sortedByBound;
+            var totalWeight = 0;
+
+            return new IEnumerator(
+                function () {
+                    sortedByBound = source
+                        .choose(function (x) {
+                            var weight = weightSelector(x);
+                            if (weight <= 0) return null; // ignore 0
+
+                            totalWeight += weight;
+                            return { value: x, bound: totalWeight };
+                        })
+                        .toArray();
+                },
+                function () {
+                    if (sortedByBound.length > 0) {
+                        var draw = Math.floor(Math.random() * totalWeight) + 1;
+
+                        var lower = -1;
+                        var upper = sortedByBound.length;
+                        while (upper - lower > 1) {
+                            var index = Math.floor((lower + upper) / 2);
+                            if (sortedByBound[index].bound >= draw) {
+                                upper = index;
+                            }
+                            else {
+                                lower = index;
+                            }
+                        }
+
+                        return this.yieldReturn(sortedByBound[upper].value);
+                    }
+
+                    return this.yieldBreak();
+                },
+                Functions.Blank);
+        });
+    };
+
+    /* Grouping Methods */
+
+    // Overload:function(keySelector)
+    // Overload:function(keySelector,elementSelector)
+    // Overload:function(keySelector,elementSelector,resultSelector)
+    // Overload:function(keySelector,elementSelector,resultSelector,compareSelector)
+    Enumerable.prototype.groupBy = function (keySelector, elementSelector, resultSelector, compareSelector) {
+        var source = this;
+        keySelector = Utils.createLambda(keySelector);
+        elementSelector = Utils.createLambda(elementSelector);
+        if (resultSelector != null) resultSelector = Utils.createLambda(resultSelector);
+        compareSelector = Utils.createLambda(compareSelector);
+
+        return new Enumerable(function () {
+            var enumerator;
+
+            return new IEnumerator(
+                function () {
+                    enumerator = source.toLookup(keySelector, elementSelector, compareSelector)
+                        .toEnumerable()
+                        .getEnumerator();
+                },
+                function () {
+                    while (enumerator.moveNext()) {
+                        return (resultSelector == null)
+                            ? this.yieldReturn(enumerator.current())
+                            : this.yieldReturn(resultSelector(enumerator.current().key(), enumerator.current()));
+                    }
+                    return false;
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    // Overload:function(keySelector)
+    // Overload:function(keySelector,elementSelector)
+    // Overload:function(keySelector,elementSelector,resultSelector)
+    // Overload:function(keySelector,elementSelector,resultSelector,compareSelector)
+    Enumerable.prototype.partitionBy = function (keySelector, elementSelector, resultSelector, compareSelector) {
+
+        var source = this;
+        keySelector = Utils.createLambda(keySelector);
+        elementSelector = Utils.createLambda(elementSelector);
+        compareSelector = Utils.createLambda(compareSelector);
+        var hasResultSelector;
+        if (resultSelector == null) {
+            hasResultSelector = false;
+            resultSelector = function (key, group) { return new Grouping(key, group); };
+        }
+        else {
+            hasResultSelector = true;
+            resultSelector = Utils.createLambda(resultSelector);
+        }
+
+        return new Enumerable(function () {
+            var enumerator;
+            var key;
+            var compareKey;
+            var group = [];
+
+            return new IEnumerator(
+                function () {
+                    enumerator = source.getEnumerator();
+                    if (enumerator.moveNext()) {
+                        key = keySelector(enumerator.current());
+                        compareKey = compareSelector(key);
+                        group.push(elementSelector(enumerator.current()));
+                    }
+                },
+                function () {
+                    var hasNext;
+                    while ((hasNext = enumerator.moveNext()) == true) {
+                        if (compareKey === compareSelector(keySelector(enumerator.current()))) {
+                            group.push(elementSelector(enumerator.current()));
+                        }
+                        else break;
+                    }
+
+                    if (group.length > 0) {
+                        var result = (hasResultSelector)
+                            ? resultSelector(key, Enumerable.from(group))
+                            : resultSelector(key, group);
+                        if (hasNext) {
+                            key = keySelector(enumerator.current());
+                            compareKey = compareSelector(key);
+                            group = [elementSelector(enumerator.current())];
+                        }
+                        else group = [];
+
+                        return this.yieldReturn(result);
+                    }
+
+                    return false;
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    Enumerable.prototype.buffer = function (count) {
+        var source = this;
+
+        return new Enumerable(function () {
+            var enumerator;
+
+            return new IEnumerator(
+                function () { enumerator = source.getEnumerator(); },
+                function () {
+                    var array = [];
+                    var index = 0;
+                    while (enumerator.moveNext()) {
+                        array.push(enumerator.current());
+                        if (++index >= count) return this.yieldReturn(array);
+                    }
+                    if (array.length > 0) return this.yieldReturn(array);
+                    return false;
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    /* Aggregate Methods */
+
+    // Overload:function(func)
+    // Overload:function(seed,func)
+    // Overload:function(seed,func,resultSelector)
+    Enumerable.prototype.aggregate = function (seed, func, resultSelector) {
+        resultSelector = Utils.createLambda(resultSelector);
+        return resultSelector(this.scan(seed, func, resultSelector).last());
+    };
+
+    // Overload:function()
+    // Overload:function(selector)
+    Enumerable.prototype.average = function (selector) {
+        selector = Utils.createLambda(selector);
+
+        var sum = 0;
+        var count = 0;
+        this.forEach(function (x) {
+            sum += selector(x);
+            ++count;
+        });
+
+        return sum / count;
+    };
+
+    // Overload:function()
+    // Overload:function(predicate)
+    Enumerable.prototype.count = function (predicate) {
+        predicate = (predicate == null) ? Functions.True : Utils.createLambda(predicate);
+
+        var count = 0;
+        this.forEach(function (x, i) {
+            if (predicate(x, i))++count;
+        });
+        return count;
+    };
+
+    // Overload:function()
+    // Overload:function(selector)
+    Enumerable.prototype.max = function (selector) {
+        if (selector == null) selector = Functions.Identity;
+        return this.select(selector).aggregate(function (a, b) { return (a > b) ? a : b; });
+    };
+
+    // Overload:function()
+    // Overload:function(selector)
+    Enumerable.prototype.min = function (selector) {
+        if (selector == null) selector = Functions.Identity;
+        return this.select(selector).aggregate(function (a, b) { return (a < b) ? a : b; });
+    };
+
+    Enumerable.prototype.maxBy = function (keySelector) {
+        keySelector = Utils.createLambda(keySelector);
+        return this.aggregate(function (a, b) { return (keySelector(a) > keySelector(b)) ? a : b; });
+    };
+
+    Enumerable.prototype.minBy = function (keySelector) {
+        keySelector = Utils.createLambda(keySelector);
+        return this.aggregate(function (a, b) { return (keySelector(a) < keySelector(b)) ? a : b; });
+    };
+
+    // Overload:function()
+    // Overload:function(selector)
+    Enumerable.prototype.sum = function (selector) {
+        if (selector == null) selector = Functions.Identity;
+        return this.select(selector).aggregate(0, function (a, b) { return a + b; });
+    };
+
+    /* Paging Methods */
+
+    Enumerable.prototype.elementAt = function (index) {
+        var value;
+        var found = false;
+        this.forEach(function (x, i) {
+            if (i == index) {
+                value = x;
+                found = true;
+                return false;
+            }
+        });
+
+        if (!found) throw new Error("index is less than 0 or greater than or equal to the number of elements in source.");
+        return value;
+    };
+
+    Enumerable.prototype.elementAtOrDefault = function (index, defaultValue) {
+        if (defaultValue === undefined) defaultValue = null;
+        var value;
+        var found = false;
+        this.forEach(function (x, i) {
+            if (i == index) {
+                value = x;
+                found = true;
+                return false;
+            }
+        });
+
+        return (!found) ? defaultValue : value;
+    };
+
+    // Overload:function()
+    // Overload:function(predicate)
+    Enumerable.prototype.first = function (predicate) {
+        if (predicate != null) return this.where(predicate).first();
+
+        var value;
+        var found = false;
+        this.forEach(function (x) {
+            value = x;
+            found = true;
+            return false;
+        });
+
+        if (!found) throw new Error("first:No element satisfies the condition.");
+        return value;
+    };
+
+    Enumerable.prototype.firstOrDefault = function (predicate, defaultValue) {
+        if (defaultValue === undefined) defaultValue = null;
+        if (predicate != null) return this.where(predicate).firstOrDefault(null, defaultValue);
+
+        var value;
+        var found = false;
+        this.forEach(function (x) {
+            value = x;
+            found = true;
+            return false;
+        });
+        return (!found) ? defaultValue : value;
+    };
+
+    // Overload:function()
+    // Overload:function(predicate)
+    Enumerable.prototype.last = function (predicate) {
+        if (predicate != null) return this.where(predicate).last();
+
+        var value;
+        var found = false;
+        this.forEach(function (x) {
+            found = true;
+            value = x;
+        });
+
+        if (!found) throw new Error("last:No element satisfies the condition.");
+        return value;
+    };
+
+    // Overload:function(defaultValue)
+    // Overload:function(defaultValue,predicate)
+    Enumerable.prototype.lastOrDefault = function (predicate, defaultValue) {
+        if (defaultValue === undefined) defaultValue = null;
+        if (predicate != null) return this.where(predicate).lastOrDefault(null, defaultValue);
+
+        var value;
+        var found = false;
+        this.forEach(function (x) {
+            found = true;
+            value = x;
+        });
+        return (!found) ? defaultValue : value;
+    };
+
+    // Overload:function()
+    // Overload:function(predicate)
+    Enumerable.prototype.single = function (predicate) {
+        if (predicate != null) return this.where(predicate).single();
+
+        var value;
+        var found = false;
+        this.forEach(function (x) {
+            if (!found) {
+                found = true;
+                value = x;
+            } else throw new Error("single:sequence contains more than one element.");
+        });
+
+        if (!found) throw new Error("single:No element satisfies the condition.");
+        return value;
+    };
+
+    // Overload:function(defaultValue)
+    // Overload:function(defaultValue,predicate)
+    Enumerable.prototype.singleOrDefault = function (predicate, defaultValue) {
+        if (defaultValue === undefined) defaultValue = null;
+        if (predicate != null) return this.where(predicate).singleOrDefault(null, defaultValue);
+
+        var value;
+        var found = false;
+        this.forEach(function (x) {
+            if (!found) {
+                found = true;
+                value = x;
+            } else throw new Error("single:sequence contains more than one element.");
+        });
+
+        return (!found) ? defaultValue : value;
+    };
+
+    Enumerable.prototype.skip = function (count) {
+        var source = this;
+
+        return new Enumerable(function () {
+            var enumerator;
+            var index = 0;
+
+            return new IEnumerator(
+                function () {
+                    enumerator = source.getEnumerator();
+                    while (index++ < count && enumerator.moveNext()) {
+                    }
+                    ;
+                },
+                function () {
+                    return (enumerator.moveNext())
+                        ? this.yieldReturn(enumerator.current())
+                        : false;
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    // Overload:function(predicate<element>)
+    // Overload:function(predicate<element,index>)
+    Enumerable.prototype.skipWhile = function (predicate) {
+        predicate = Utils.createLambda(predicate);
+        var source = this;
+
+        return new Enumerable(function () {
+            var enumerator;
+            var index = 0;
+            var isSkipEnd = false;
+
+            return new IEnumerator(
+                function () { enumerator = source.getEnumerator(); },
+                function () {
+                    while (!isSkipEnd) {
+                        if (enumerator.moveNext()) {
+                            if (!predicate(enumerator.current(), index++)) {
+                                isSkipEnd = true;
+                                return this.yieldReturn(enumerator.current());
+                            }
+                            continue;
+                        } else return false;
+                    }
+
+                    return (enumerator.moveNext())
+                        ? this.yieldReturn(enumerator.current())
+                        : false;
+
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    Enumerable.prototype.take = function (count) {
+        var source = this;
+
+        return new Enumerable(function () {
+            var enumerator;
+            var index = 0;
+
+            return new IEnumerator(
+                function () { enumerator = source.getEnumerator(); },
+                function () {
+                    return (index++ < count && enumerator.moveNext())
+                        ? this.yieldReturn(enumerator.current())
+                        : false;
+                },
+                function () { Utils.dispose(enumerator); }
+            );
+        });
+    };
+
+    // Overload:function(predicate<element>)
+    // Overload:function(predicate<element,index>)
+    Enumerable.prototype.takeWhile = function (predicate) {
+        predicate = Utils.createLambda(predicate);
+        var source = this;
+
+        return new Enumerable(function () {
+            var enumerator;
+            var index = 0;
+
+            return new IEnumerator(
+                function () { enumerator = source.getEnumerator(); },
+                function () {
+                    return (enumerator.moveNext() && predicate(enumerator.current(), index++))
+                        ? this.yieldReturn(enumerator.current())
+                        : false;
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    // Overload:function()
+    // Overload:function(count)
+    Enumerable.prototype.takeExceptLast = function (count) {
+        if (count == null) count = 1;
+        var source = this;
+
+        return new Enumerable(function () {
+            if (count <= 0) return source.getEnumerator(); // do nothing
+
+            var enumerator;
+            var q = [];
+
+            return new IEnumerator(
+                function () { enumerator = source.getEnumerator(); },
+                function () {
+                    while (enumerator.moveNext()) {
+                        if (q.length == count) {
+                            q.push(enumerator.current());
+                            return this.yieldReturn(q.shift());
+                        }
+                        q.push(enumerator.current());
+                    }
+                    return false;
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    Enumerable.prototype.takeFromLast = function (count) {
+        if (count <= 0 || count == null) return Enumerable.empty();
+        var source = this;
+
+        return new Enumerable(function () {
+            var sourceEnumerator;
+            var enumerator;
+            var q = [];
+
+            return new IEnumerator(
+                function () { sourceEnumerator = source.getEnumerator(); },
+                function () {
+                    while (sourceEnumerator.moveNext()) {
+                        if (q.length == count) q.shift();
+                        q.push(sourceEnumerator.current());
+                    }
+                    if (enumerator == null) {
+                        enumerator = Enumerable.from(q).getEnumerator();
+                    }
+                    return (enumerator.moveNext())
+                        ? this.yieldReturn(enumerator.current())
+                        : false;
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    // Overload:function(item)
+    // Overload:function(predicate)
+    Enumerable.prototype.indexOf = function (item) {
+        var found = null;
+
+        // item as predicate
+        if (typeof (item) === Types.Function) {
+            this.forEach(function (x, i) {
+                if (item(x, i)) {
+                    found = i;
+                    return false;
+                }
+            });
+        }
+        else {
+            this.forEach(function (x, i) {
+                if (x === item) {
+                    found = i;
+                    return false;
+                }
+            });
+        }
+
+        return (found !== null) ? found : -1;
+    };
+
+    // Overload:function(item)
+    // Overload:function(predicate)
+    Enumerable.prototype.lastIndexOf = function (item) {
+        var result = -1;
+
+        // item as predicate
+        if (typeof (item) === Types.Function) {
+            this.forEach(function (x, i) {
+                if (item(x, i)) result = i;
+            });
+        }
+        else {
+            this.forEach(function (x, i) {
+                if (x === item) result = i;
+            });
+        }
+
+        return result;
+    };
+
+    /* Convert Methods */
+
+    Enumerable.prototype.asEnumerable = function () {
+        return Enumerable.from(this);
+    };
+
+    Enumerable.prototype.toArray = function () {
+        var array = [];
+        this.forEach(function (x) { array.push(x); });
+        return array;
+    };
+
+    // Overload:function(keySelector)
+    // Overload:function(keySelector, elementSelector)
+    // Overload:function(keySelector, elementSelector, compareSelector)
+    Enumerable.prototype.toLookup = function (keySelector, elementSelector, compareSelector) {
+        keySelector = Utils.createLambda(keySelector);
+        elementSelector = Utils.createLambda(elementSelector);
+        compareSelector = Utils.createLambda(compareSelector);
+
+        var dict = new Dictionary(compareSelector);
+        this.forEach(function (x) {
+            var key = keySelector(x);
+            var element = elementSelector(x);
+
+            var array = dict.get(key);
+            if (array !== undefined) array.push(element);
+            else dict.add(key, [element]);
+        });
+        return new Lookup(dict);
+    };
+
+    Enumerable.prototype.toObject = function (keySelector, elementSelector) {
+        keySelector = Utils.createLambda(keySelector);
+        elementSelector = Utils.createLambda(elementSelector);
+
+        var obj = {};
+        this.forEach(function (x) {
+            obj[keySelector(x)] = elementSelector(x);
+        });
+        return obj;
+    };
+
+    // Overload:function(keySelector, elementSelector)
+    // Overload:function(keySelector, elementSelector, compareSelector)
+    Enumerable.prototype.toDictionary = function (keySelector, elementSelector, compareSelector) {
+        keySelector = Utils.createLambda(keySelector);
+        elementSelector = Utils.createLambda(elementSelector);
+        compareSelector = Utils.createLambda(compareSelector);
+
+        var dict = new Dictionary(compareSelector);
+        this.forEach(function (x) {
+            dict.add(keySelector(x), elementSelector(x));
+        });
+        return dict;
+    };
+
+    // Overload:function()
+    // Overload:function(replacer)
+    // Overload:function(replacer, space)
+    Enumerable.prototype.toJSONString = function (replacer, space) {
+        if (typeof JSON === Types.Undefined || JSON.stringify == null) {
+            throw new Error("toJSONString can't find JSON.stringify. This works native JSON support Browser or include json2.js");
+        }
+        return JSON.stringify(this.toArray(), replacer, space);
+    };
+
+    // Overload:function()
+    // Overload:function(separator)
+    // Overload:function(separator,selector)
+    Enumerable.prototype.toJoinedString = function (separator, selector) {
+        if (separator == null) separator = "";
+        if (selector == null) selector = Functions.Identity;
+
+        return this.select(selector).toArray().join(separator);
+    };
+
+
+    /* Action Methods */
+
+    // Overload:function(action<element>)
+    // Overload:function(action<element,index>)
+    Enumerable.prototype.doAction = function (action) {
+        var source = this;
+        action = Utils.createLambda(action);
+
+        return new Enumerable(function () {
+            var enumerator;
+            var index = 0;
+
+            return new IEnumerator(
+                function () { enumerator = source.getEnumerator(); },
+                function () {
+                    if (enumerator.moveNext()) {
+                        action(enumerator.current(), index++);
+                        return this.yieldReturn(enumerator.current());
+                    }
+                    return false;
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    // Overload:function(action<element>)
+    // Overload:function(action<element,index>)
+    // Overload:function(func<element,bool>)
+    // Overload:function(func<element,index,bool>)
+    Enumerable.prototype.forEach = function (action) {
+        action = Utils.createLambda(action);
+
+        var index = 0;
+        var enumerator = this.getEnumerator();
+        try {
+            while (enumerator.moveNext()) {
+                if (action(enumerator.current(), index++) === false) break;
+            }
+        } finally {
+            Utils.dispose(enumerator);
+        }
+    };
+
+    // Overload:function()
+    // Overload:function(separator)
+    // Overload:function(separator,selector)
+    Enumerable.prototype.write = function (separator, selector) {
+        if (separator == null) separator = "";
+        selector = Utils.createLambda(selector);
+
+        var isFirst = true;
+        this.forEach(function (item) {
+            if (isFirst) isFirst = false;
+            else document.write(separator);
+            document.write(selector(item));
+        });
+    };
+
+    // Overload:function()
+    // Overload:function(selector)
+    Enumerable.prototype.writeLine = function (selector) {
+        selector = Utils.createLambda(selector);
+
+        this.forEach(function (item) {
+            document.writeln(selector(item) + "<br />");
+        });
+    };
+
+    Enumerable.prototype.force = function () {
+        var enumerator = this.getEnumerator();
+
+        try {
+            while (enumerator.moveNext()) {
+            }
+        }
+        finally {
+            Utils.dispose(enumerator);
+        }
+    };
+
+    /* Functional Methods */
+
+    Enumerable.prototype.letBind = function (func) {
+        func = Utils.createLambda(func);
+        var source = this;
+
+        return new Enumerable(function () {
+            var enumerator;
+
+            return new IEnumerator(
+                function () {
+                    enumerator = Enumerable.from(func(source)).getEnumerator();
+                },
+                function () {
+                    return (enumerator.moveNext())
+                        ? this.yieldReturn(enumerator.current())
+                        : false;
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    Enumerable.prototype.share = function () {
+        var source = this;
+        var sharedEnumerator;
+        var disposed = false;
+
+        return new DisposableEnumerable(function () {
+            return new IEnumerator(
+                function () {
+                    if (sharedEnumerator == null) {
+                        sharedEnumerator = source.getEnumerator();
+                    }
+                },
+                function () {
+                    if (disposed) throw new Error("enumerator is disposed");
+
+                    return (sharedEnumerator.moveNext())
+                        ? this.yieldReturn(sharedEnumerator.current())
+                        : false;
+                },
+                Functions.Blank
+            );
+        }, function () {
+            disposed = true;
+            Utils.dispose(sharedEnumerator);
+        });
+    };
+
+    Enumerable.prototype.memoize = function () {
+        var source = this;
+        var cache;
+        var enumerator;
+        var disposed = false;
+
+        return new DisposableEnumerable(function () {
+            var index = -1;
+
+            return new IEnumerator(
+                function () {
+                    if (enumerator == null) {
+                        enumerator = source.getEnumerator();
+                        cache = [];
+                    }
+                },
+                function () {
+                    if (disposed) throw new Error("enumerator is disposed");
+
+                    index++;
+                    if (cache.length <= index) {
+                        return (enumerator.moveNext())
+                            ? this.yieldReturn(cache[index] = enumerator.current())
+                            : false;
+                    }
+
+                    return this.yieldReturn(cache[index]);
+                },
+                Functions.Blank
+            );
+        }, function () {
+            disposed = true;
+            Utils.dispose(enumerator);
+            cache = null;
+        });
+    };
+
+    /* Error Handling Methods */
+
+    Enumerable.prototype.catchError = function (handler) {
+        handler = Utils.createLambda(handler);
+        var source = this;
+
+        return new Enumerable(function () {
+            var enumerator;
+
+            return new IEnumerator(
+                function () { enumerator = source.getEnumerator(); },
+                function () {
+                    try {
+                        return (enumerator.moveNext())
+                            ? this.yieldReturn(enumerator.current())
+                            : false;
+                    } catch (e) {
+                        handler(e);
+                        return false;
+                    }
+                },
+                function () { Utils.dispose(enumerator); });
+        });
+    };
+
+    Enumerable.prototype.finallyAction = function (finallyAction) {
+        finallyAction = Utils.createLambda(finallyAction);
+        var source = this;
+
+        return new Enumerable(function () {
+            var enumerator;
+
+            return new IEnumerator(
+                function () { enumerator = source.getEnumerator(); },
+                function () {
+                    return (enumerator.moveNext())
+                        ? this.yieldReturn(enumerator.current())
+                        : false;
+                },
+                function () {
+                    try {
+                        Utils.dispose(enumerator);
+                    } finally {
+                        finallyAction();
+                    }
+                });
+        });
+    };
+
+    /* For Debug Methods */
+
+    // Overload:function()
+    // Overload:function(selector)
+    Enumerable.prototype.log = function (selector) {
+        selector = Utils.createLambda(selector);
+
+        return this.doAction(function (item) {
+            if (typeof console !== Types.Undefined) {
+                console.log(selector(item));
+            }
+        });
+    };
+
+    // Overload:function()
+    // Overload:function(message)
+    // Overload:function(message,selector)
+    Enumerable.prototype.trace = function (message, selector) {
+        if (message == null) message = "Trace";
+        selector = Utils.createLambda(selector);
+
+        return this.doAction(function (item) {
+            if (typeof console !== Types.Undefined) {
+                console.log(message, selector(item));
+            }
+        });
+    };
+
+    // private
+
+    var OrderedEnumerable = function (source, keySelector, descending, parent) {
+        this.source = source;
+        this.keySelector = Utils.createLambda(keySelector);
+        this.descending = descending;
+        this.parent = parent;
+    };
+    OrderedEnumerable.prototype = new Enumerable();
+
+    OrderedEnumerable.prototype.createOrderedEnumerable = function (keySelector, descending) {
+        return new OrderedEnumerable(this.source, keySelector, descending, this);
+    };
+    OrderedEnumerable.prototype.thenBy = function (keySelector) {
+        return this.createOrderedEnumerable(keySelector, false);
+    };
+    OrderedEnumerable.prototype.thenByDescending = function (keySelector) {
+        return this.createOrderedEnumerable(keySelector, true);
+    };
+    OrderedEnumerable.prototype.getEnumerator = function () {
+        var self = this;
+        var buffer;
+        var indexes;
+        var index = 0;
+
+        return new IEnumerator(
+            function () {
+                buffer = [];
+                indexes = [];
+                self.source.forEach(function (item, index) {
+                    buffer.push(item);
+                    indexes.push(index);
+                });
+                var sortContext = SortContext.create(self, null);
+                sortContext.GenerateKeys(buffer);
+
+                indexes.sort(function (a, b) { return sortContext.compare(a, b); });
+            },
+            function () {
+                return (index < indexes.length)
+                    ? this.yieldReturn(buffer[indexes[index++]])
+                    : false;
+            },
+            Functions.Blank
+        );
+    };
+
+    var SortContext = function (keySelector, descending, child) {
+        this.keySelector = keySelector;
+        this.descending = descending;
+        this.child = child;
+        this.keys = null;
+    };
+    SortContext.create = function (orderedEnumerable, currentContext) {
+        var context = new SortContext(orderedEnumerable.keySelector, orderedEnumerable.descending, currentContext);
+        if (orderedEnumerable.parent != null) return SortContext.create(orderedEnumerable.parent, context);
+        return context;
+    };
+    SortContext.prototype.GenerateKeys = function (source) {
+        var len = source.length;
+        var keySelector = this.keySelector;
+        var keys = new Array(len);
+        for (var i = 0; i < len; i++) keys[i] = keySelector(source[i]);
+        this.keys = keys;
+
+        if (this.child != null) this.child.GenerateKeys(source);
+    };
+    SortContext.prototype.compare = function (index1, index2) {
+        var comparison = Utils.compare(this.keys[index1], this.keys[index2]);
+
+        if (comparison == 0) {
+            if (this.child != null) return this.child.compare(index1, index2);
+            return Utils.compare(index1, index2);
+        }
+
+        return (this.descending) ? -comparison : comparison;
+    };
+
+    var DisposableEnumerable = function (getEnumerator, dispose) {
+        this.dispose = dispose;
+        Enumerable.call(this, getEnumerator);
+    };
+    DisposableEnumerable.prototype = new Enumerable();
+
+    // optimize array or arraylike object
+
+    var ArrayEnumerable = function (source) {
+        this.getSource = function () { return source; };
+    };
+    ArrayEnumerable.prototype = new Enumerable();
+
+    ArrayEnumerable.prototype.any = function (predicate) {
+        return (predicate == null)
+            ? (this.getSource().length > 0)
+            : Enumerable.prototype.any.apply(this, arguments);
+    };
+
+    ArrayEnumerable.prototype.count = function (predicate) {
+        return (predicate == null)
+            ? this.getSource().length
+            : Enumerable.prototype.count.apply(this, arguments);
+    };
+
+    ArrayEnumerable.prototype.elementAt = function (index) {
+        var source = this.getSource();
+        return (0 <= index && index < source.length)
+            ? source[index]
+            : Enumerable.prototype.elementAt.apply(this, arguments);
+    };
+
+    ArrayEnumerable.prototype.elementAtOrDefault = function (index, defaultValue) {
+        if (defaultValue === undefined) defaultValue = null;
+        var source = this.getSource();
+        return (0 <= index && index < source.length)
+            ? source[index]
+            : defaultValue;
+    };
+
+    ArrayEnumerable.prototype.first = function (predicate) {
+        var source = this.getSource();
+        return (predicate == null && source.length > 0)
+            ? source[0]
+            : Enumerable.prototype.first.apply(this, arguments);
+    };
+
+    ArrayEnumerable.prototype.firstOrDefault = function (predicate, defaultValue) {
+        if (defaultValue === undefined) defaultValue = null;
+        if (predicate != null) {
+            return Enumerable.prototype.firstOrDefault.apply(this, arguments);
+        }
+
+        var source = this.getSource();
+        return source.length > 0 ? source[0] : defaultValue;
+    };
+
+    ArrayEnumerable.prototype.last = function (predicate) {
+        var source = this.getSource();
+        return (predicate == null && source.length > 0)
+            ? source[source.length - 1]
+            : Enumerable.prototype.last.apply(this, arguments);
+    };
+
+    ArrayEnumerable.prototype.lastOrDefault = function (predicate, defaultValue) {
+        if (defaultValue === undefined) defaultValue = null;
+        if (predicate != null) {
+            return Enumerable.prototype.lastOrDefault.apply(this, arguments);
+        }
+
+        var source = this.getSource();
+        return source.length > 0 ? source[source.length - 1] : defaultValue;
+    };
+
+    ArrayEnumerable.prototype.skip = function (count) {
+        var source = this.getSource();
+
+        return new Enumerable(function () {
+            var index;
+
+            return new IEnumerator(
+                function () { index = (count < 0) ? 0 : count; },
+                function () {
+                    return (index < source.length)
+                        ? this.yieldReturn(source[index++])
+                        : false;
+                },
+                Functions.Blank);
+        });
+    };
+
+    ArrayEnumerable.prototype.takeExceptLast = function (count) {
+        if (count == null) count = 1;
+        return this.take(this.getSource().length - count);
+    };
+
+    ArrayEnumerable.prototype.takeFromLast = function (count) {
+        return this.skip(this.getSource().length - count);
+    };
+
+    ArrayEnumerable.prototype.reverse = function () {
+        var source = this.getSource();
+
+        return new Enumerable(function () {
+            var index;
+
+            return new IEnumerator(
+                function () {
+                    index = source.length;
+                },
+                function () {
+                    return (index > 0)
+                        ? this.yieldReturn(source[--index])
+                        : false;
+                },
+                Functions.Blank);
+        });
+    };
+
+    ArrayEnumerable.prototype.sequenceEqual = function (second, compareSelector) {
+        if ((second instanceof ArrayEnumerable || second instanceof Array)
+            && compareSelector == null
+            && Enumerable.from(second).count() != this.count()) {
+            return false;
+        }
+
+        return Enumerable.prototype.sequenceEqual.apply(this, arguments);
+    };
+
+    ArrayEnumerable.prototype.toJoinedString = function (separator, selector) {
+        var source = this.getSource();
+        if (selector != null || !(source instanceof Array)) {
+            return Enumerable.prototype.toJoinedString.apply(this, arguments);
+        }
+
+        if (separator == null) separator = "";
+        return source.join(separator);
+    };
+
+    ArrayEnumerable.prototype.getEnumerator = function () {
+        var source = this.getSource();
+        var index = -1;
+
+        // fast and simple enumerator
+        return {
+            current: function () { return source[index]; },
+            moveNext: function () {
+                return ++index < source.length;
+            },
+            dispose: Functions.Blank
+        };
+    };
+
+    // optimization for multiple where and multiple select and whereselect
+
+    var WhereEnumerable = function (source, predicate) {
+        this.prevSource = source;
+        this.prevPredicate = predicate; // predicate.length always <= 1
+    };
+    WhereEnumerable.prototype = new Enumerable();
+
+    WhereEnumerable.prototype.where = function (predicate) {
+        predicate = Utils.createLambda(predicate);
+
+        if (predicate.length <= 1) {
+            var prevPredicate = this.prevPredicate;
+            var composedPredicate = function (x) { return prevPredicate(x) && predicate(x); };
+            return new WhereEnumerable(this.prevSource, composedPredicate);
+        }
+        else {
+            // if predicate use index, can't compose
+            return Enumerable.prototype.where.call(this, predicate);
+        }
+    };
+
+    WhereEnumerable.prototype.select = function (selector) {
+        selector = Utils.createLambda(selector);
+
+        return (selector.length <= 1)
+            ? new WhereSelectEnumerable(this.prevSource, this.prevPredicate, selector)
+            : Enumerable.prototype.select.call(this, selector);
+    };
+
+    WhereEnumerable.prototype.getEnumerator = function () {
+        var predicate = this.prevPredicate;
+        var source = this.prevSource;
+        var enumerator;
+
+        return new IEnumerator(
+            function () { enumerator = source.getEnumerator(); },
+            function () {
+                while (enumerator.moveNext()) {
+                    if (predicate(enumerator.current())) {
+                        return this.yieldReturn(enumerator.current());
+                    }
+                }
+                return false;
+            },
+            function () { Utils.dispose(enumerator); });
+    };
+
+    var WhereSelectEnumerable = function (source, predicate, selector) {
+        this.prevSource = source;
+        this.prevPredicate = predicate; // predicate.length always <= 1 or null
+        this.prevSelector = selector; // selector.length always <= 1
+    };
+    WhereSelectEnumerable.prototype = new Enumerable();
+
+    WhereSelectEnumerable.prototype.where = function (predicate) {
+        predicate = Utils.createLambda(predicate);
+
+        return (predicate.length <= 1)
+            ? new WhereEnumerable(this, predicate)
+            : Enumerable.prototype.where.call(this, predicate);
+    };
+
+    WhereSelectEnumerable.prototype.select = function (selector) {
+        selector = Utils.createLambda(selector);
+
+        if (selector.length <= 1) {
+            var prevSelector = this.prevSelector;
+            var composedSelector = function (x) { return selector(prevSelector(x)); };
+            return new WhereSelectEnumerable(this.prevSource, this.prevPredicate, composedSelector);
+        }
+        else {
+            // if selector use index, can't compose
+            return Enumerable.prototype.select.call(this, selector);
+        }
+    };
+
+    WhereSelectEnumerable.prototype.getEnumerator = function () {
+        var predicate = this.prevPredicate;
+        var selector = this.prevSelector;
+        var source = this.prevSource;
+        var enumerator;
+
+        return new IEnumerator(
+            function () { enumerator = source.getEnumerator(); },
+            function () {
+                while (enumerator.moveNext()) {
+                    if (predicate == null || predicate(enumerator.current())) {
+                        return this.yieldReturn(selector(enumerator.current()));
+                    }
+                }
+                return false;
+            },
+            function () { Utils.dispose(enumerator); });
+    };
+
+    // Collections
+
+    var Dictionary = (function () {
+        // static utility methods
+        var callHasOwnProperty = function (target, key) {
+            return Object.prototype.hasOwnProperty.call(target, key);
+        };
+
+        var computeHashCode = function (obj) {
+            if (obj === null) return "null";
+            if (obj === undefined) return "undefined";
+
+            return (typeof obj.toString === Types.Function)
+                ? obj.toString()
+                : Object.prototype.toString.call(obj);
+        };
+
+        // LinkedList for Dictionary
+        var HashEntry = function (key, value) {
+            this.key = key;
+            this.value = value;
+            this.prev = null;
+            this.next = null;
+        };
+
+        var EntryList = function () {
+            this.first = null;
+            this.last = null;
+        };
+        EntryList.prototype =
+        {
+            addLast: function (entry) {
+                if (this.last != null) {
+                    this.last.next = entry;
+                    entry.prev = this.last;
+                    this.last = entry;
+                } else this.first = this.last = entry;
+            },
+
+            replace: function (entry, newEntry) {
+                if (entry.prev != null) {
+                    entry.prev.next = newEntry;
+                    newEntry.prev = entry.prev;
+                } else this.first = newEntry;
+
+                if (entry.next != null) {
+                    entry.next.prev = newEntry;
+                    newEntry.next = entry.next;
+                } else this.last = newEntry;
+
+            },
+
+            remove: function (entry) {
+                if (entry.prev != null) entry.prev.next = entry.next;
+                else this.first = entry.next;
+
+                if (entry.next != null) entry.next.prev = entry.prev;
+                else this.last = entry.prev;
+            }
+        };
+
+        // Overload:function()
+        // Overload:function(compareSelector)
+        var Dictionary = function (compareSelector) {
+            this.countField = 0;
+            this.entryList = new EntryList();
+            this.buckets = {}; // as Dictionary<string,List<object>>
+            this.compareSelector = (compareSelector == null) ? Functions.Identity : compareSelector;
+        };
+        Dictionary.prototype =
+        {
+            add: function (key, value) {
+                var compareKey = this.compareSelector(key);
+                var hash = computeHashCode(compareKey);
+                var entry = new HashEntry(key, value);
+                if (callHasOwnProperty(this.buckets, hash)) {
+                    var array = this.buckets[hash];
+                    for (var i = 0; i < array.length; i++) {
+                        if (this.compareSelector(array[i].key) === compareKey) {
+                            this.entryList.replace(array[i], entry);
+                            array[i] = entry;
+                            return;
+                        }
+                    }
+                    array.push(entry);
+                } else {
+                    this.buckets[hash] = [entry];
+                }
+                this.countField++;
+                this.entryList.addLast(entry);
+            },
+
+            get: function (key) {
+                var compareKey = this.compareSelector(key);
+                var hash = computeHashCode(compareKey);
+                if (!callHasOwnProperty(this.buckets, hash)) return undefined;
+
+                var array = this.buckets[hash];
+                for (var i = 0; i < array.length; i++) {
+                    var entry = array[i];
+                    if (this.compareSelector(entry.key) === compareKey) return entry.value;
+                }
+                return undefined;
+            },
+
+            set: function (key, value) {
+                var compareKey = this.compareSelector(key);
+                var hash = computeHashCode(compareKey);
+                if (callHasOwnProperty(this.buckets, hash)) {
+                    var array = this.buckets[hash];
+                    for (var i = 0; i < array.length; i++) {
+                        if (this.compareSelector(array[i].key) === compareKey) {
+                            var newEntry = new HashEntry(key, value);
+                            this.entryList.replace(array[i], newEntry);
+                            array[i] = newEntry;
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            },
+
+            contains: function (key) {
+                var compareKey = this.compareSelector(key);
+                var hash = computeHashCode(compareKey);
+                if (!callHasOwnProperty(this.buckets, hash)) return false;
+
+                var array = this.buckets[hash];
+                for (var i = 0; i < array.length; i++) {
+                    if (this.compareSelector(array[i].key) === compareKey) return true;
+                }
+                return false;
+            },
+
+            clear: function () {
+                this.countField = 0;
+                this.buckets = {};
+                this.entryList = new EntryList();
+            },
+
+            remove: function (key) {
+                var compareKey = this.compareSelector(key);
+                var hash = computeHashCode(compareKey);
+                if (!callHasOwnProperty(this.buckets, hash)) return;
+
+                var array = this.buckets[hash];
+                for (var i = 0; i < array.length; i++) {
+                    if (this.compareSelector(array[i].key) === compareKey) {
+                        this.entryList.remove(array[i]);
+                        array.splice(i, 1);
+                        if (array.length == 0) delete this.buckets[hash];
+                        this.countField--;
+                        return;
+                    }
+                }
+            },
+
+            count: function () {
+                return this.countField;
+            },
+
+            toEnumerable: function () {
+                var self = this;
+                return new Enumerable(function () {
+                    var currentEntry;
+
+                    return new IEnumerator(
+                        function () { currentEntry = self.entryList.first; },
+                        function () {
+                            if (currentEntry != null) {
+                                var result = { key: currentEntry.key, value: currentEntry.value };
+                                currentEntry = currentEntry.next;
+                                return this.yieldReturn(result);
+                            }
+                            return false;
+                        },
+                        Functions.Blank);
+                });
+            }
+        };
+
+        return Dictionary;
+    })();
+
+    // dictionary = Dictionary<TKey, TValue[]>
+    var Lookup = function (dictionary) {
+        this.count = function () {
+            return dictionary.count();
+        };
+        this.get = function (key) {
+            return Enumerable.from(dictionary.get(key));
+        };
+        this.contains = function (key) {
+            return dictionary.contains(key);
+        };
+        this.toEnumerable = function () {
+            return dictionary.toEnumerable().select(function (kvp) {
+                return new Grouping(kvp.key, kvp.value);
+            });
+        };
+    };
+
+    var Grouping = function (groupKey, elements) {
+        this.key = function () {
+            return groupKey;
+        };
+        ArrayEnumerable.call(this, elements);
+    };
+    Grouping.prototype = new ArrayEnumerable();
+
+    // module export
+    if (typeof define === Types.Function && define.amd) { // AMD
+        define("linqjs", [], function () { return Enumerable; });
+    }
+    else if (typeof module !== Types.Undefined && module.exports) { // Node
+        module.exports = Enumerable;
+    }
+    else {
+        root.Enumerable = Enumerable;
+    }
+})(this);