diff --git a/src/lib/es2015.iterable.d.ts b/src/lib/es2015.iterable.d.ts
index e1b9d99762b..4ccdd02b566 100644
--- a/src/lib/es2015.iterable.d.ts
+++ b/src/lib/es2015.iterable.d.ts
@@ -1,24 +1,13 @@
 /// <reference path="lib.es2015.symbol.d.ts" />
 
 interface SymbolConstructor {
-    /** 
-      * A method that returns the default iterator for an object. Called by the semantics of the 
+    /**
+      * A method that returns the default iterator for an object. Called by the semantics of the
       * for-of statement.
       */
     readonly iterator: symbol;
 }
 
-interface IteratorResult<T> {
-    done: boolean;
-    value: T;
-}
-
-interface Iterator<T> {
-    next(value?: any): IteratorResult<T>;
-    return?(value?: any): IteratorResult<T>;
-    throw?(e?: any): IteratorResult<T>;
-}
-
 interface Iterable<T> {
     [Symbol.iterator](): Iterator<T>;
 }
@@ -31,17 +20,17 @@ interface Array<T> {
     /** Iterator */
     [Symbol.iterator](): IterableIterator<T>;
 
-    /** 
+    /**
       * Returns an array of key, value pairs for every entry in the array
       */
     entries(): IterableIterator<[number, T]>;
 
-    /** 
+    /**
       * Returns an list of keys in the array
       */
     keys(): IterableIterator<number>;
 
-    /** 
+    /**
       * Returns an list of values in the array
       */
     values(): IterableIterator<T>;
@@ -55,7 +44,7 @@ interface ArrayConstructor {
       * @param thisArg Value of 'this' used to invoke the mapfn.
       */
     from<T, U>(iterable: Iterable<T>, mapfn: (v: T, k: number) => U, thisArg?: any): Array<U>;
-    
+
     /**
       * Creates an array from an iterable object.
       * @param iterable An iterable object to convert to an array.
@@ -106,15 +95,15 @@ interface Promise<T> { }
 
 interface PromiseConstructor {
     /**
-     * Creates a Promise that is resolved with an array of results when all of the provided Promises 
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises
      * resolve, or rejected when any Promise is rejected.
      * @param values An array of Promises.
      * @returns A new Promise.
      */
     all<TAll>(values: Iterable<TAll | PromiseLike<TAll>>): Promise<TAll[]>;
-    
+
     /**
-     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved 
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
      * or rejected.
      * @param values An array of Promises.
      * @returns A new Promise.
@@ -132,20 +121,20 @@ interface String {
 }
 
 /**
-  * A typed array of 8-bit integer values. The contents are initialized to 0. If the requested 
+  * A typed array of 8-bit integer values. The contents are initialized to 0. If the requested
   * number of bytes could not be allocated an exception is raised.
   */
 interface Int8Array {
     [Symbol.iterator](): IterableIterator<number>;
-    /** 
+    /**
       * Returns an array of key, value pairs for every entry in the array
       */
     entries(): IterableIterator<[number, number]>;
-    /** 
+    /**
       * Returns an list of keys in the array
       */
     keys(): IterableIterator<number>;
-    /** 
+    /**
       * Returns an list of values in the array
       */
     values(): IterableIterator<number>;
@@ -164,20 +153,20 @@ interface Int8ArrayConstructor {
 }
 
 /**
-  * A typed array of 8-bit unsigned integer values. The contents are initialized to 0. If the 
+  * A typed array of 8-bit unsigned integer values. The contents are initialized to 0. If the
   * requested number of bytes could not be allocated an exception is raised.
   */
 interface Uint8Array {
     [Symbol.iterator](): IterableIterator<number>;
-    /** 
+    /**
       * Returns an array of key, value pairs for every entry in the array
       */
     entries(): IterableIterator<[number, number]>;
-    /** 
+    /**
       * Returns an list of keys in the array
       */
     keys(): IterableIterator<number>;
-    /** 
+    /**
       * Returns an list of values in the array
       */
     values(): IterableIterator<number>;
@@ -196,22 +185,22 @@ interface Uint8ArrayConstructor {
 }
 
 /**
-  * A typed array of 8-bit unsigned integer (clamped) values. The contents are initialized to 0. 
+  * A typed array of 8-bit unsigned integer (clamped) values. The contents are initialized to 0.
   * If the requested number of bytes could not be allocated an exception is raised.
   */
 interface Uint8ClampedArray {
     [Symbol.iterator](): IterableIterator<number>;
-    /** 
+    /**
       * Returns an array of key, value pairs for every entry in the array
       */
     entries(): IterableIterator<[number, number]>;
 
-    /** 
+    /**
       * Returns an list of keys in the array
       */
     keys(): IterableIterator<number>;
 
-    /** 
+    /**
       * Returns an list of values in the array
       */
     values(): IterableIterator<number>;
@@ -231,22 +220,22 @@ interface Uint8ClampedArrayConstructor {
 }
 
 /**
-  * A typed array of 16-bit signed integer values. The contents are initialized to 0. If the 
+  * A typed array of 16-bit signed integer values. The contents are initialized to 0. If the
   * requested number of bytes could not be allocated an exception is raised.
   */
 interface Int16Array {
     [Symbol.iterator](): IterableIterator<number>;
-    /** 
+    /**
       * Returns an array of key, value pairs for every entry in the array
       */
     entries(): IterableIterator<[number, number]>;
 
-    /** 
+    /**
       * Returns an list of keys in the array
       */
     keys(): IterableIterator<number>;
 
-    /** 
+    /**
       * Returns an list of values in the array
       */
     values(): IterableIterator<number>;
@@ -265,20 +254,20 @@ interface Int16ArrayConstructor {
 }
 
 /**
-  * A typed array of 16-bit unsigned integer values. The contents are initialized to 0. If the 
+  * A typed array of 16-bit unsigned integer values. The contents are initialized to 0. If the
   * requested number of bytes could not be allocated an exception is raised.
   */
 interface Uint16Array {
     [Symbol.iterator](): IterableIterator<number>;
-    /** 
+    /**
       * Returns an array of key, value pairs for every entry in the array
       */
     entries(): IterableIterator<[number, number]>;
-    /** 
+    /**
       * Returns an list of keys in the array
       */
     keys(): IterableIterator<number>;
-    /** 
+    /**
       * Returns an list of values in the array
       */
     values(): IterableIterator<number>;
@@ -297,20 +286,20 @@ interface Uint16ArrayConstructor {
 }
 
 /**
-  * A typed array of 32-bit signed integer values. The contents are initialized to 0. If the 
+  * A typed array of 32-bit signed integer values. The contents are initialized to 0. If the
   * requested number of bytes could not be allocated an exception is raised.
   */
 interface Int32Array {
     [Symbol.iterator](): IterableIterator<number>;
-    /** 
+    /**
       * Returns an array of key, value pairs for every entry in the array
       */
     entries(): IterableIterator<[number, number]>;
-    /** 
+    /**
       * Returns an list of keys in the array
       */
     keys(): IterableIterator<number>;
-    /** 
+    /**
       * Returns an list of values in the array
       */
     values(): IterableIterator<number>;
@@ -329,20 +318,20 @@ interface Int32ArrayConstructor {
 }
 
 /**
-  * A typed array of 32-bit unsigned integer values. The contents are initialized to 0. If the 
+  * A typed array of 32-bit unsigned integer values. The contents are initialized to 0. If the
   * requested number of bytes could not be allocated an exception is raised.
   */
 interface Uint32Array {
     [Symbol.iterator](): IterableIterator<number>;
-    /** 
+    /**
       * Returns an array of key, value pairs for every entry in the array
       */
     entries(): IterableIterator<[number, number]>;
-    /** 
+    /**
       * Returns an list of keys in the array
       */
     keys(): IterableIterator<number>;
-    /** 
+    /**
       * Returns an list of values in the array
       */
     values(): IterableIterator<number>;
@@ -366,15 +355,15 @@ interface Uint32ArrayConstructor {
   */
 interface Float32Array {
     [Symbol.iterator](): IterableIterator<number>;
-    /** 
+    /**
       * Returns an array of key, value pairs for every entry in the array
       */
     entries(): IterableIterator<[number, number]>;
-    /** 
+    /**
       * Returns an list of keys in the array
       */
     keys(): IterableIterator<number>;
-    /** 
+    /**
       * Returns an list of values in the array
       */
     values(): IterableIterator<number>;
@@ -393,20 +382,20 @@ interface Float32ArrayConstructor {
 }
 
 /**
-  * A typed array of 64-bit float values. The contents are initialized to 0. If the requested 
+  * A typed array of 64-bit float values. The contents are initialized to 0. If the requested
   * number of bytes could not be allocated an exception is raised.
   */
 interface Float64Array {
     [Symbol.iterator](): IterableIterator<number>;
-    /** 
+    /**
       * Returns an array of key, value pairs for every entry in the array
       */
     entries(): IterableIterator<[number, number]>;
-    /** 
+    /**
       * Returns an list of keys in the array
       */
     keys(): IterableIterator<number>;
-    /** 
+    /**
       * Returns an list of values in the array
       */
     values(): IterableIterator<number>;
diff --git a/tests/baselines/reference/FunctionDeclaration10_es6.js b/tests/baselines/reference/FunctionDeclaration10_es6.js
index 6ac2ec8d194..3248a79d88d 100644
--- a/tests/baselines/reference/FunctionDeclaration10_es6.js
+++ b/tests/baselines/reference/FunctionDeclaration10_es6.js
@@ -3,8 +3,59 @@ function * foo(a = yield => yield) {
 }
 
 //// [FunctionDeclaration10_es6.js]
-function* foo(a) {
-    if (a === void 0) { a = yield; }
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function foo(a) {
+    if (a === void 0) { a = _a.sent(); }
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/];
+            case 1: return [2 /*return*/];
+        }
+    });
 }
 yield;
 {
diff --git a/tests/baselines/reference/FunctionDeclaration11_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration11_es6.errors.txt
deleted file mode 100644
index 4db3842e91d..00000000000
--- a/tests/baselines/reference/FunctionDeclaration11_es6.errors.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration11_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-
-
-==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration11_es6.ts (1 errors) ====
-    function * yield() {
-             ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/FunctionDeclaration11_es6.js b/tests/baselines/reference/FunctionDeclaration11_es6.js
index d56eebd3bb5..9a166c4af74 100644
--- a/tests/baselines/reference/FunctionDeclaration11_es6.js
+++ b/tests/baselines/reference/FunctionDeclaration11_es6.js
@@ -3,5 +3,53 @@ function * yield() {
 }
 
 //// [FunctionDeclaration11_es6.js]
-function* yield() {
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function yield() {
+    return __generator(this, function (_a) {
+        return [2 /*return*/];
+    });
 }
diff --git a/tests/baselines/reference/FunctionDeclaration11_es6.symbols b/tests/baselines/reference/FunctionDeclaration11_es6.symbols
new file mode 100644
index 00000000000..a51b763e4bf
--- /dev/null
+++ b/tests/baselines/reference/FunctionDeclaration11_es6.symbols
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration11_es6.ts ===
+function * yield() {
+>yield : Symbol(yield, Decl(FunctionDeclaration11_es6.ts, 0, 0))
+}
diff --git a/tests/baselines/reference/FunctionDeclaration11_es6.types b/tests/baselines/reference/FunctionDeclaration11_es6.types
new file mode 100644
index 00000000000..d4e28a7922d
--- /dev/null
+++ b/tests/baselines/reference/FunctionDeclaration11_es6.types
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration11_es6.ts ===
+function * yield() {
+>yield : () => Iterator<any>
+}
diff --git a/tests/baselines/reference/FunctionDeclaration12_es6.js b/tests/baselines/reference/FunctionDeclaration12_es6.js
index 87ea08215fe..c86a5a6ebb8 100644
--- a/tests/baselines/reference/FunctionDeclaration12_es6.js
+++ b/tests/baselines/reference/FunctionDeclaration12_es6.js
@@ -2,4 +2,51 @@
 var v = function * yield() { }
 
 //// [FunctionDeclaration12_es6.js]
-var v = function* () { }, yield = function () { };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+var v = function () { return __generator(this, function (_a) {
+    return [2 /*return*/];
+}); }, yield = function () { };
diff --git a/tests/baselines/reference/FunctionDeclaration13_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration13_es6.errors.txt
index fa675446617..1f921475fd3 100644
--- a/tests/baselines/reference/FunctionDeclaration13_es6.errors.txt
+++ b/tests/baselines/reference/FunctionDeclaration13_es6.errors.txt
@@ -1,11 +1,8 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts(3,11): error TS2304: Cannot find name 'yield'.
 
 
-==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts (2 errors) ====
+==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts (1 errors) ====
     function * foo() {
-             ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
        // Legal to use 'yield' in a type context.
        var v: yield;
               ~~~~~
diff --git a/tests/baselines/reference/FunctionDeclaration13_es6.js b/tests/baselines/reference/FunctionDeclaration13_es6.js
index b0527ee47ef..8d273c54d62 100644
--- a/tests/baselines/reference/FunctionDeclaration13_es6.js
+++ b/tests/baselines/reference/FunctionDeclaration13_es6.js
@@ -6,7 +6,54 @@ function * foo() {
 
 
 //// [FunctionDeclaration13_es6.js]
-function* foo() {
-    // Legal to use 'yield' in a type context.
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function foo() {
     var v;
+    return __generator(this, function (_a) {
+        return [2 /*return*/];
+    });
 }
diff --git a/tests/baselines/reference/FunctionDeclaration1_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration1_es6.errors.txt
deleted file mode 100644
index d3dab521926..00000000000
--- a/tests/baselines/reference/FunctionDeclaration1_es6.errors.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration1_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-
-
-==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration1_es6.ts (1 errors) ====
-    function * foo() {
-             ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/FunctionDeclaration1_es6.js b/tests/baselines/reference/FunctionDeclaration1_es6.js
index 534a4c21cd7..cc9a2811668 100644
--- a/tests/baselines/reference/FunctionDeclaration1_es6.js
+++ b/tests/baselines/reference/FunctionDeclaration1_es6.js
@@ -3,5 +3,53 @@ function * foo() {
 }
 
 //// [FunctionDeclaration1_es6.js]
-function* foo() {
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function foo() {
+    return __generator(this, function (_a) {
+        return [2 /*return*/];
+    });
 }
diff --git a/tests/baselines/reference/FunctionDeclaration1_es6.symbols b/tests/baselines/reference/FunctionDeclaration1_es6.symbols
new file mode 100644
index 00000000000..7683664cb93
--- /dev/null
+++ b/tests/baselines/reference/FunctionDeclaration1_es6.symbols
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration1_es6.ts ===
+function * foo() {
+>foo : Symbol(foo, Decl(FunctionDeclaration1_es6.ts, 0, 0))
+}
diff --git a/tests/baselines/reference/FunctionDeclaration1_es6.types b/tests/baselines/reference/FunctionDeclaration1_es6.types
new file mode 100644
index 00000000000..764b821cedf
--- /dev/null
+++ b/tests/baselines/reference/FunctionDeclaration1_es6.types
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration1_es6.ts ===
+function * foo() {
+>foo : () => Iterator<any>
+}
diff --git a/tests/baselines/reference/FunctionDeclaration5_es6.js b/tests/baselines/reference/FunctionDeclaration5_es6.js
index 645ee976ecd..e15abcba317 100644
--- a/tests/baselines/reference/FunctionDeclaration5_es6.js
+++ b/tests/baselines/reference/FunctionDeclaration5_es6.js
@@ -3,7 +3,54 @@ function*foo(yield) {
 }
 
 //// [FunctionDeclaration5_es6.js]
-function* foo() { }
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function foo() { return __generator(this, function (_a) {
+    return [2 /*return*/];
+}); }
 yield;
 {
 }
diff --git a/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt
index 60798f7dbd6..04806c7aae9 100644
--- a/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt
+++ b/tests/baselines/reference/FunctionDeclaration6_es6.errors.txt
@@ -1,11 +1,8 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts(1,18): error TS2523: 'yield' expressions cannot be used in a parameter initializer.
 
 
-==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts (2 errors) ====
+==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts (1 errors) ====
     function*foo(a = yield) {
-            ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
                      ~~~~~
 !!! error TS2523: 'yield' expressions cannot be used in a parameter initializer.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/FunctionDeclaration6_es6.js b/tests/baselines/reference/FunctionDeclaration6_es6.js
index e0b871a9172..52d34bf4db8 100644
--- a/tests/baselines/reference/FunctionDeclaration6_es6.js
+++ b/tests/baselines/reference/FunctionDeclaration6_es6.js
@@ -3,6 +3,57 @@ function*foo(a = yield) {
 }
 
 //// [FunctionDeclaration6_es6.js]
-function* foo(a) {
-    if (a === void 0) { a = yield; }
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function foo(a) {
+    if (a === void 0) { a = _a.sent(); }
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/];
+            case 1: return [2 /*return*/];
+        }
+    });
 }
diff --git a/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt
index 3c1b950bea5..e0273c3bb44 100644
--- a/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt
+++ b/tests/baselines/reference/FunctionDeclaration7_es6.errors.txt
@@ -1,16 +1,10 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts(3,20): error TS2523: 'yield' expressions cannot be used in a parameter initializer.
 
 
-==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts (3 errors) ====
+==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts (1 errors) ====
     function*bar() {
-            ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
       // 'yield' here is an identifier, and not a yield expression.
       function*foo(a = yield) {
-              ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
                        ~~~~~
 !!! error TS2523: 'yield' expressions cannot be used in a parameter initializer.
       }
diff --git a/tests/baselines/reference/FunctionDeclaration7_es6.js b/tests/baselines/reference/FunctionDeclaration7_es6.js
index 49b43e2a2db..340219c40a4 100644
--- a/tests/baselines/reference/FunctionDeclaration7_es6.js
+++ b/tests/baselines/reference/FunctionDeclaration7_es6.js
@@ -6,9 +6,63 @@ function*bar() {
 }
 
 //// [FunctionDeclaration7_es6.js]
-function* bar() {
-    // 'yield' here is an identifier, and not a yield expression.
-    function* foo(a) {
-        if (a === void 0) { a = yield; }
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
     }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function bar() {
+    // 'yield' here is an identifier, and not a yield expression.
+    function foo(a) {
+        if (a === void 0) { a = _a.sent(); }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/];
+                case 1: return [2 /*return*/];
+            }
+        });
+    }
+    return __generator(this, function (_a) {
+        return [2 /*return*/];
+    });
 }
diff --git a/tests/baselines/reference/FunctionDeclaration9_es6.errors.txt b/tests/baselines/reference/FunctionDeclaration9_es6.errors.txt
deleted file mode 100644
index a2d2121d7fa..00000000000
--- a/tests/baselines/reference/FunctionDeclaration9_es6.errors.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-
-
-==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts (1 errors) ====
-    function * foo() {
-             ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-      var v = { [yield]: foo }
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/FunctionDeclaration9_es6.js b/tests/baselines/reference/FunctionDeclaration9_es6.js
index 720e276ccba..2e5c9e4157c 100644
--- a/tests/baselines/reference/FunctionDeclaration9_es6.js
+++ b/tests/baselines/reference/FunctionDeclaration9_es6.js
@@ -4,7 +4,61 @@ function * foo() {
 }
 
 //// [FunctionDeclaration9_es6.js]
-function* foo() {
-    var v = (_a = {}, _a[yield] = foo, _a);
-    var _a;
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function foo() {
+    var v, _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _a = {};
+                return [4 /*yield*/];
+            case 1:
+                v = (_a[_b.sent()] = foo, _a);
+                return [2 /*return*/];
+        }
+    });
 }
diff --git a/tests/baselines/reference/FunctionDeclaration9_es6.symbols b/tests/baselines/reference/FunctionDeclaration9_es6.symbols
new file mode 100644
index 00000000000..0797c51331c
--- /dev/null
+++ b/tests/baselines/reference/FunctionDeclaration9_es6.symbols
@@ -0,0 +1,8 @@
+=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts ===
+function * foo() {
+>foo : Symbol(foo, Decl(FunctionDeclaration9_es6.ts, 0, 0))
+
+  var v = { [yield]: foo }
+>v : Symbol(v, Decl(FunctionDeclaration9_es6.ts, 1, 5))
+>foo : Symbol(foo, Decl(FunctionDeclaration9_es6.ts, 0, 0))
+}
diff --git a/tests/baselines/reference/FunctionDeclaration9_es6.types b/tests/baselines/reference/FunctionDeclaration9_es6.types
new file mode 100644
index 00000000000..268a235d040
--- /dev/null
+++ b/tests/baselines/reference/FunctionDeclaration9_es6.types
@@ -0,0 +1,10 @@
+=== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts ===
+function * foo() {
+>foo : () => Iterator<any>
+
+  var v = { [yield]: foo }
+>v : { [x: number]: () => Iterator<any>; }
+>{ [yield]: foo } : { [x: number]: () => Iterator<any>; }
+>yield : any
+>foo : () => Iterator<any>
+}
diff --git a/tests/baselines/reference/FunctionExpression1_es6.errors.txt b/tests/baselines/reference/FunctionExpression1_es6.errors.txt
deleted file mode 100644
index 9c1f798c5ad..00000000000
--- a/tests/baselines/reference/FunctionExpression1_es6.errors.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-tests/cases/conformance/es6/functionExpressions/FunctionExpression1_es6.ts(1,18): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-
-
-==== tests/cases/conformance/es6/functionExpressions/FunctionExpression1_es6.ts (1 errors) ====
-    var v = function * () { }
-                     ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
\ No newline at end of file
diff --git a/tests/baselines/reference/FunctionExpression1_es6.js b/tests/baselines/reference/FunctionExpression1_es6.js
index 4d2f36843a9..3ae4c3c64f8 100644
--- a/tests/baselines/reference/FunctionExpression1_es6.js
+++ b/tests/baselines/reference/FunctionExpression1_es6.js
@@ -2,4 +2,51 @@
 var v = function * () { }
 
 //// [FunctionExpression1_es6.js]
-var v = function* () { };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+var v = function () { return __generator(this, function (_a) {
+    return [2 /*return*/];
+}); };
diff --git a/tests/baselines/reference/FunctionExpression1_es6.symbols b/tests/baselines/reference/FunctionExpression1_es6.symbols
new file mode 100644
index 00000000000..4e1ed33ea1c
--- /dev/null
+++ b/tests/baselines/reference/FunctionExpression1_es6.symbols
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/es6/functionExpressions/FunctionExpression1_es6.ts ===
+var v = function * () { }
+>v : Symbol(v, Decl(FunctionExpression1_es6.ts, 0, 3))
+
diff --git a/tests/baselines/reference/FunctionExpression1_es6.types b/tests/baselines/reference/FunctionExpression1_es6.types
new file mode 100644
index 00000000000..b52f46ef09b
--- /dev/null
+++ b/tests/baselines/reference/FunctionExpression1_es6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/functionExpressions/FunctionExpression1_es6.ts ===
+var v = function * () { }
+>v : () => Iterator<any>
+>function * () { } : () => Iterator<any>
+
diff --git a/tests/baselines/reference/FunctionExpression2_es6.errors.txt b/tests/baselines/reference/FunctionExpression2_es6.errors.txt
deleted file mode 100644
index 9248962e620..00000000000
--- a/tests/baselines/reference/FunctionExpression2_es6.errors.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-tests/cases/conformance/es6/functionExpressions/FunctionExpression2_es6.ts(1,18): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-
-
-==== tests/cases/conformance/es6/functionExpressions/FunctionExpression2_es6.ts (1 errors) ====
-    var v = function * foo() { }
-                     ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
\ No newline at end of file
diff --git a/tests/baselines/reference/FunctionExpression2_es6.js b/tests/baselines/reference/FunctionExpression2_es6.js
index bd88efcc7ec..1a84d3cc2e0 100644
--- a/tests/baselines/reference/FunctionExpression2_es6.js
+++ b/tests/baselines/reference/FunctionExpression2_es6.js
@@ -2,4 +2,51 @@
 var v = function * foo() { }
 
 //// [FunctionExpression2_es6.js]
-var v = function* foo() { };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+var v = function foo() { return __generator(this, function (_a) {
+    return [2 /*return*/];
+}); };
diff --git a/tests/baselines/reference/FunctionExpression2_es6.symbols b/tests/baselines/reference/FunctionExpression2_es6.symbols
new file mode 100644
index 00000000000..1fc8c3c10d6
--- /dev/null
+++ b/tests/baselines/reference/FunctionExpression2_es6.symbols
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/functionExpressions/FunctionExpression2_es6.ts ===
+var v = function * foo() { }
+>v : Symbol(v, Decl(FunctionExpression2_es6.ts, 0, 3))
+>foo : Symbol(foo, Decl(FunctionExpression2_es6.ts, 0, 7))
+
diff --git a/tests/baselines/reference/FunctionExpression2_es6.types b/tests/baselines/reference/FunctionExpression2_es6.types
new file mode 100644
index 00000000000..e20b2240730
--- /dev/null
+++ b/tests/baselines/reference/FunctionExpression2_es6.types
@@ -0,0 +1,6 @@
+=== tests/cases/conformance/es6/functionExpressions/FunctionExpression2_es6.ts ===
+var v = function * foo() { }
+>v : () => Iterator<any>
+>function * foo() { } : () => Iterator<any>
+>foo : () => Iterator<any>
+
diff --git a/tests/baselines/reference/FunctionPropertyAssignments1_es6.errors.txt b/tests/baselines/reference/FunctionPropertyAssignments1_es6.errors.txt
deleted file mode 100644
index fd463eed02d..00000000000
--- a/tests/baselines/reference/FunctionPropertyAssignments1_es6.errors.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments1_es6.ts(1,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-
-
-==== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments1_es6.ts (1 errors) ====
-    var v = { *foo() { } }
-              ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
\ No newline at end of file
diff --git a/tests/baselines/reference/FunctionPropertyAssignments1_es6.js b/tests/baselines/reference/FunctionPropertyAssignments1_es6.js
index 5975745391a..46cb3f95e7c 100644
--- a/tests/baselines/reference/FunctionPropertyAssignments1_es6.js
+++ b/tests/baselines/reference/FunctionPropertyAssignments1_es6.js
@@ -2,4 +2,51 @@
 var v = { *foo() { } }
 
 //// [FunctionPropertyAssignments1_es6.js]
-var v = { foo: function* () { } };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+var v = { foo: function () { return __generator(this, function (_a) {
+        return [2 /*return*/];
+    }); } };
diff --git a/tests/baselines/reference/FunctionPropertyAssignments1_es6.symbols b/tests/baselines/reference/FunctionPropertyAssignments1_es6.symbols
new file mode 100644
index 00000000000..79aee0f4700
--- /dev/null
+++ b/tests/baselines/reference/FunctionPropertyAssignments1_es6.symbols
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments1_es6.ts ===
+var v = { *foo() { } }
+>v : Symbol(v, Decl(FunctionPropertyAssignments1_es6.ts, 0, 3))
+>foo : Symbol(foo, Decl(FunctionPropertyAssignments1_es6.ts, 0, 9))
+
diff --git a/tests/baselines/reference/FunctionPropertyAssignments1_es6.types b/tests/baselines/reference/FunctionPropertyAssignments1_es6.types
new file mode 100644
index 00000000000..c4b7bd316eb
--- /dev/null
+++ b/tests/baselines/reference/FunctionPropertyAssignments1_es6.types
@@ -0,0 +1,6 @@
+=== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments1_es6.ts ===
+var v = { *foo() { } }
+>v : { foo(): Iterator<any>; }
+>{ *foo() { } } : { foo(): Iterator<any>; }
+>foo : () => Iterator<any>
+
diff --git a/tests/baselines/reference/FunctionPropertyAssignments2_es6.js b/tests/baselines/reference/FunctionPropertyAssignments2_es6.js
index b055960b6a8..bfa38087472 100644
--- a/tests/baselines/reference/FunctionPropertyAssignments2_es6.js
+++ b/tests/baselines/reference/FunctionPropertyAssignments2_es6.js
@@ -2,4 +2,51 @@
 var v = { *() { } }
 
 //// [FunctionPropertyAssignments2_es6.js]
-var v = { : function* () { } };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+var v = { : function () { return __generator(this, function (_a) {
+        return [2 /*return*/];
+    }); } };
diff --git a/tests/baselines/reference/FunctionPropertyAssignments3_es6.js b/tests/baselines/reference/FunctionPropertyAssignments3_es6.js
index 9642c28529d..81bc77b6d12 100644
--- a/tests/baselines/reference/FunctionPropertyAssignments3_es6.js
+++ b/tests/baselines/reference/FunctionPropertyAssignments3_es6.js
@@ -2,4 +2,51 @@
 var v = { *{ } }
 
 //// [FunctionPropertyAssignments3_es6.js]
-var v = { : function* () { } };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+var v = { : function () { return __generator(this, function (_a) {
+        return [2 /*return*/];
+    }); } };
diff --git a/tests/baselines/reference/FunctionPropertyAssignments4_es6.js b/tests/baselines/reference/FunctionPropertyAssignments4_es6.js
index a76405e34df..f90bbe0c074 100644
--- a/tests/baselines/reference/FunctionPropertyAssignments4_es6.js
+++ b/tests/baselines/reference/FunctionPropertyAssignments4_es6.js
@@ -2,4 +2,49 @@
 var v = { * }
 
 //// [FunctionPropertyAssignments4_es6.js]
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
 var v = {};
diff --git a/tests/baselines/reference/FunctionPropertyAssignments5_es6.errors.txt b/tests/baselines/reference/FunctionPropertyAssignments5_es6.errors.txt
index 35185fdb7c6..143b764c08c 100644
--- a/tests/baselines/reference/FunctionPropertyAssignments5_es6.errors.txt
+++ b/tests/baselines/reference/FunctionPropertyAssignments5_es6.errors.txt
@@ -1,10 +1,7 @@
-tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts(1,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts(1,13): error TS2304: Cannot find name 'foo'.
 
 
-==== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts (2 errors) ====
+==== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts (1 errors) ====
     var v = { *[foo()]() { } }
-              ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
                 ~~~
 !!! error TS2304: Cannot find name 'foo'.
\ No newline at end of file
diff --git a/tests/baselines/reference/FunctionPropertyAssignments5_es6.js b/tests/baselines/reference/FunctionPropertyAssignments5_es6.js
index ba25922b670..0341887a811 100644
--- a/tests/baselines/reference/FunctionPropertyAssignments5_es6.js
+++ b/tests/baselines/reference/FunctionPropertyAssignments5_es6.js
@@ -2,5 +2,52 @@
 var v = { *[foo()]() { } }
 
 //// [FunctionPropertyAssignments5_es6.js]
-var v = (_a = {}, _a[foo()] = function* () { }, _a);
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+var v = (_a = {}, _a[foo()] = function () { return __generator(this, function (_a) {
+    return [2 /*return*/];
+}); }, _a);
 var _a;
diff --git a/tests/baselines/reference/FunctionPropertyAssignments6_es6.js b/tests/baselines/reference/FunctionPropertyAssignments6_es6.js
index edcd227f7b9..da0febd338a 100644
--- a/tests/baselines/reference/FunctionPropertyAssignments6_es6.js
+++ b/tests/baselines/reference/FunctionPropertyAssignments6_es6.js
@@ -2,4 +2,51 @@
 var v = { *<T>() { } }
 
 //// [FunctionPropertyAssignments6_es6.js]
-var v = { : function* () { } };
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+var v = { : function () { return __generator(this, function (_a) {
+        return [2 /*return*/];
+    }); } };
diff --git a/tests/baselines/reference/MemberFunctionDeclaration1_es6.errors.txt b/tests/baselines/reference/MemberFunctionDeclaration1_es6.errors.txt
deleted file mode 100644
index 25cb4ba4240..00000000000
--- a/tests/baselines/reference/MemberFunctionDeclaration1_es6.errors.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration1_es6.ts(2,4): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-
-
-==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration1_es6.ts (1 errors) ====
-    class C {
-       *foo() { }
-       ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/MemberFunctionDeclaration1_es6.js b/tests/baselines/reference/MemberFunctionDeclaration1_es6.js
index ec37b3370b0..0fcf45a69ab 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration1_es6.js
+++ b/tests/baselines/reference/MemberFunctionDeclaration1_es6.js
@@ -4,9 +4,56 @@ class C {
 }
 
 //// [MemberFunctionDeclaration1_es6.js]
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
 var C = (function () {
     function C() {
     }
-    C.prototype.foo = function* () { };
+    C.prototype.foo = function () { return __generator(this, function (_a) {
+        return [2 /*return*/];
+    }); };
     return C;
 }());
diff --git a/tests/baselines/reference/MemberFunctionDeclaration1_es6.symbols b/tests/baselines/reference/MemberFunctionDeclaration1_es6.symbols
new file mode 100644
index 00000000000..a1862ea9209
--- /dev/null
+++ b/tests/baselines/reference/MemberFunctionDeclaration1_es6.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration1_es6.ts ===
+class C {
+>C : Symbol(C, Decl(MemberFunctionDeclaration1_es6.ts, 0, 0))
+
+   *foo() { }
+>foo : Symbol(C.foo, Decl(MemberFunctionDeclaration1_es6.ts, 0, 9))
+}
diff --git a/tests/baselines/reference/MemberFunctionDeclaration1_es6.types b/tests/baselines/reference/MemberFunctionDeclaration1_es6.types
new file mode 100644
index 00000000000..d1799bcb2d8
--- /dev/null
+++ b/tests/baselines/reference/MemberFunctionDeclaration1_es6.types
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration1_es6.ts ===
+class C {
+>C : C
+
+   *foo() { }
+>foo : () => Iterator<any>
+}
diff --git a/tests/baselines/reference/MemberFunctionDeclaration2_es6.errors.txt b/tests/baselines/reference/MemberFunctionDeclaration2_es6.errors.txt
deleted file mode 100644
index 8277d6f1f67..00000000000
--- a/tests/baselines/reference/MemberFunctionDeclaration2_es6.errors.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration2_es6.ts(2,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-
-
-==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration2_es6.ts (1 errors) ====
-    class C {
-       public * foo() { }
-              ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/MemberFunctionDeclaration2_es6.js b/tests/baselines/reference/MemberFunctionDeclaration2_es6.js
index 54550ef72e7..c187db3d68d 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration2_es6.js
+++ b/tests/baselines/reference/MemberFunctionDeclaration2_es6.js
@@ -4,9 +4,56 @@ class C {
 }
 
 //// [MemberFunctionDeclaration2_es6.js]
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
 var C = (function () {
     function C() {
     }
-    C.prototype.foo = function* () { };
+    C.prototype.foo = function () { return __generator(this, function (_a) {
+        return [2 /*return*/];
+    }); };
     return C;
 }());
diff --git a/tests/baselines/reference/MemberFunctionDeclaration2_es6.symbols b/tests/baselines/reference/MemberFunctionDeclaration2_es6.symbols
new file mode 100644
index 00000000000..ac380db0268
--- /dev/null
+++ b/tests/baselines/reference/MemberFunctionDeclaration2_es6.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration2_es6.ts ===
+class C {
+>C : Symbol(C, Decl(MemberFunctionDeclaration2_es6.ts, 0, 0))
+
+   public * foo() { }
+>foo : Symbol(C.foo, Decl(MemberFunctionDeclaration2_es6.ts, 0, 9))
+}
diff --git a/tests/baselines/reference/MemberFunctionDeclaration2_es6.types b/tests/baselines/reference/MemberFunctionDeclaration2_es6.types
new file mode 100644
index 00000000000..0e7532e2503
--- /dev/null
+++ b/tests/baselines/reference/MemberFunctionDeclaration2_es6.types
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration2_es6.ts ===
+class C {
+>C : C
+
+   public * foo() { }
+>foo : () => Iterator<any>
+}
diff --git a/tests/baselines/reference/MemberFunctionDeclaration3_es6.errors.txt b/tests/baselines/reference/MemberFunctionDeclaration3_es6.errors.txt
index 3fd821bafdf..fdfe7425320 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration3_es6.errors.txt
+++ b/tests/baselines/reference/MemberFunctionDeclaration3_es6.errors.txt
@@ -1,12 +1,9 @@
-tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts(2,4): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts(2,6): error TS2304: Cannot find name 'foo'.
 
 
-==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts (2 errors) ====
+==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts (1 errors) ====
     class C {
        *[foo]() { }
-       ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
          ~~~
 !!! error TS2304: Cannot find name 'foo'.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/MemberFunctionDeclaration3_es6.js b/tests/baselines/reference/MemberFunctionDeclaration3_es6.js
index 07d9a021fcd..8873d649ad4 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration3_es6.js
+++ b/tests/baselines/reference/MemberFunctionDeclaration3_es6.js
@@ -4,9 +4,56 @@ class C {
 }
 
 //// [MemberFunctionDeclaration3_es6.js]
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
 var C = (function () {
     function C() {
     }
-    C.prototype[foo] = function* () { };
+    C.prototype[foo] = function () { return __generator(this, function (_a) {
+        return [2 /*return*/];
+    }); };
     return C;
 }());
diff --git a/tests/baselines/reference/MemberFunctionDeclaration4_es6.js b/tests/baselines/reference/MemberFunctionDeclaration4_es6.js
index f791d4a1156..28ee654eb82 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration4_es6.js
+++ b/tests/baselines/reference/MemberFunctionDeclaration4_es6.js
@@ -4,9 +4,56 @@ class C {
 }
 
 //// [MemberFunctionDeclaration4_es6.js]
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
 var C = (function () {
     function C() {
     }
-    C.prototype. = function* () { };
+    C.prototype. = function () { return __generator(this, function (_a) {
+        return [2 /*return*/];
+    }); };
     return C;
 }());
diff --git a/tests/baselines/reference/MemberFunctionDeclaration5_es6.js b/tests/baselines/reference/MemberFunctionDeclaration5_es6.js
index 2303c5e0f62..107d2cb8d17 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration5_es6.js
+++ b/tests/baselines/reference/MemberFunctionDeclaration5_es6.js
@@ -4,6 +4,51 @@ class C {
 }
 
 //// [MemberFunctionDeclaration5_es6.js]
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
 var C = (function () {
     function C() {
     }
diff --git a/tests/baselines/reference/MemberFunctionDeclaration6_es6.js b/tests/baselines/reference/MemberFunctionDeclaration6_es6.js
index b2a753d7ce0..fe2dee0c621 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration6_es6.js
+++ b/tests/baselines/reference/MemberFunctionDeclaration6_es6.js
@@ -4,6 +4,51 @@ class C {
 }
 
 //// [MemberFunctionDeclaration6_es6.js]
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
 var C = (function () {
     function C() {
     }
diff --git a/tests/baselines/reference/MemberFunctionDeclaration7_es6.errors.txt b/tests/baselines/reference/MemberFunctionDeclaration7_es6.errors.txt
deleted file mode 100644
index cd4c49bdd6d..00000000000
--- a/tests/baselines/reference/MemberFunctionDeclaration7_es6.errors.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration7_es6.ts(2,4): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-
-
-==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration7_es6.ts (1 errors) ====
-    class C {
-       *foo<T>() { }
-       ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/MemberFunctionDeclaration7_es6.js b/tests/baselines/reference/MemberFunctionDeclaration7_es6.js
index 8e19f0db333..3145c04b1a6 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration7_es6.js
+++ b/tests/baselines/reference/MemberFunctionDeclaration7_es6.js
@@ -4,9 +4,56 @@ class C {
 }
 
 //// [MemberFunctionDeclaration7_es6.js]
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
 var C = (function () {
     function C() {
     }
-    C.prototype.foo = function* () { };
+    C.prototype.foo = function () { return __generator(this, function (_a) {
+        return [2 /*return*/];
+    }); };
     return C;
 }());
diff --git a/tests/baselines/reference/MemberFunctionDeclaration7_es6.symbols b/tests/baselines/reference/MemberFunctionDeclaration7_es6.symbols
new file mode 100644
index 00000000000..fa07b61e4a6
--- /dev/null
+++ b/tests/baselines/reference/MemberFunctionDeclaration7_es6.symbols
@@ -0,0 +1,8 @@
+=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration7_es6.ts ===
+class C {
+>C : Symbol(C, Decl(MemberFunctionDeclaration7_es6.ts, 0, 0))
+
+   *foo<T>() { }
+>foo : Symbol(C.foo, Decl(MemberFunctionDeclaration7_es6.ts, 0, 9))
+>T : Symbol(T, Decl(MemberFunctionDeclaration7_es6.ts, 1, 8))
+}
diff --git a/tests/baselines/reference/MemberFunctionDeclaration7_es6.types b/tests/baselines/reference/MemberFunctionDeclaration7_es6.types
new file mode 100644
index 00000000000..4ecce6a5f27
--- /dev/null
+++ b/tests/baselines/reference/MemberFunctionDeclaration7_es6.types
@@ -0,0 +1,8 @@
+=== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration7_es6.ts ===
+class C {
+>C : C
+
+   *foo<T>() { }
+>foo : <T>() => Iterator<any>
+>T : T
+}
diff --git a/tests/baselines/reference/YieldExpression10_es6.errors.txt b/tests/baselines/reference/YieldExpression10_es6.errors.txt
index 7bf534e4188..9e48fefc10a 100644
--- a/tests/baselines/reference/YieldExpression10_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression10_es6.errors.txt
@@ -1,11 +1,8 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts(1,11): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts(2,11): error TS2304: Cannot find name 'foo'.
 
 
-==== tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts (2 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts (1 errors) ====
     var v = { * foo() {
-              ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
         yield(foo);
               ~~~
 !!! error TS2304: Cannot find name 'foo'.
diff --git a/tests/baselines/reference/YieldExpression10_es6.js b/tests/baselines/reference/YieldExpression10_es6.js
index e1dd44b676b..02cf859017a 100644
--- a/tests/baselines/reference/YieldExpression10_es6.js
+++ b/tests/baselines/reference/YieldExpression10_es6.js
@@ -6,7 +6,59 @@ var v = { * foo() {
 
 
 //// [YieldExpression10_es6.js]
-var v = { foo: function* () {
-        yield (foo);
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+var v = { foo: function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (foo)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
     }
 };
diff --git a/tests/baselines/reference/YieldExpression11_es6.errors.txt b/tests/baselines/reference/YieldExpression11_es6.errors.txt
index f5d3458520f..223389e4e39 100644
--- a/tests/baselines/reference/YieldExpression11_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression11_es6.errors.txt
@@ -1,12 +1,9 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts(2,3): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts(3,11): error TS2663: Cannot find name 'foo'. Did you mean the instance member 'this.foo'?
 
 
-==== tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts (2 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression11_es6.ts (1 errors) ====
     class C {
       *foo() {
-      ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
         yield(foo);
               ~~~
 !!! error TS2663: Cannot find name 'foo'. Did you mean the instance member 'this.foo'?
diff --git a/tests/baselines/reference/YieldExpression11_es6.js b/tests/baselines/reference/YieldExpression11_es6.js
index fb4f83c7197..8e1dad94b1f 100644
--- a/tests/baselines/reference/YieldExpression11_es6.js
+++ b/tests/baselines/reference/YieldExpression11_es6.js
@@ -6,11 +6,63 @@ class C {
 }
 
 //// [YieldExpression11_es6.js]
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
 var C = (function () {
     function C() {
     }
-    C.prototype.foo = function* () {
-        yield (foo);
+    C.prototype.foo = function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (foo)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
     };
     return C;
 }());
diff --git a/tests/baselines/reference/YieldExpression13_es6.errors.txt b/tests/baselines/reference/YieldExpression13_es6.errors.txt
deleted file mode 100644
index 99088448886..00000000000
--- a/tests/baselines/reference/YieldExpression13_es6.errors.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression13_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-
-
-==== tests/cases/conformance/es6/yieldExpressions/YieldExpression13_es6.ts (1 errors) ====
-    function* foo() { yield }
-            ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression13_es6.js b/tests/baselines/reference/YieldExpression13_es6.js
index c75e964675a..b24c9b09fd9 100644
--- a/tests/baselines/reference/YieldExpression13_es6.js
+++ b/tests/baselines/reference/YieldExpression13_es6.js
@@ -2,4 +2,56 @@
 function* foo() { yield }
 
 //// [YieldExpression13_es6.js]
-function* foo() { yield; }
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function foo() { return __generator(this, function (_a) {
+    switch (_a.label) {
+        case 0: return [4 /*yield*/];
+        case 1:
+            _a.sent();
+            return [2 /*return*/];
+    }
+}); }
diff --git a/tests/baselines/reference/YieldExpression13_es6.symbols b/tests/baselines/reference/YieldExpression13_es6.symbols
new file mode 100644
index 00000000000..f2e1b100c9d
--- /dev/null
+++ b/tests/baselines/reference/YieldExpression13_es6.symbols
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/es6/yieldExpressions/YieldExpression13_es6.ts ===
+function* foo() { yield }
+>foo : Symbol(foo, Decl(YieldExpression13_es6.ts, 0, 0))
+
diff --git a/tests/baselines/reference/YieldExpression13_es6.types b/tests/baselines/reference/YieldExpression13_es6.types
new file mode 100644
index 00000000000..19de1796b6c
--- /dev/null
+++ b/tests/baselines/reference/YieldExpression13_es6.types
@@ -0,0 +1,5 @@
+=== tests/cases/conformance/es6/yieldExpressions/YieldExpression13_es6.ts ===
+function* foo() { yield }
+>foo : () => Iterator<any>
+>yield : any
+
diff --git a/tests/baselines/reference/YieldExpression16_es6.errors.txt b/tests/baselines/reference/YieldExpression16_es6.errors.txt
index 0645f5d818a..94e082f4c27 100644
--- a/tests/baselines/reference/YieldExpression16_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression16_es6.errors.txt
@@ -1,11 +1,8 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts(3,5): error TS1163: A 'yield' expression is only allowed in a generator body.
 
 
-==== tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts (2 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts (1 errors) ====
     function* foo() {
-            ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
       function bar() {
         yield foo;
         ~~~~~
diff --git a/tests/baselines/reference/YieldExpression16_es6.js b/tests/baselines/reference/YieldExpression16_es6.js
index 0937cfedcb9..d409d8154c9 100644
--- a/tests/baselines/reference/YieldExpression16_es6.js
+++ b/tests/baselines/reference/YieldExpression16_es6.js
@@ -6,8 +6,56 @@ function* foo() {
 }
 
 //// [YieldExpression16_es6.js]
-function* foo() {
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function foo() {
     function bar() {
         yield foo;
     }
+    return __generator(this, function (_a) {
+        return [2 /*return*/];
+    });
 }
diff --git a/tests/baselines/reference/YieldExpression19_es6.errors.txt b/tests/baselines/reference/YieldExpression19_es6.errors.txt
deleted file mode 100644
index f07cfc1db78..00000000000
--- a/tests/baselines/reference/YieldExpression19_es6.errors.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts(3,13): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-
-
-==== tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts (2 errors) ====
-    function*foo() {
-            ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-      function bar() {
-        function* quux() {
-                ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-          yield(foo);
-        }
-      }
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression19_es6.js b/tests/baselines/reference/YieldExpression19_es6.js
index 444c7af7be1..276979e9008 100644
--- a/tests/baselines/reference/YieldExpression19_es6.js
+++ b/tests/baselines/reference/YieldExpression19_es6.js
@@ -8,10 +8,65 @@ function*foo() {
 }
 
 //// [YieldExpression19_es6.js]
-function* foo() {
-    function bar() {
-        function* quux() {
-            yield (foo);
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
         }
     }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function foo() {
+    function bar() {
+        function quux() {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (foo)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }
+    }
+    return __generator(this, function (_a) {
+        return [2 /*return*/];
+    });
 }
diff --git a/tests/baselines/reference/YieldExpression19_es6.symbols b/tests/baselines/reference/YieldExpression19_es6.symbols
new file mode 100644
index 00000000000..609102001c4
--- /dev/null
+++ b/tests/baselines/reference/YieldExpression19_es6.symbols
@@ -0,0 +1,15 @@
+=== tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts ===
+function*foo() {
+>foo : Symbol(foo, Decl(YieldExpression19_es6.ts, 0, 0))
+
+  function bar() {
+>bar : Symbol(bar, Decl(YieldExpression19_es6.ts, 0, 16))
+
+    function* quux() {
+>quux : Symbol(quux, Decl(YieldExpression19_es6.ts, 1, 18))
+
+      yield(foo);
+>foo : Symbol(foo, Decl(YieldExpression19_es6.ts, 0, 0))
+    }
+  }
+}
diff --git a/tests/baselines/reference/YieldExpression19_es6.types b/tests/baselines/reference/YieldExpression19_es6.types
new file mode 100644
index 00000000000..6b9b2cdf67a
--- /dev/null
+++ b/tests/baselines/reference/YieldExpression19_es6.types
@@ -0,0 +1,17 @@
+=== tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts ===
+function*foo() {
+>foo : () => Iterator<any>
+
+  function bar() {
+>bar : () => void
+
+    function* quux() {
+>quux : () => Iterator<() => Iterator<any>>
+
+      yield(foo);
+>yield(foo) : any
+>(foo) : () => Iterator<any>
+>foo : () => Iterator<any>
+    }
+  }
+}
diff --git a/tests/baselines/reference/YieldExpression3_es6.errors.txt b/tests/baselines/reference/YieldExpression3_es6.errors.txt
deleted file mode 100644
index 9f07c13184e..00000000000
--- a/tests/baselines/reference/YieldExpression3_es6.errors.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression3_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-
-
-==== tests/cases/conformance/es6/yieldExpressions/YieldExpression3_es6.ts (1 errors) ====
-    function* foo() {
-            ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-      yield
-      yield
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression3_es6.js b/tests/baselines/reference/YieldExpression3_es6.js
index 737b3534886..daaae105783 100644
--- a/tests/baselines/reference/YieldExpression3_es6.js
+++ b/tests/baselines/reference/YieldExpression3_es6.js
@@ -5,7 +5,61 @@ function* foo() {
 }
 
 //// [YieldExpression3_es6.js]
-function* foo() {
-    yield;
-    yield;
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function foo() {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/];
+            case 1:
+                _a.sent();
+                return [4 /*yield*/];
+            case 2:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
 }
diff --git a/tests/baselines/reference/YieldExpression3_es6.symbols b/tests/baselines/reference/YieldExpression3_es6.symbols
new file mode 100644
index 00000000000..4ab5b42688f
--- /dev/null
+++ b/tests/baselines/reference/YieldExpression3_es6.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/yieldExpressions/YieldExpression3_es6.ts ===
+function* foo() {
+>foo : Symbol(foo, Decl(YieldExpression3_es6.ts, 0, 0))
+
+  yield
+  yield
+}
diff --git a/tests/baselines/reference/YieldExpression3_es6.types b/tests/baselines/reference/YieldExpression3_es6.types
new file mode 100644
index 00000000000..bc979a5fdbf
--- /dev/null
+++ b/tests/baselines/reference/YieldExpression3_es6.types
@@ -0,0 +1,10 @@
+=== tests/cases/conformance/es6/yieldExpressions/YieldExpression3_es6.ts ===
+function* foo() {
+>foo : () => Iterator<any>
+
+  yield
+>yield : any
+
+  yield
+>yield : any
+}
diff --git a/tests/baselines/reference/YieldExpression4_es6.errors.txt b/tests/baselines/reference/YieldExpression4_es6.errors.txt
deleted file mode 100644
index 6c9a5796ee8..00000000000
--- a/tests/baselines/reference/YieldExpression4_es6.errors.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression4_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-
-
-==== tests/cases/conformance/es6/yieldExpressions/YieldExpression4_es6.ts (1 errors) ====
-    function* foo() {
-            ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-      yield;
-      yield;
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression4_es6.js b/tests/baselines/reference/YieldExpression4_es6.js
index c97a7949b2b..c8204288cf4 100644
--- a/tests/baselines/reference/YieldExpression4_es6.js
+++ b/tests/baselines/reference/YieldExpression4_es6.js
@@ -5,7 +5,61 @@ function* foo() {
 }
 
 //// [YieldExpression4_es6.js]
-function* foo() {
-    yield;
-    yield;
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function foo() {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/];
+            case 1:
+                _a.sent();
+                return [4 /*yield*/];
+            case 2:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
 }
diff --git a/tests/baselines/reference/YieldExpression4_es6.symbols b/tests/baselines/reference/YieldExpression4_es6.symbols
new file mode 100644
index 00000000000..7954fb705e6
--- /dev/null
+++ b/tests/baselines/reference/YieldExpression4_es6.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/yieldExpressions/YieldExpression4_es6.ts ===
+function* foo() {
+>foo : Symbol(foo, Decl(YieldExpression4_es6.ts, 0, 0))
+
+  yield;
+  yield;
+}
diff --git a/tests/baselines/reference/YieldExpression4_es6.types b/tests/baselines/reference/YieldExpression4_es6.types
new file mode 100644
index 00000000000..d7e97de34bb
--- /dev/null
+++ b/tests/baselines/reference/YieldExpression4_es6.types
@@ -0,0 +1,10 @@
+=== tests/cases/conformance/es6/yieldExpressions/YieldExpression4_es6.ts ===
+function* foo() {
+>foo : () => Iterator<any>
+
+  yield;
+>yield : any
+
+  yield;
+>yield : any
+}
diff --git a/tests/baselines/reference/YieldExpression5_es6.js b/tests/baselines/reference/YieldExpression5_es6.js
index 8599cfdb6bb..06c126d0c23 100644
--- a/tests/baselines/reference/YieldExpression5_es6.js
+++ b/tests/baselines/reference/YieldExpression5_es6.js
@@ -4,6 +4,58 @@ function* foo() {
 }
 
 //// [YieldExpression5_es6.js]
-function* foo() {
-    yield* ;
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function foo() {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [5 /*yield**/, ];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
 }
diff --git a/tests/baselines/reference/YieldExpression6_es6.errors.txt b/tests/baselines/reference/YieldExpression6_es6.errors.txt
index f2fc90b81b4..1aec594e8d6 100644
--- a/tests/baselines/reference/YieldExpression6_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression6_es6.errors.txt
@@ -1,12 +1,9 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts(2,9): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
+tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts(2,9): error TS2489: An iterator must have a 'next()' method.
 
 
-==== tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts (2 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression6_es6.ts (1 errors) ====
     function* foo() {
-            ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
       yield*foo
             ~~~
-!!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
+!!! error TS2489: An iterator must have a 'next()' method.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression6_es6.js b/tests/baselines/reference/YieldExpression6_es6.js
index c511daec989..66450dc366d 100644
--- a/tests/baselines/reference/YieldExpression6_es6.js
+++ b/tests/baselines/reference/YieldExpression6_es6.js
@@ -4,6 +4,58 @@ function* foo() {
 }
 
 //// [YieldExpression6_es6.js]
-function* foo() {
-    yield* foo;
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function foo() {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [5 /*yield**/, foo];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
 }
diff --git a/tests/baselines/reference/YieldExpression7_es6.errors.txt b/tests/baselines/reference/YieldExpression7_es6.errors.txt
deleted file mode 100644
index f929dff0a2a..00000000000
--- a/tests/baselines/reference/YieldExpression7_es6.errors.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression7_es6.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-
-
-==== tests/cases/conformance/es6/yieldExpressions/YieldExpression7_es6.ts (1 errors) ====
-    function* foo() {
-            ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-      yield foo
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression7_es6.js b/tests/baselines/reference/YieldExpression7_es6.js
index 8055b96ec73..58ef47222e1 100644
--- a/tests/baselines/reference/YieldExpression7_es6.js
+++ b/tests/baselines/reference/YieldExpression7_es6.js
@@ -4,6 +4,58 @@ function* foo() {
 }
 
 //// [YieldExpression7_es6.js]
-function* foo() {
-    yield foo;
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function foo() {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, foo];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
 }
diff --git a/tests/baselines/reference/YieldExpression7_es6.symbols b/tests/baselines/reference/YieldExpression7_es6.symbols
new file mode 100644
index 00000000000..53737c94be9
--- /dev/null
+++ b/tests/baselines/reference/YieldExpression7_es6.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/conformance/es6/yieldExpressions/YieldExpression7_es6.ts ===
+function* foo() {
+>foo : Symbol(foo, Decl(YieldExpression7_es6.ts, 0, 0))
+
+  yield foo
+>foo : Symbol(foo, Decl(YieldExpression7_es6.ts, 0, 0))
+}
diff --git a/tests/baselines/reference/YieldExpression7_es6.types b/tests/baselines/reference/YieldExpression7_es6.types
new file mode 100644
index 00000000000..889ca36d7a9
--- /dev/null
+++ b/tests/baselines/reference/YieldExpression7_es6.types
@@ -0,0 +1,8 @@
+=== tests/cases/conformance/es6/yieldExpressions/YieldExpression7_es6.ts ===
+function* foo() {
+>foo : () => Iterator<typeof foo>
+
+  yield foo
+>yield foo : any
+>foo : () => Iterator<typeof foo>
+}
diff --git a/tests/baselines/reference/YieldExpression8_es6.errors.txt b/tests/baselines/reference/YieldExpression8_es6.errors.txt
index aef1fbc122d..f4dd30b1a19 100644
--- a/tests/baselines/reference/YieldExpression8_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression8_es6.errors.txt
@@ -1,13 +1,10 @@
 tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts(1,1): error TS2304: Cannot find name 'yield'.
-tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts(2,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 
 
-==== tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts (2 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression8_es6.ts (1 errors) ====
     yield(foo);
     ~~~~~
 !!! error TS2304: Cannot find name 'yield'.
     function* foo() {
-            ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
       yield(foo);
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldExpression8_es6.js b/tests/baselines/reference/YieldExpression8_es6.js
index cc92b79c722..65620862704 100644
--- a/tests/baselines/reference/YieldExpression8_es6.js
+++ b/tests/baselines/reference/YieldExpression8_es6.js
@@ -5,7 +5,59 @@ function* foo() {
 }
 
 //// [YieldExpression8_es6.js]
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
 yield(foo);
-function* foo() {
-    yield (foo);
+function foo() {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (foo)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
 }
diff --git a/tests/baselines/reference/YieldExpression9_es6.errors.txt b/tests/baselines/reference/YieldExpression9_es6.errors.txt
index 2ad925a90a0..1241e615f79 100644
--- a/tests/baselines/reference/YieldExpression9_es6.errors.txt
+++ b/tests/baselines/reference/YieldExpression9_es6.errors.txt
@@ -1,11 +1,8 @@
-tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts(1,17): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
 tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts(2,9): error TS2304: Cannot find name 'foo'.
 
 
-==== tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts (2 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts (1 errors) ====
     var v = function*() {
-                    ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
       yield(foo);
             ~~~
 !!! error TS2304: Cannot find name 'foo'.
diff --git a/tests/baselines/reference/YieldExpression9_es6.js b/tests/baselines/reference/YieldExpression9_es6.js
index a2ffa0fa01b..db44a5409bd 100644
--- a/tests/baselines/reference/YieldExpression9_es6.js
+++ b/tests/baselines/reference/YieldExpression9_es6.js
@@ -4,6 +4,58 @@ var v = function*() {
 }
 
 //// [YieldExpression9_es6.js]
-var v = function* () {
-    yield (foo);
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+var v = function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (foo)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
 };
diff --git a/tests/baselines/reference/YieldStarExpression3_es6.js b/tests/baselines/reference/YieldStarExpression3_es6.js
index e64306dc4cf..0691c77a48f 100644
--- a/tests/baselines/reference/YieldStarExpression3_es6.js
+++ b/tests/baselines/reference/YieldStarExpression3_es6.js
@@ -4,6 +4,58 @@ function *g() {
 }
 
 //// [YieldStarExpression3_es6.js]
-function* g() {
-    yield* ;
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function g() {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [5 /*yield**/, ];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
 }
diff --git a/tests/baselines/reference/YieldStarExpression4_es6.errors.txt b/tests/baselines/reference/YieldStarExpression4_es6.errors.txt
index c58844a9288..f75f8553bbb 100644
--- a/tests/baselines/reference/YieldStarExpression4_es6.errors.txt
+++ b/tests/baselines/reference/YieldStarExpression4_es6.errors.txt
@@ -1,12 +1,9 @@
-tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts(1,10): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts(2,13): error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
+tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts(2,13): error TS2489: An iterator must have a 'next()' method.
 
 
-==== tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts (2 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts (1 errors) ====
     function *g() {
-             ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
         yield * [];
                 ~~
-!!! error TS2488: Type must have a '[Symbol.iterator]()' method that returns an iterator.
+!!! error TS2489: An iterator must have a 'next()' method.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/YieldStarExpression4_es6.js b/tests/baselines/reference/YieldStarExpression4_es6.js
index 8ec5fa0c933..43d28dfed29 100644
--- a/tests/baselines/reference/YieldStarExpression4_es6.js
+++ b/tests/baselines/reference/YieldStarExpression4_es6.js
@@ -4,6 +4,58 @@ function *g() {
 }
 
 //// [YieldStarExpression4_es6.js]
-function* g() {
-    yield* [];
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function g() {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [5 /*yield**/, []];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
 }
diff --git a/tests/baselines/reference/asyncArrowFunction7_es5.js b/tests/baselines/reference/asyncArrowFunction7_es5.js
index 19e589fa542..f2edb2b6537 100644
--- a/tests/baselines/reference/asyncArrowFunction7_es5.js
+++ b/tests/baselines/reference/asyncArrowFunction7_es5.js
@@ -9,7 +9,7 @@ var bar = async (): Promise<void> => {
 //// [asyncArrowFunction7_es5.js]
 var _this = this;
 var bar = function () { return __awaiter(_this, void 0, void 0, function () {
-    _this = this;
+    var _this = this;
     var foo;
     return __generator(this, function (_a) {
         foo = function (a) {
@@ -22,4 +22,4 @@ var bar = function () { return __awaiter(_this, void 0, void 0, function () {
         };
         return [2 /*return*/];
     });
-}); var _this; };
+}); };
diff --git a/tests/baselines/reference/asyncAwaitIsolatedModules_es5.js b/tests/baselines/reference/asyncAwaitIsolatedModules_es5.js
index 95416f3aaa2..14ae6599ed3 100644
--- a/tests/baselines/reference/asyncAwaitIsolatedModules_es5.js
+++ b/tests/baselines/reference/asyncAwaitIsolatedModules_es5.js
@@ -50,7 +50,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, f;
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
         while (1) {
@@ -60,9 +60,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
                 case 2: return { value: op[1], done: true };
             }
             try {
-                switch (f = 1, op[0]) {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
                     case 0: case 1: sent = op; break;
                     case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
                     case 7: op = _.stack.pop(), _.trys.pop(); continue;
                     default:
                         var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
@@ -76,8 +84,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
                 }
                 op = body.call(thisArg, _);
             }
-            catch (e) { op = [6, e]; }
-            finally { f = 0, sent = void 0; }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
         }
     }
     return {
diff --git a/tests/baselines/reference/asyncAwait_es5.js b/tests/baselines/reference/asyncAwait_es5.js
index e148de70ad2..9febfa6f869 100644
--- a/tests/baselines/reference/asyncAwait_es5.js
+++ b/tests/baselines/reference/asyncAwait_es5.js
@@ -49,7 +49,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, f;
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
         while (1) {
@@ -59,9 +59,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
                 case 2: return { value: op[1], done: true };
             }
             try {
-                switch (f = 1, op[0]) {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
                     case 0: case 1: sent = op; break;
                     case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
                     case 7: op = _.stack.pop(), _.trys.pop(); continue;
                     default:
                         var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
@@ -75,8 +83,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
                 }
                 op = body.call(thisArg, _);
             }
-            catch (e) { op = [6, e]; }
-            finally { f = 0, sent = void 0; }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
         }
     }
     return {
diff --git a/tests/baselines/reference/asyncFunctionNoReturnType.js b/tests/baselines/reference/asyncFunctionNoReturnType.js
index a3635b85a09..4a223d33508 100644
--- a/tests/baselines/reference/asyncFunctionNoReturnType.js
+++ b/tests/baselines/reference/asyncFunctionNoReturnType.js
@@ -15,7 +15,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, f;
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
         while (1) {
@@ -25,9 +25,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
                 case 2: return { value: op[1], done: true };
             }
             try {
-                switch (f = 1, op[0]) {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
                     case 0: case 1: sent = op; break;
                     case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
                     case 7: op = _.stack.pop(), _.trys.pop(); continue;
                     default:
                         var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
@@ -41,8 +49,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
                 }
                 op = body.call(thisArg, _);
             }
-            catch (e) { op = [6, e]; }
-            finally { f = 0, sent = void 0; }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
         }
     }
     return {
diff --git a/tests/baselines/reference/asyncImportedPromise_es5.js b/tests/baselines/reference/asyncImportedPromise_es5.js
index 54d1b0fdac8..c95a21f9319 100644
--- a/tests/baselines/reference/asyncImportedPromise_es5.js
+++ b/tests/baselines/reference/asyncImportedPromise_es5.js
@@ -35,7 +35,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, f;
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
         while (1) {
@@ -45,9 +45,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
                 case 2: return { value: op[1], done: true };
             }
             try {
-                switch (f = 1, op[0]) {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
                     case 0: case 1: sent = op; break;
                     case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
                     case 7: op = _.stack.pop(), _.trys.pop(); continue;
                     default:
                         var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
@@ -61,8 +69,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
                 }
                 op = body.call(thisArg, _);
             }
-            catch (e) { op = [6, e]; }
-            finally { f = 0, sent = void 0; }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
         }
     }
     return {
diff --git a/tests/baselines/reference/asyncMultiFile_es5.js b/tests/baselines/reference/asyncMultiFile_es5.js
index 197127c5f10..15a9166e943 100644
--- a/tests/baselines/reference/asyncMultiFile_es5.js
+++ b/tests/baselines/reference/asyncMultiFile_es5.js
@@ -15,7 +15,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, f;
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
         while (1) {
@@ -25,9 +25,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
                 case 2: return { value: op[1], done: true };
             }
             try {
-                switch (f = 1, op[0]) {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
                     case 0: case 1: sent = op; break;
                     case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
                     case 7: op = _.stack.pop(), _.trys.pop(); continue;
                     default:
                         var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
@@ -41,8 +49,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
                 }
                 op = body.call(thisArg, _);
             }
-            catch (e) { op = [6, e]; }
-            finally { f = 0, sent = void 0; }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
         }
     }
     return {
diff --git a/tests/baselines/reference/es5-asyncFunction.js b/tests/baselines/reference/es5-asyncFunction.js
index 9cb6f1d3674..e56da04827c 100644
--- a/tests/baselines/reference/es5-asyncFunction.js
+++ b/tests/baselines/reference/es5-asyncFunction.js
@@ -18,7 +18,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, f;
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
         while (1) {
@@ -28,9 +28,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
                 case 2: return { value: op[1], done: true };
             }
             try {
-                switch (f = 1, op[0]) {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
                     case 0: case 1: sent = op; break;
                     case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
                     case 7: op = _.stack.pop(), _.trys.pop(); continue;
                     default:
                         var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
@@ -44,8 +52,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
                 }
                 op = body.call(thisArg, _);
             }
-            catch (e) { op = [6, e]; }
-            finally { f = 0, sent = void 0; }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
         }
     }
     return {
diff --git a/tests/baselines/reference/es5-importHelpersAsyncFunctions.js b/tests/baselines/reference/es5-importHelpersAsyncFunctions.js
index 0fcd8897018..af480ce3967 100644
--- a/tests/baselines/reference/es5-importHelpersAsyncFunctions.js
+++ b/tests/baselines/reference/es5-importHelpersAsyncFunctions.js
@@ -38,7 +38,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, f;
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
         while (1) {
@@ -48,9 +48,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
                 case 2: return { value: op[1], done: true };
             }
             try {
-                switch (f = 1, op[0]) {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
                     case 0: case 1: sent = op; break;
                     case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
                     case 7: op = _.stack.pop(), _.trys.pop(); continue;
                     default:
                         var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
@@ -64,8 +72,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
                 }
                 op = body.call(thisArg, _);
             }
-            catch (e) { op = [6, e]; }
-            finally { f = 0, sent = void 0; }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
         }
     }
     return {
diff --git a/tests/baselines/reference/generatorTypeCheck1.symbols b/tests/baselines/reference/generatorTypeCheck1.symbols
index dbb6db06833..7c9dbbf05b4 100644
--- a/tests/baselines/reference/generatorTypeCheck1.symbols
+++ b/tests/baselines/reference/generatorTypeCheck1.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck1.ts ===
 function* g1(): Iterator<string> { }
 >g1 : Symbol(g1, Decl(generatorTypeCheck1.ts, 0, 0))
->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterator : Symbol(Iterator, Decl(lib.es5.d.ts, --, --))
 
diff --git a/tests/baselines/reference/generatorTypeCheck29.symbols b/tests/baselines/reference/generatorTypeCheck29.symbols
index 5ea31ccb0cd..eca0b2c6091 100644
--- a/tests/baselines/reference/generatorTypeCheck29.symbols
+++ b/tests/baselines/reference/generatorTypeCheck29.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck29.ts ===
 function* g2(): Iterator<Iterable<(x: string) => number>> {
 >g2 : Symbol(g2, Decl(generatorTypeCheck29.ts, 0, 0))
->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterator : Symbol(Iterator, Decl(lib.es5.d.ts, --, --))
 >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck29.ts, 0, 35))
 
diff --git a/tests/baselines/reference/generatorTypeCheck30.symbols b/tests/baselines/reference/generatorTypeCheck30.symbols
index f1626cf067f..acb1e861520 100644
--- a/tests/baselines/reference/generatorTypeCheck30.symbols
+++ b/tests/baselines/reference/generatorTypeCheck30.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck30.ts ===
 function* g2(): Iterator<Iterable<(x: string) => number>> {
 >g2 : Symbol(g2, Decl(generatorTypeCheck30.ts, 0, 0))
->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterator : Symbol(Iterator, Decl(lib.es5.d.ts, --, --))
 >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck30.ts, 0, 35))
 
diff --git a/tests/baselines/reference/generatorTypeCheck45.symbols b/tests/baselines/reference/generatorTypeCheck45.symbols
index fa8cdacfcd3..e8d400c6ef7 100644
--- a/tests/baselines/reference/generatorTypeCheck45.symbols
+++ b/tests/baselines/reference/generatorTypeCheck45.symbols
@@ -6,7 +6,7 @@ declare function foo<T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U)
 >x : Symbol(x, Decl(generatorTypeCheck45.ts, 0, 27))
 >T : Symbol(T, Decl(generatorTypeCheck45.ts, 0, 21))
 >fun : Symbol(fun, Decl(generatorTypeCheck45.ts, 0, 32))
->Iterator : Symbol(Iterator, Decl(lib.es2015.iterable.d.ts, --, --))
+>Iterator : Symbol(Iterator, Decl(lib.es5.d.ts, --, --))
 >x : Symbol(x, Decl(generatorTypeCheck45.ts, 0, 54))
 >T : Symbol(T, Decl(generatorTypeCheck45.ts, 0, 21))
 >U : Symbol(U, Decl(generatorTypeCheck45.ts, 0, 23))
diff --git a/tests/baselines/reference/parserMissingLambdaOpenBrace1.errors.txt b/tests/baselines/reference/parserMissingLambdaOpenBrace1.errors.txt
index d39986c9c01..6f01085be22 100644
--- a/tests/baselines/reference/parserMissingLambdaOpenBrace1.errors.txt
+++ b/tests/baselines/reference/parserMissingLambdaOpenBrace1.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/parser/ecmascript5/ErrorRecovery/parserMissingLambdaOpenBrace1.ts(2,19): error TS2304: Cannot find name 'Iterator'.
+tests/cases/conformance/parser/ecmascript5/ErrorRecovery/parserMissingLambdaOpenBrace1.ts(2,19): error TS2314: Generic type 'Iterator<T>' requires 1 type argument(s).
 tests/cases/conformance/parser/ecmascript5/ErrorRecovery/parserMissingLambdaOpenBrace1.ts(2,42): error TS2304: Cannot find name 'Query'.
 tests/cases/conformance/parser/ecmascript5/ErrorRecovery/parserMissingLambdaOpenBrace1.ts(3,16): error TS2304: Cannot find name 'fromDoWhile'.
 tests/cases/conformance/parser/ecmascript5/ErrorRecovery/parserMissingLambdaOpenBrace1.ts(4,13): error TS1005: '{' expected.
@@ -8,8 +8,8 @@ tests/cases/conformance/parser/ecmascript5/ErrorRecovery/parserMissingLambdaOpen
 ==== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/parserMissingLambdaOpenBrace1.ts (5 errors) ====
     class C {
         where(filter: Iterator<T, boolean>): Query<T> {
-                      ~~~~~~~~
-!!! error TS2304: Cannot find name 'Iterator'.
+                      ~~~~~~~~~~~~~~~~~~~~
+!!! error TS2314: Generic type 'Iterator<T>' requires 1 type argument(s).
                                              ~~~~~
 !!! error TS2304: Cannot find name 'Query'.
             return fromDoWhile(test =>
diff --git a/tests/baselines/reference/templateStringInYieldKeyword.errors.txt b/tests/baselines/reference/templateStringInYieldKeyword.errors.txt
deleted file mode 100644
index 578c24e7ce9..00000000000
--- a/tests/baselines/reference/templateStringInYieldKeyword.errors.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-
-
-==== tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts (1 errors) ====
-    function* gen() {
-            ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-        // Once this is supported, the inner expression does not need to be parenthesized.
-        var x = yield `abc${ x }def`;
-    }
-    
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringInYieldKeyword.js b/tests/baselines/reference/templateStringInYieldKeyword.js
index e23eaa17c9c..fad896a2dd8 100644
--- a/tests/baselines/reference/templateStringInYieldKeyword.js
+++ b/tests/baselines/reference/templateStringInYieldKeyword.js
@@ -6,7 +6,59 @@ function* gen() {
 
 
 //// [templateStringInYieldKeyword.js]
-function* gen() {
-    // Once this is supported, the inner expression does not need to be parenthesized.
-    var x = yield "abc" + x + "def";
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function gen() {
+    var x;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, "abc" + x + "def"];
+            case 1:
+                x = _a.sent();
+                return [2 /*return*/];
+        }
+    });
 }
diff --git a/tests/baselines/reference/templateStringInYieldKeyword.symbols b/tests/baselines/reference/templateStringInYieldKeyword.symbols
new file mode 100644
index 00000000000..3e8e63d2954
--- /dev/null
+++ b/tests/baselines/reference/templateStringInYieldKeyword.symbols
@@ -0,0 +1,10 @@
+=== tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts ===
+function* gen() {
+>gen : Symbol(gen, Decl(templateStringInYieldKeyword.ts, 0, 0))
+
+    // Once this is supported, the inner expression does not need to be parenthesized.
+    var x = yield `abc${ x }def`;
+>x : Symbol(x, Decl(templateStringInYieldKeyword.ts, 2, 7))
+>x : Symbol(x, Decl(templateStringInYieldKeyword.ts, 2, 7))
+}
+
diff --git a/tests/baselines/reference/templateStringInYieldKeyword.types b/tests/baselines/reference/templateStringInYieldKeyword.types
new file mode 100644
index 00000000000..456421126a6
--- /dev/null
+++ b/tests/baselines/reference/templateStringInYieldKeyword.types
@@ -0,0 +1,12 @@
+=== tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts ===
+function* gen() {
+>gen : () => Iterator<string>
+
+    // Once this is supported, the inner expression does not need to be parenthesized.
+    var x = yield `abc${ x }def`;
+>x : any
+>yield `abc${ x }def` : any
+>`abc${ x }def` : string
+>x : any
+}
+
diff --git a/tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.js b/tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.js
index 8230f0ec8f1..7a66f3339b7 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.js
+++ b/tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.js
@@ -6,7 +6,61 @@ function* gen {
 
 
 //// [templateStringWithEmbeddedYieldKeyword.js]
-function* gen() {
-    // Once this is supported, yield *must* be parenthesized.
-    var x = "abc" + (yield 10) + "def";
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function gen() {
+    var x, _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _a = "abc";
+                return [4 /*yield*/, 10];
+            case 1:
+                x = _a + (_b.sent()) + "def";
+                return [2 /*return*/];
+        }
+    });
 }
diff --git a/tests/baselines/reference/underscoreTest1.js b/tests/baselines/reference/underscoreTest1.js
index 687a210e670..771e6df56ac 100644
--- a/tests/baselines/reference/underscoreTest1.js
+++ b/tests/baselines/reference/underscoreTest1.js
@@ -5,11 +5,11 @@ interface Dictionary<T> {
     [x: string]: T;
 }
 
-interface Iterator<T, U> {
+interface IteratorCallback<T, U> {
     (value: T, index: any, list: any): U;
 }
 
-interface Reducer<T, U> {
+interface ReducerCallback<T, U> {
     (accumulator: U, value: T, index: any, list: any): U;
 }
 
@@ -81,42 +81,42 @@ module Underscore {
     }
 
     export interface WrappedArray<T> extends WrappedObject<Array<T>> {
-        each(iterator: Iterator<T, void>, context?: any): void;
-        forEach(iterator: Iterator<T, void>, context?: any): void;
-        map<U>(iterator: Iterator<T, U>, context?: any): U[];
-        collect<U>(iterator: Iterator<T, U>, context?: any): U[];
-        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        find(iterator: Iterator<T, boolean>, context?: any): T;
-        detect(iterator: Iterator<T, boolean>, context?: any): T;
-        filter(iterator: Iterator<T, boolean>, context?: any): T[];
-        select(iterator: Iterator<T, boolean>, context?: any): T[];
+        each(iterator: IteratorCallback<T, void>, context?: any): void;
+        forEach(iterator: IteratorCallback<T, void>, context?: any): void;
+        map<U>(iterator: IteratorCallback<T, U>, context?: any): U[];
+        collect<U>(iterator: IteratorCallback<T, U>, context?: any): U[];
+        reduce(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        reduce<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        foldl(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        foldl<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        inject(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        inject<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        reduceRight(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        reduceRight<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        foldr(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        foldr<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        find(iterator: IteratorCallback<T, boolean>, context?: any): T;
+        detect(iterator: IteratorCallback<T, boolean>, context?: any): T;
+        filter(iterator: IteratorCallback<T, boolean>, context?: any): T[];
+        select(iterator: IteratorCallback<T, boolean>, context?: any): T[];
         where(properties: Object): T[];
         findWhere(properties: Object): T;
-        reject(iterator: Iterator<T, boolean>, context?: any): T[];
-        every(iterator?: Iterator<T, boolean>, context?: any): boolean;
-        all(iterator?: Iterator<T, boolean>, context?: any): boolean;
-        some(iterator?: Iterator<T, boolean>, context?: any): boolean;
-        any(iterator?: Iterator<T, boolean>, context?: any): boolean;
+        reject(iterator: IteratorCallback<T, boolean>, context?: any): T[];
+        every(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        all(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        some(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        any(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
         contains(value: T): boolean;
         include(value: T): boolean;
         invoke(methodName: string, ...args: any[]): any[];
         pluck(propertyName: string): any[];
-        max(iterator?: Iterator<T, any>, context?: any): T;
-        min(iterator?: Iterator<T, any>, context?: any): T;
-        sortBy(iterator: Iterator<T, any>, context?: any): T[];
+        max(iterator?: IteratorCallback<T, any>, context?: any): T;
+        min(iterator?: IteratorCallback<T, any>, context?: any): T;
+        sortBy(iterator: IteratorCallback<T, any>, context?: any): T[];
         sortBy(propertyName: string): T[];
-        groupBy(iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
+        groupBy(iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>;
         groupBy(propertyName: string): Dictionary<T[]>;
-        countBy(iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
+        countBy(iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>;
         countBy(propertyName: string): Dictionary<number>;
         shuffle(): T[];
         toArray(): T[];
@@ -139,16 +139,16 @@ module Underscore {
         intersection(...arrays: T[][]): T[];
         difference(...others: T[][]): T[];
         uniq(isSorted?: boolean): T[];
-        uniq<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
+        uniq<U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[];
         unique(isSorted?: boolean): T[];
-        unique<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
+        unique<U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[];
         zip(...arrays: any[][]): any[][];
         object(): any;
         object(values: any[]): any;
         indexOf(value: T, isSorted?: boolean): number;
         lastIndexOf(value: T, fromIndex?: number): number;
         sortedIndex(obj: T, propertyName: string): number;
-        sortedIndex(obj: T, iterator?: Iterator<T, any>, context?: any): number;
+        sortedIndex(obj: T, iterator?: IteratorCallback<T, any>, context?: any): number;
         // Methods from Array
         concat(...items: T[]): T[];
         join(separator?: string): string;
@@ -164,42 +164,42 @@ module Underscore {
     }
 
     export interface WrappedDictionary<T> extends WrappedObject<Dictionary<T>> {
-        each(iterator: Iterator<T, void>, context?: any): void;
-        forEach(iterator: Iterator<T, void>, context?: any): void;
-        map<U>(iterator: Iterator<T, U>, context?: any): U[];
-        collect<U>(iterator: Iterator<T, U>, context?: any): U[];
-        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        find(iterator: Iterator<T, boolean>, context?: any): T;
-        detect(iterator: Iterator<T, boolean>, context?: any): T;
-        filter(iterator: Iterator<T, boolean>, context?: any): T[];
-        select(iterator: Iterator<T, boolean>, context?: any): T[];
+        each(iterator: IteratorCallback<T, void>, context?: any): void;
+        forEach(iterator: IteratorCallback<T, void>, context?: any): void;
+        map<U>(iterator: IteratorCallback<T, U>, context?: any): U[];
+        collect<U>(iterator: IteratorCallback<T, U>, context?: any): U[];
+        reduce(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        reduce<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        foldl(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        foldl<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        inject(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        inject<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        reduceRight(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        reduceRight<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        foldr(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        foldr<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        find(iterator: IteratorCallback<T, boolean>, context?: any): T;
+        detect(iterator: IteratorCallback<T, boolean>, context?: any): T;
+        filter(iterator: IteratorCallback<T, boolean>, context?: any): T[];
+        select(iterator: IteratorCallback<T, boolean>, context?: any): T[];
         where(properties: Object): T[];
         findWhere(properties: Object): T;
-        reject(iterator: Iterator<T, boolean>, context?: any): T[];
-        every(iterator?: Iterator<T, boolean>, context?: any): boolean;
-        all(iterator?: Iterator<T, boolean>, context?: any): boolean;
-        some(iterator?: Iterator<T, boolean>, context?: any): boolean;
-        any(iterator?: Iterator<T, boolean>, context?: any): boolean;
+        reject(iterator: IteratorCallback<T, boolean>, context?: any): T[];
+        every(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        all(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        some(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        any(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
         contains(value: T): boolean;
         include(value: T): boolean;
         invoke(methodName: string, ...args: any[]): any[];
         pluck(propertyName: string): any[];
-        max(iterator?: Iterator<T, any>, context?: any): T;
-        min(iterator?: Iterator<T, any>, context?: any): T;
-        sortBy(iterator: Iterator<T, any>, context?: any): T[];
+        max(iterator?: IteratorCallback<T, any>, context?: any): T;
+        min(iterator?: IteratorCallback<T, any>, context?: any): T;
+        sortBy(iterator: IteratorCallback<T, any>, context?: any): T[];
         sortBy(propertyName: string): T[];
-        groupBy(iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
+        groupBy(iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>;
         groupBy(propertyName: string): Dictionary<T[]>;
-        countBy(iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
+        countBy(iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>;
         countBy(propertyName: string): Dictionary<number>;
         shuffle(): T[];
         toArray(): T[];
@@ -240,43 +240,43 @@ module Underscore {
     }
 
     export interface ChainedArray<T> extends ChainedObject<Array<T>> {
-        each(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
-        forEach(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
-        map<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
-        collect<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
-        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        find(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
-        detect(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
-        filter(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
-        select(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
+        each(iterator: IteratorCallback<T, void>, context?: any): ChainedObject<void>;
+        forEach(iterator: IteratorCallback<T, void>, context?: any): ChainedObject<void>;
+        map<U>(iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
+        collect<U>(iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
+        reduce(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        reduce<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        foldl(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        foldl<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        inject(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        inject<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        reduceRight(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        reduceRight<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        foldr(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        foldr<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        find(iterator: IteratorCallback<T, boolean>, context?: any): ChainedObject<T>;
+        detect(iterator: IteratorCallback<T, boolean>, context?: any): ChainedObject<T>;
+        filter(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
+        select(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
         where(properties: Object): ChainedArray<T>;
         findWhere(properties: Object): ChainedObject<T>;
-        reject(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
-        every(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
-        all(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
-        some(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
-        any(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
+        reject(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
+        every(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+        all(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+        some(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+        any(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
         contains(value: T): ChainedObject<boolean>;
         include(value: T): ChainedObject<boolean>;
         invoke(methodName: string, ...args: any[]): ChainedArray<any>;
         pluck(propertyName: string): ChainedArray<any>;
-        max(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
-        min(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
-        sortBy(iterator: Iterator<T, any>, context?: any): ChainedArray<T>;
+        max(iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<T>;
+        min(iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<T>;
+        sortBy(iterator: IteratorCallback<T, any>, context?: any): ChainedArray<T>;
         sortBy(propertyName: string): ChainedArray<T>;
         // Should return ChainedDictionary<T[]>, but expansive recursion not allowed
-        groupBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<any[]>;
+        groupBy(iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<any[]>;
         groupBy(propertyName: string): ChainedDictionary<any[]>;
-        countBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<number>;
+        countBy(iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<number>;
         countBy(propertyName: string): ChainedDictionary<number>;
         shuffle(): ChainedArray<T>;
         toArray(): ChainedArray<T>;
@@ -299,16 +299,16 @@ module Underscore {
         intersection(...arrays: T[][]): ChainedArray<T>;
         difference(...others: T[][]): ChainedArray<T>;
         uniq(isSorted?: boolean): ChainedArray<T>;
-        uniq<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
+        uniq<U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
         unique(isSorted?: boolean): ChainedArray<T>;
-        unique<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
+        unique<U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
         zip(...arrays: any[][]): ChainedArray<any[]>;
         object(): ChainedObject<any>;
         object(values: any[]): ChainedObject<any>;
         indexOf(value: T, isSorted?: boolean): ChainedObject<number>;
         lastIndexOf(value: T, fromIndex?: number): ChainedObject<number>;
         sortedIndex(obj: T, propertyName: string): ChainedObject<number>;
-        sortedIndex(obj: T, iterator?: Iterator<T, any>, context?: any): ChainedObject<number>;
+        sortedIndex(obj: T, iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<number>;
         // Methods from Array
         concat(...items: T[]): ChainedArray<T>;
         join(separator?: string): ChainedObject<string>;
@@ -331,43 +331,43 @@ module Underscore {
     }
 
     export interface ChainedDictionary<T> extends ChainedObject<Dictionary<T>> {
-        each(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
-        forEach(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
-        map<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
-        collect<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
-        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        find(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
-        detect(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
-        filter(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
-        select(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
+        each(iterator: IteratorCallback<T, void>, context?: any): ChainedObject<void>;
+        forEach(iterator: IteratorCallback<T, void>, context?: any): ChainedObject<void>;
+        map<U>(iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
+        collect<U>(iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
+        reduce(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        reduce<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        foldl(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        foldl<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        inject(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        inject<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        reduceRight(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        reduceRight<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        foldr(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        foldr<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        find(iterator: IteratorCallback<T, boolean>, context?: any): ChainedObject<T>;
+        detect(iterator: IteratorCallback<T, boolean>, context?: any): ChainedObject<T>;
+        filter(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
+        select(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
         where(properties: Object): ChainedArray<T>;
         findWhere(properties: Object): ChainedObject<T>;
-        reject(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
-        every(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
-        all(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
-        some(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
-        any(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
+        reject(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
+        every(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+        all(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+        some(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+        any(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
         contains(value: T): ChainedObject<boolean>;
         include(value: T): ChainedObject<boolean>;
         invoke(methodName: string, ...args: any[]): ChainedArray<any>;
         pluck(propertyName: string): ChainedArray<any>;
-        max(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
-        min(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
-        sortBy(iterator: Iterator<T, any>, context?: any): ChainedArray<T>;
+        max(iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<T>;
+        min(iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<T>;
+        sortBy(iterator: IteratorCallback<T, any>, context?: any): ChainedArray<T>;
         sortBy(propertyName: string): ChainedArray<T>;
         // Should return ChainedDictionary<T[]>, but expansive recursion not allowed
-        groupBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<any[]>;
+        groupBy(iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<any[]>;
         groupBy(propertyName: string): ChainedDictionary<any[]>;
-        countBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<number>;
+        countBy(iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<number>;
         countBy(propertyName: string): ChainedDictionary<number>;
         shuffle(): ChainedArray<T>;
         toArray(): ChainedArray<T>;
@@ -398,47 +398,47 @@ module Underscore {
         chain<T>(list: Dictionary<T>): ChainedDictionary<T>;
         chain<T>(obj: T): ChainedObject<T>;
 
-        each<T>(list: T[], iterator: Iterator<T, void>, context?: any): void;
-        each<T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void;
-        forEach<T>(list: T[], iterator: Iterator<T, void>, context?: any): void;
-        forEach<T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void;
+        each<T>(list: T[], iterator: IteratorCallback<T, void>, context?: any): void;
+        each<T>(list: Dictionary<T>, iterator: IteratorCallback<T, void>, context?: any): void;
+        forEach<T>(list: T[], iterator: IteratorCallback<T, void>, context?: any): void;
+        forEach<T>(list: Dictionary<T>, iterator: IteratorCallback<T, void>, context?: any): void;
 
-        map<T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[];
-        map<T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[];
-        collect<T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[];
-        collect<T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[];
+        map<T, U>(list: T[], iterator: IteratorCallback<T, U>, context?: any): U[];
+        map<T, U>(list: Dictionary<T>, iterator: IteratorCallback<T, U>, context?: any): U[];
+        collect<T, U>(list: T[], iterator: IteratorCallback<T, U>, context?: any): U[];
+        collect<T, U>(list: Dictionary<T>, iterator: IteratorCallback<T, U>, context?: any): U[];
 
-        reduce<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        reduce<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        reduce<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        reduce<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        foldl<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        foldl<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        foldl<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        foldl<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        inject<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        inject<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        inject<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        inject<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
+        reduce<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        reduce<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        reduce<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        reduce<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        foldl<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        foldl<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        foldl<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        foldl<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        inject<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        inject<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        inject<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        inject<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
 
-        reduceRight<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        reduceRight<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        reduceRight<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        reduceRight<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        foldr<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        foldr<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        foldr<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        foldr<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
+        reduceRight<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        reduceRight<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        reduceRight<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        reduceRight<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        foldr<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        foldr<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        foldr<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        foldr<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
 
-        find<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T;
-        find<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T;
-        detect<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T;
-        detect<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T;
+        find<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T;
+        find<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T;
+        detect<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T;
+        detect<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T;
 
-        filter<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[];
-        filter<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[];
-        select<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[];
-        select<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[];
+        filter<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[];
+        filter<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[];
+        select<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[];
+        select<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[];
 
         where<T>(list: T[], properties: Object): T[];
         where<T>(list: Dictionary<T>, properties: Object): T[];
@@ -446,18 +446,18 @@ module Underscore {
         findWhere<T>(list: T[], properties: Object): T;
         findWhere<T>(list: Dictionary<T>, properties: Object): T;
 
-        reject<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[];
-        reject<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[];
+        reject<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[];
+        reject<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[];
 
-        every<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
-        every<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
-        all<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
-        all<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
+        every<T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        every<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        all<T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        all<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
 
-        some<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
-        some<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
-        any<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
-        any<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
+        some<T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        some<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        any<T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        any<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
 
         contains<T>(list: T[], value: T): boolean;
         contains<T>(list: Dictionary<T>, value: T): boolean;
@@ -470,24 +470,24 @@ module Underscore {
         pluck(list: any[], propertyName: string): any[];
         pluck(list: Dictionary<any>, propertyName: string): any[];
 
-        max<T>(list: T[], iterator?: Iterator<T, any>, context?: any): T;
-        max<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T;
+        max<T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): T;
+        max<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): T;
 
-        min<T>(list: T[], iterator?: Iterator<T, any>, context?: any): T;
-        min<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T;
+        min<T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): T;
+        min<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): T;
 
-        sortBy<T>(list: T[], iterator: Iterator<T, any>, context?: any): T[];
-        sortBy<T>(list: Dictionary<T>, iterator: Iterator<T, any>, context?: any): T[];
+        sortBy<T>(list: T[], iterator: IteratorCallback<T, any>, context?: any): T[];
+        sortBy<T>(list: Dictionary<T>, iterator: IteratorCallback<T, any>, context?: any): T[];
         sortBy<T>(list: T[], propertyName: string): T[];
         sortBy<T>(list: Dictionary<T>, propertyName: string): T[];
 
-        groupBy<T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
-        groupBy<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
+        groupBy<T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>;
+        groupBy<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>;
         groupBy<T>(list: T[], propertyName: string): Dictionary<T[]>;
         groupBy<T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>;
 
-        countBy<T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
-        countBy<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
+        countBy<T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>;
+        countBy<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>;
         countBy<T>(list: T[], propertyName: string): Dictionary<number>;
         countBy<T>(list: Dictionary<T>, propertyName: string): Dictionary<number>;
 
@@ -529,9 +529,9 @@ module Underscore {
         difference<T>(list: T[], ...others: T[][]): T[];
 
         uniq<T>(list: T[], isSorted?: boolean): T[];
-        uniq<T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
+        uniq<T, U>(list: T[], isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[];
         unique<T>(list: T[], isSorted?: boolean): T[];
-        unique<T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
+        unique<T, U>(list: T[], isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[];
 
         zip<T0, T1>(a0: T0[], a1: T1[]): Tuple2<T0, T1>[];
         zip<T0, T1, T2>(a0: T0[], a1: T1[], a2: T2[]): Tuple3<T0, T1, T2>[];
@@ -546,7 +546,7 @@ module Underscore {
         lastIndexOf<T>(list: T[], value: T, fromIndex?: number): number;
 
         sortedIndex<T>(list: T[], obj: T, propertyName: string): number;
-        sortedIndex<T>(list: T[], obj: T, iterator?: Iterator<T, any>, context?: any): number;
+        sortedIndex<T>(list: T[], obj: T, iterator?: IteratorCallback<T, any>, context?: any): number;
 
         range(stop: number): number[];
         range(start: number, stop: number, step?: number): number[];
@@ -623,7 +623,7 @@ module Underscore {
 
         identity<T>(value: T): T;
 
-        times<U>(n: number, iterator: Iterator<number, U>, context?: any): U[];
+        times<U>(n: number, iterator: IteratorCallback<number, U>, context?: any): U[];
 
         random(max: number): number;
         random(min: number, max: number): number;
diff --git a/tests/baselines/reference/underscoreTest1.symbols b/tests/baselines/reference/underscoreTest1.symbols
index 89815bd2371..8f91fa5c518 100644
--- a/tests/baselines/reference/underscoreTest1.symbols
+++ b/tests/baselines/reference/underscoreTest1.symbols
@@ -9,9 +9,9 @@ declare function alert(x: string): void;
 >x : Symbol(x, Decl(underscoreTest1_underscoreTests.ts, 3, 23))
 
 _.each([1, 2, 3], (num) => alert(num.toString()));
->_.each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77))
+>_.each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 85))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77))
+>each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 85))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 5, 19))
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 >num.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
@@ -19,9 +19,9 @@ _.each([1, 2, 3], (num) => alert(num.toString()));
 >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 _.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(value.toString()));
->_.each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77))
+>_.each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 85))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77))
+>each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 85))
 >one : Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 6, 8))
 >two : Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 6, 16))
 >three : Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 6, 24))
@@ -33,16 +33,16 @@ _.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(valu
 >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
 
 _.map([1, 2, 3], (num) => num * 3);
->_.map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 400, 90), Decl(underscoreTest1_underscore.ts, 402, 75))
+>_.map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 400, 98), Decl(underscoreTest1_underscore.ts, 402, 83))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 400, 90), Decl(underscoreTest1_underscore.ts, 402, 75))
+>map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 400, 98), Decl(underscoreTest1_underscore.ts, 402, 83))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 8, 18))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 8, 18))
 
 _.map({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => value * 3);
->_.map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 400, 90), Decl(underscoreTest1_underscore.ts, 402, 75))
+>_.map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 400, 98), Decl(underscoreTest1_underscore.ts, 402, 83))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 400, 90), Decl(underscoreTest1_underscore.ts, 402, 75))
+>map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 400, 98), Decl(underscoreTest1_underscore.ts, 402, 83))
 >one : Symbol(one, Decl(underscoreTest1_underscoreTests.ts, 9, 7))
 >two : Symbol(two, Decl(underscoreTest1_underscoreTests.ts, 9, 15))
 >three : Symbol(three, Decl(underscoreTest1_underscoreTests.ts, 9, 23))
@@ -52,9 +52,9 @@ _.map({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => value * 3);
 
 var sum = _.reduce([1, 2, 3], (memo, num) => memo + num, 0);
 >sum : Symbol(sum, Decl(underscoreTest1_underscoreTests.ts, 11, 3))
->_.reduce : Symbol(Underscore.Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 89), Decl(underscoreTest1_underscore.ts, 407, 90), Decl(underscoreTest1_underscore.ts, 408, 92), Decl(underscoreTest1_underscore.ts, 409, 100))
+>_.reduce : Symbol(Underscore.Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 97), Decl(underscoreTest1_underscore.ts, 407, 98), Decl(underscoreTest1_underscore.ts, 408, 100), Decl(underscoreTest1_underscore.ts, 409, 108))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->reduce : Symbol(Underscore.Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 89), Decl(underscoreTest1_underscore.ts, 407, 90), Decl(underscoreTest1_underscore.ts, 408, 92), Decl(underscoreTest1_underscore.ts, 409, 100))
+>reduce : Symbol(Underscore.Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 97), Decl(underscoreTest1_underscore.ts, 407, 98), Decl(underscoreTest1_underscore.ts, 408, 100), Decl(underscoreTest1_underscore.ts, 409, 108))
 >memo : Symbol(memo, Decl(underscoreTest1_underscoreTests.ts, 11, 31))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 11, 36))
 >memo : Symbol(memo, Decl(underscoreTest1_underscoreTests.ts, 11, 31))
@@ -65,9 +65,9 @@ var list = [[0, 1], [2, 3], [4, 5]];
 
 var flat = _.reduceRight(list, (a, b) => a.concat(b), []);
 >flat : Symbol(flat, Decl(underscoreTest1_underscoreTests.ts, 14, 3))
->_.reduceRight : Symbol(Underscore.Static.reduceRight, Decl(underscoreTest1_underscore.ts, 418, 102), Decl(underscoreTest1_underscore.ts, 420, 95), Decl(underscoreTest1_underscore.ts, 421, 97), Decl(underscoreTest1_underscore.ts, 422, 105))
+>_.reduceRight : Symbol(Underscore.Static.reduceRight, Decl(underscoreTest1_underscore.ts, 418, 110), Decl(underscoreTest1_underscore.ts, 420, 103), Decl(underscoreTest1_underscore.ts, 421, 105), Decl(underscoreTest1_underscore.ts, 422, 113))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->reduceRight : Symbol(Underscore.Static.reduceRight, Decl(underscoreTest1_underscore.ts, 418, 102), Decl(underscoreTest1_underscore.ts, 420, 95), Decl(underscoreTest1_underscore.ts, 421, 97), Decl(underscoreTest1_underscore.ts, 422, 105))
+>reduceRight : Symbol(Underscore.Static.reduceRight, Decl(underscoreTest1_underscore.ts, 418, 110), Decl(underscoreTest1_underscore.ts, 420, 103), Decl(underscoreTest1_underscore.ts, 421, 105), Decl(underscoreTest1_underscore.ts, 422, 113))
 >list : Symbol(list, Decl(underscoreTest1_underscoreTests.ts, 13, 3))
 >a : Symbol(a, Decl(underscoreTest1_underscoreTests.ts, 14, 32))
 >b : Symbol(b, Decl(underscoreTest1_underscoreTests.ts, 14, 34))
@@ -78,17 +78,17 @@ var flat = _.reduceRight(list, (a, b) => a.concat(b), []);
 
 var even = _.find([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
 >even : Symbol(even, Decl(underscoreTest1_underscoreTests.ts, 16, 3))
->_.find : Symbol(Underscore.Static.find, Decl(underscoreTest1_underscore.ts, 427, 101), Decl(underscoreTest1_underscore.ts, 429, 77))
+>_.find : Symbol(Underscore.Static.find, Decl(underscoreTest1_underscore.ts, 427, 109), Decl(underscoreTest1_underscore.ts, 429, 85))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->find : Symbol(Underscore.Static.find, Decl(underscoreTest1_underscore.ts, 427, 101), Decl(underscoreTest1_underscore.ts, 429, 77))
+>find : Symbol(Underscore.Static.find, Decl(underscoreTest1_underscore.ts, 427, 109), Decl(underscoreTest1_underscore.ts, 429, 85))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 16, 39))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 16, 39))
 
 var evens = _.filter([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
 >evens : Symbol(evens, Decl(underscoreTest1_underscoreTests.ts, 18, 3))
->_.filter : Symbol(Underscore.Static.filter, Decl(underscoreTest1_underscore.ts, 432, 89), Decl(underscoreTest1_underscore.ts, 434, 81))
+>_.filter : Symbol(Underscore.Static.filter, Decl(underscoreTest1_underscore.ts, 432, 97), Decl(underscoreTest1_underscore.ts, 434, 89))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->filter : Symbol(Underscore.Static.filter, Decl(underscoreTest1_underscore.ts, 432, 89), Decl(underscoreTest1_underscore.ts, 434, 81))
+>filter : Symbol(Underscore.Static.filter, Decl(underscoreTest1_underscore.ts, 432, 97), Decl(underscoreTest1_underscore.ts, 434, 89))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 18, 42))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 18, 42))
 
@@ -105,38 +105,38 @@ var listOfPlays = [{ title: "Cymbeline", author: "Shakespeare", year: 1611 }, {
 >year : Symbol(year, Decl(underscoreTest1_underscoreTests.ts, 20, 183))
 
 _.where(listOfPlays, { author: "Shakespeare", year: 1611 });
->_.where : Symbol(Underscore.Static.where, Decl(underscoreTest1_underscore.ts, 437, 91), Decl(underscoreTest1_underscore.ts, 439, 53))
+>_.where : Symbol(Underscore.Static.where, Decl(underscoreTest1_underscore.ts, 437, 99), Decl(underscoreTest1_underscore.ts, 439, 53))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->where : Symbol(Underscore.Static.where, Decl(underscoreTest1_underscore.ts, 437, 91), Decl(underscoreTest1_underscore.ts, 439, 53))
+>where : Symbol(Underscore.Static.where, Decl(underscoreTest1_underscore.ts, 437, 99), Decl(underscoreTest1_underscore.ts, 439, 53))
 >listOfPlays : Symbol(listOfPlays, Decl(underscoreTest1_underscoreTests.ts, 20, 3))
 >author : Symbol(author, Decl(underscoreTest1_underscoreTests.ts, 21, 22))
 >year : Symbol(year, Decl(underscoreTest1_underscoreTests.ts, 21, 45))
 
 var odds = _.reject([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
 >odds : Symbol(odds, Decl(underscoreTest1_underscoreTests.ts, 23, 3))
->_.reject : Symbol(Underscore.Static.reject, Decl(underscoreTest1_underscore.ts, 443, 65), Decl(underscoreTest1_underscore.ts, 445, 81))
+>_.reject : Symbol(Underscore.Static.reject, Decl(underscoreTest1_underscore.ts, 443, 65), Decl(underscoreTest1_underscore.ts, 445, 89))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->reject : Symbol(Underscore.Static.reject, Decl(underscoreTest1_underscore.ts, 443, 65), Decl(underscoreTest1_underscore.ts, 445, 81))
+>reject : Symbol(Underscore.Static.reject, Decl(underscoreTest1_underscore.ts, 443, 65), Decl(underscoreTest1_underscore.ts, 445, 89))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 23, 41))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 23, 41))
 
 _.all([true, 1, null, 'yes'], _.identity);
->_.all : Symbol(Underscore.Static.all, Decl(underscoreTest1_underscore.ts, 449, 95), Decl(underscoreTest1_underscore.ts, 450, 83))
+>_.all : Symbol(Underscore.Static.all, Decl(underscoreTest1_underscore.ts, 449, 103), Decl(underscoreTest1_underscore.ts, 450, 91))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->all : Symbol(Underscore.Static.all, Decl(underscoreTest1_underscore.ts, 449, 95), Decl(underscoreTest1_underscore.ts, 450, 83))
+>all : Symbol(Underscore.Static.all, Decl(underscoreTest1_underscore.ts, 449, 103), Decl(underscoreTest1_underscore.ts, 450, 91))
 >_.identity : Symbol(Underscore.Static.identity, Decl(underscoreTest1_underscore.ts, 618, 29))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
 >identity : Symbol(Underscore.Static.identity, Decl(underscoreTest1_underscore.ts, 618, 29))
 
 _.any([null, 0, 'yes', false]);
->_.any : Symbol(Underscore.Static.any, Decl(underscoreTest1_underscore.ts, 454, 94), Decl(underscoreTest1_underscore.ts, 455, 83))
+>_.any : Symbol(Underscore.Static.any, Decl(underscoreTest1_underscore.ts, 454, 102), Decl(underscoreTest1_underscore.ts, 455, 91))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->any : Symbol(Underscore.Static.any, Decl(underscoreTest1_underscore.ts, 454, 94), Decl(underscoreTest1_underscore.ts, 455, 83))
+>any : Symbol(Underscore.Static.any, Decl(underscoreTest1_underscore.ts, 454, 102), Decl(underscoreTest1_underscore.ts, 455, 91))
 
 _.contains([1, 2, 3], 3);
->_.contains : Symbol(Underscore.Static.contains, Decl(underscoreTest1_underscore.ts, 456, 93), Decl(underscoreTest1_underscore.ts, 458, 50))
+>_.contains : Symbol(Underscore.Static.contains, Decl(underscoreTest1_underscore.ts, 456, 101), Decl(underscoreTest1_underscore.ts, 458, 50))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->contains : Symbol(Underscore.Static.contains, Decl(underscoreTest1_underscore.ts, 456, 93), Decl(underscoreTest1_underscore.ts, 458, 50))
+>contains : Symbol(Underscore.Static.contains, Decl(underscoreTest1_underscore.ts, 456, 101), Decl(underscoreTest1_underscore.ts, 458, 50))
 
 _.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
 >_.invoke : Symbol(Underscore.Static.invoke, Decl(underscoreTest1_underscore.ts, 461, 59), Decl(underscoreTest1_underscore.ts, 463, 71))
@@ -159,9 +159,9 @@ _.pluck(stooges, 'name');
 >stooges : Symbol(stooges, Decl(underscoreTest1_underscoreTests.ts, 33, 3))
 
 _.max(stooges, (stooge) => stooge.age);
->_.max : Symbol(Underscore.Static.max, Decl(underscoreTest1_underscore.ts, 467, 66), Decl(underscoreTest1_underscore.ts, 469, 73))
+>_.max : Symbol(Underscore.Static.max, Decl(underscoreTest1_underscore.ts, 467, 66), Decl(underscoreTest1_underscore.ts, 469, 81))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->max : Symbol(Underscore.Static.max, Decl(underscoreTest1_underscore.ts, 467, 66), Decl(underscoreTest1_underscore.ts, 469, 73))
+>max : Symbol(Underscore.Static.max, Decl(underscoreTest1_underscore.ts, 467, 66), Decl(underscoreTest1_underscore.ts, 469, 81))
 >stooges : Symbol(stooges, Decl(underscoreTest1_underscoreTests.ts, 33, 3))
 >stooge : Symbol(stooge, Decl(underscoreTest1_underscoreTests.ts, 36, 16))
 >stooge.age : Symbol(age, Decl(underscoreTest1_underscoreTests.ts, 33, 29))
@@ -172,15 +172,15 @@ var numbers = [10, 5, 100, 2, 1000];
 >numbers : Symbol(numbers, Decl(underscoreTest1_underscoreTests.ts, 38, 3))
 
 _.min(numbers);
->_.min : Symbol(Underscore.Static.min, Decl(underscoreTest1_underscore.ts, 470, 83), Decl(underscoreTest1_underscore.ts, 472, 73))
+>_.min : Symbol(Underscore.Static.min, Decl(underscoreTest1_underscore.ts, 470, 91), Decl(underscoreTest1_underscore.ts, 472, 81))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->min : Symbol(Underscore.Static.min, Decl(underscoreTest1_underscore.ts, 470, 83), Decl(underscoreTest1_underscore.ts, 472, 73))
+>min : Symbol(Underscore.Static.min, Decl(underscoreTest1_underscore.ts, 470, 91), Decl(underscoreTest1_underscore.ts, 472, 81))
 >numbers : Symbol(numbers, Decl(underscoreTest1_underscoreTests.ts, 38, 3))
 
 _.sortBy([1, 2, 3, 4, 5, 6], (num) => Math.sin(num));
->_.sortBy : Symbol(Underscore.Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 83), Decl(underscoreTest1_underscore.ts, 475, 77), Decl(underscoreTest1_underscore.ts, 476, 87), Decl(underscoreTest1_underscore.ts, 477, 56))
+>_.sortBy : Symbol(Underscore.Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 91), Decl(underscoreTest1_underscore.ts, 475, 85), Decl(underscoreTest1_underscore.ts, 476, 95), Decl(underscoreTest1_underscore.ts, 477, 56))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->sortBy : Symbol(Underscore.Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 83), Decl(underscoreTest1_underscore.ts, 475, 77), Decl(underscoreTest1_underscore.ts, 476, 87), Decl(underscoreTest1_underscore.ts, 477, 56))
+>sortBy : Symbol(Underscore.Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 91), Decl(underscoreTest1_underscore.ts, 475, 85), Decl(underscoreTest1_underscore.ts, 476, 95), Decl(underscoreTest1_underscore.ts, 477, 56))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 41, 30))
 >Math.sin : Symbol(Math.sin, Decl(lib.d.ts, --, --))
 >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
@@ -190,9 +190,9 @@ _.sortBy([1, 2, 3, 4, 5, 6], (num) => Math.sin(num));
 
 // not sure how this is typechecking at all.. Math.floor(e) is number not string..?
 _([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floor(e));
->_([1.3, 2.1, 2.4]).groupBy : Symbol(Underscore.WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 77))
+>_([1.3, 2.1, 2.4]).groupBy : Symbol(Underscore.WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 85))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->groupBy : Symbol(Underscore.WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 77))
+>groupBy : Symbol(Underscore.WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 85))
 >e : Symbol(e, Decl(underscoreTest1_underscoreTests.ts, 45, 28))
 >i : Symbol(i, Decl(underscoreTest1_underscoreTests.ts, 45, 38))
 >list : Symbol(list, Decl(underscoreTest1_underscoreTests.ts, 45, 50))
@@ -202,9 +202,9 @@ _([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floo
 >e : Symbol(e, Decl(underscoreTest1_underscoreTests.ts, 45, 28))
 
 _.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num));
->_.groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 91), Decl(underscoreTest1_underscore.ts, 481, 101), Decl(underscoreTest1_underscore.ts, 482, 69))
+>_.groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 99), Decl(underscoreTest1_underscore.ts, 481, 109), Decl(underscoreTest1_underscore.ts, 482, 69))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 91), Decl(underscoreTest1_underscore.ts, 481, 101), Decl(underscoreTest1_underscore.ts, 482, 69))
+>groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 99), Decl(underscoreTest1_underscore.ts, 481, 109), Decl(underscoreTest1_underscore.ts, 482, 69))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 46, 28))
 >Math.floor : Symbol(Math.floor, Decl(lib.d.ts, --, --))
 >Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
@@ -212,14 +212,14 @@ _.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num));
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 46, 28))
 
 _.groupBy(['one', 'two', 'three'], 'length');
->_.groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 91), Decl(underscoreTest1_underscore.ts, 481, 101), Decl(underscoreTest1_underscore.ts, 482, 69))
+>_.groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 99), Decl(underscoreTest1_underscore.ts, 481, 109), Decl(underscoreTest1_underscore.ts, 482, 69))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 91), Decl(underscoreTest1_underscore.ts, 481, 101), Decl(underscoreTest1_underscore.ts, 482, 69))
+>groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 99), Decl(underscoreTest1_underscore.ts, 481, 109), Decl(underscoreTest1_underscore.ts, 482, 69))
 
 _.countBy([1, 2, 3, 4, 5], (num) => num % 2 == 0 ? 'even' : 'odd');
->_.countBy : Symbol(Underscore.Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 94), Decl(underscoreTest1_underscore.ts, 486, 104), Decl(underscoreTest1_underscore.ts, 487, 72))
+>_.countBy : Symbol(Underscore.Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 102), Decl(underscoreTest1_underscore.ts, 486, 112), Decl(underscoreTest1_underscore.ts, 487, 72))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->countBy : Symbol(Underscore.Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 94), Decl(underscoreTest1_underscore.ts, 486, 104), Decl(underscoreTest1_underscore.ts, 487, 72))
+>countBy : Symbol(Underscore.Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 102), Decl(underscoreTest1_underscore.ts, 486, 112), Decl(underscoreTest1_underscore.ts, 487, 72))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 49, 28))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 49, 28))
 
@@ -312,9 +312,9 @@ _.uniq([1, 2, 1, 3, 1, 4]);
 >uniq : Symbol(Underscore.Static.uniq, Decl(underscoreTest1_underscore.ts, 525, 56), Decl(underscoreTest1_underscore.ts, 527, 52))
 
 _.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]);
->_.zip : Symbol(Underscore.Static.zip, Decl(underscoreTest1_underscore.ts, 530, 97), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94))
+>_.zip : Symbol(Underscore.Static.zip, Decl(underscoreTest1_underscore.ts, 530, 105), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->zip : Symbol(Underscore.Static.zip, Decl(underscoreTest1_underscore.ts, 530, 97), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94))
+>zip : Symbol(Underscore.Static.zip, Decl(underscoreTest1_underscore.ts, 530, 105), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94))
 
 _.object(['moe', 'larry', 'curly'], [30, 40, 50]);
 >_.object : Symbol(Underscore.Static.object, Decl(underscoreTest1_underscore.ts, 535, 41), Decl(underscoreTest1_underscore.ts, 537, 35))
@@ -342,29 +342,29 @@ _.sortedIndex([10, 20, 30, 40, 50], 35);
 >sortedIndex : Symbol(Underscore.Static.sortedIndex, Decl(underscoreTest1_underscore.ts, 542, 72), Decl(underscoreTest1_underscore.ts, 544, 72))
 
 _.range(10);
->_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38))
+>_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 102), Decl(underscoreTest1_underscore.ts, 547, 38))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38))
+>range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 102), Decl(underscoreTest1_underscore.ts, 547, 38))
 
 _.range(1, 11);
->_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38))
+>_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 102), Decl(underscoreTest1_underscore.ts, 547, 38))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38))
+>range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 102), Decl(underscoreTest1_underscore.ts, 547, 38))
 
 _.range(0, 30, 5);
->_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38))
+>_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 102), Decl(underscoreTest1_underscore.ts, 547, 38))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38))
+>range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 102), Decl(underscoreTest1_underscore.ts, 547, 38))
 
 _.range(0, 30, 5);
->_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38))
+>_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 102), Decl(underscoreTest1_underscore.ts, 547, 38))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38))
+>range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 102), Decl(underscoreTest1_underscore.ts, 547, 38))
 
 _.range(0);
->_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38))
+>_.range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 102), Decl(underscoreTest1_underscore.ts, 547, 38))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38))
+>range : Symbol(Underscore.Static.range, Decl(underscoreTest1_underscore.ts, 545, 102), Decl(underscoreTest1_underscore.ts, 547, 38))
 
 ///////////////////////////////////////////////////////////////////////////////////////
 
@@ -516,9 +516,9 @@ var renderNotes = _.after(notes.length, render);
 >render : Symbol(render, Decl(underscoreTest1_underscoreTests.ts, 127, 3))
 
 _.each(notes, (note) => note.asyncSave({ success: renderNotes }));
->_.each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77))
+>_.each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 85))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77))
+>each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 85))
 >notes : Symbol(notes, Decl(underscoreTest1_underscoreTests.ts, 126, 3))
 >note : Symbol(note, Decl(underscoreTest1_underscoreTests.ts, 129, 15))
 >note : Symbol(note, Decl(underscoreTest1_underscoreTests.ts, 129, 15))
@@ -648,15 +648,15 @@ _.clone({ name: 'moe' });
 
 _.chain([1, 2, 3, 200])
 >_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap(<any>alert)    .map(function (num) { return num * num })    .value : Symbol(Underscore.ChainedObject.value, Decl(underscoreTest1_underscore.ts, 234, 46))
->_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap(<any>alert)    .map : Symbol(Underscore.ChainedArray.map, Decl(underscoreTest1_underscore.ts, 240, 81))
+>_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap(<any>alert)    .map : Symbol(Underscore.ChainedArray.map, Decl(underscoreTest1_underscore.ts, 240, 89))
 >_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap : Symbol(Underscore.ChainedArray.tap, Decl(underscoreTest1_underscore.ts, 325, 33))
->_.chain([1, 2, 3, 200])    .filter : Symbol(Underscore.ChainedArray.filter, Decl(underscoreTest1_underscore.ts, 254, 80))
+>_.chain([1, 2, 3, 200])    .filter : Symbol(Underscore.ChainedArray.filter, Decl(underscoreTest1_underscore.ts, 254, 88))
 >_.chain : Symbol(Underscore.Static.chain, Decl(underscoreTest1_underscore.ts, 391, 38), Decl(underscoreTest1_underscore.ts, 393, 45), Decl(underscoreTest1_underscore.ts, 394, 60))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
 >chain : Symbol(Underscore.Static.chain, Decl(underscoreTest1_underscore.ts, 391, 38), Decl(underscoreTest1_underscore.ts, 393, 45), Decl(underscoreTest1_underscore.ts, 394, 60))
 
     .filter(function (num) { return num % 2 == 0; })
->filter : Symbol(Underscore.ChainedArray.filter, Decl(underscoreTest1_underscore.ts, 254, 80))
+>filter : Symbol(Underscore.ChainedArray.filter, Decl(underscoreTest1_underscore.ts, 254, 88))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 157, 22))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 157, 22))
 
@@ -665,7 +665,7 @@ _.chain([1, 2, 3, 200])
 >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14))
 
     .map(function (num) { return num * num })
->map : Symbol(Underscore.ChainedArray.map, Decl(underscoreTest1_underscore.ts, 240, 81))
+>map : Symbol(Underscore.ChainedArray.map, Decl(underscoreTest1_underscore.ts, 240, 89))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 159, 19))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 159, 19))
 >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 159, 19))
@@ -852,9 +852,9 @@ _.times(3, function (n) { genie.grantWishNumber(n); });
 >n : Symbol(n, Decl(underscoreTest1_underscoreTests.ts, 218, 21))
 
 _.random(0, 100);
->_.random : Symbol(Underscore.Static.random, Decl(underscoreTest1_underscore.ts, 622, 79), Decl(underscoreTest1_underscore.ts, 624, 36))
+>_.random : Symbol(Underscore.Static.random, Decl(underscoreTest1_underscore.ts, 622, 87), Decl(underscoreTest1_underscore.ts, 624, 36))
 >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11))
->random : Symbol(Underscore.Static.random, Decl(underscoreTest1_underscore.ts, 622, 79), Decl(underscoreTest1_underscore.ts, 624, 36))
+>random : Symbol(Underscore.Static.random, Decl(underscoreTest1_underscore.ts, 622, 87), Decl(underscoreTest1_underscore.ts, 624, 36))
 
 _.mixin({
 >_.mixin : Symbol(Underscore.Static.mixin, Decl(underscoreTest1_underscore.ts, 625, 49))
@@ -976,32 +976,32 @@ interface Dictionary<T> {
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 0, 21))
 }
 
-interface Iterator<T, U> {
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
->T : Symbol(T, Decl(underscoreTest1_underscore.ts, 4, 19))
->U : Symbol(U, Decl(underscoreTest1_underscore.ts, 4, 21))
+interface IteratorCallback<T, U> {
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
+>T : Symbol(T, Decl(underscoreTest1_underscore.ts, 4, 27))
+>U : Symbol(U, Decl(underscoreTest1_underscore.ts, 4, 29))
 
     (value: T, index: any, list: any): U;
 >value : Symbol(value, Decl(underscoreTest1_underscore.ts, 5, 5))
->T : Symbol(T, Decl(underscoreTest1_underscore.ts, 4, 19))
+>T : Symbol(T, Decl(underscoreTest1_underscore.ts, 4, 27))
 >index : Symbol(index, Decl(underscoreTest1_underscore.ts, 5, 14))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 5, 26))
->U : Symbol(U, Decl(underscoreTest1_underscore.ts, 4, 21))
+>U : Symbol(U, Decl(underscoreTest1_underscore.ts, 4, 29))
 }
 
-interface Reducer<T, U> {
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
->T : Symbol(T, Decl(underscoreTest1_underscore.ts, 8, 18))
->U : Symbol(U, Decl(underscoreTest1_underscore.ts, 8, 20))
+interface ReducerCallback<T, U> {
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
+>T : Symbol(T, Decl(underscoreTest1_underscore.ts, 8, 26))
+>U : Symbol(U, Decl(underscoreTest1_underscore.ts, 8, 28))
 
     (accumulator: U, value: T, index: any, list: any): U;
 >accumulator : Symbol(accumulator, Decl(underscoreTest1_underscore.ts, 9, 5))
->U : Symbol(U, Decl(underscoreTest1_underscore.ts, 8, 20))
+>U : Symbol(U, Decl(underscoreTest1_underscore.ts, 8, 28))
 >value : Symbol(value, Decl(underscoreTest1_underscore.ts, 9, 20))
->T : Symbol(T, Decl(underscoreTest1_underscore.ts, 8, 18))
+>T : Symbol(T, Decl(underscoreTest1_underscore.ts, 8, 26))
 >index : Symbol(index, Decl(underscoreTest1_underscore.ts, 9, 30))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 9, 42))
->U : Symbol(U, Decl(underscoreTest1_underscore.ts, 8, 20))
+>U : Symbol(U, Decl(underscoreTest1_underscore.ts, 8, 28))
 }
 
 interface Tuple2<T0, T1> extends Array<any> {
@@ -1250,189 +1250,189 @@ module Underscore {
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
-        each(iterator: Iterator<T, void>, context?: any): void;
+        each(iterator: IteratorCallback<T, void>, context?: any): void;
 >each : Symbol(WrappedArray.each, Decl(underscoreTest1_underscore.ts, 79, 70))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 80, 13))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 80, 41))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 80, 49))
 
-        forEach(iterator: Iterator<T, void>, context?: any): void;
->forEach : Symbol(WrappedArray.forEach, Decl(underscoreTest1_underscore.ts, 80, 63))
+        forEach(iterator: IteratorCallback<T, void>, context?: any): void;
+>forEach : Symbol(WrappedArray.forEach, Decl(underscoreTest1_underscore.ts, 80, 71))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 81, 16))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 81, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 81, 52))
 
-        map<U>(iterator: Iterator<T, U>, context?: any): U[];
->map : Symbol(WrappedArray.map, Decl(underscoreTest1_underscore.ts, 81, 66))
+        map<U>(iterator: IteratorCallback<T, U>, context?: any): U[];
+>map : Symbol(WrappedArray.map, Decl(underscoreTest1_underscore.ts, 81, 74))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 82, 12))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 82, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 82, 12))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 82, 40))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 82, 48))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 82, 12))
 
-        collect<U>(iterator: Iterator<T, U>, context?: any): U[];
->collect : Symbol(WrappedArray.collect, Decl(underscoreTest1_underscore.ts, 82, 61))
+        collect<U>(iterator: IteratorCallback<T, U>, context?: any): U[];
+>collect : Symbol(WrappedArray.collect, Decl(underscoreTest1_underscore.ts, 82, 69))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 83, 16))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 83, 19))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 83, 16))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 83, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 83, 52))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 83, 16))
 
-        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->reduce : Symbol(WrappedArray.reduce, Decl(underscoreTest1_underscore.ts, 83, 65), Decl(underscoreTest1_underscore.ts, 84, 76))
+        reduce(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>reduce : Symbol(WrappedArray.reduce, Decl(underscoreTest1_underscore.ts, 83, 73), Decl(underscoreTest1_underscore.ts, 84, 84))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 84, 15))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 84, 39))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 84, 47))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 84, 57))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 84, 65))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
-        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->reduce : Symbol(WrappedArray.reduce, Decl(underscoreTest1_underscore.ts, 83, 65), Decl(underscoreTest1_underscore.ts, 84, 76))
+        reduce<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>reduce : Symbol(WrappedArray.reduce, Decl(underscoreTest1_underscore.ts, 83, 73), Decl(underscoreTest1_underscore.ts, 84, 84))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 85, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 85, 18))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 85, 15))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 85, 42))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 85, 50))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 85, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 85, 59))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 85, 67))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 85, 15))
 
-        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->foldl : Symbol(WrappedArray.foldl, Decl(underscoreTest1_underscore.ts, 85, 78), Decl(underscoreTest1_underscore.ts, 86, 75))
+        foldl(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>foldl : Symbol(WrappedArray.foldl, Decl(underscoreTest1_underscore.ts, 85, 86), Decl(underscoreTest1_underscore.ts, 86, 83))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 86, 14))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 86, 38))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 86, 46))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 86, 56))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 86, 64))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
-        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->foldl : Symbol(WrappedArray.foldl, Decl(underscoreTest1_underscore.ts, 85, 78), Decl(underscoreTest1_underscore.ts, 86, 75))
+        foldl<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>foldl : Symbol(WrappedArray.foldl, Decl(underscoreTest1_underscore.ts, 85, 86), Decl(underscoreTest1_underscore.ts, 86, 83))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 87, 14))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 87, 17))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 87, 14))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 87, 41))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 87, 49))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 87, 14))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 87, 58))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 87, 66))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 87, 14))
 
-        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->inject : Symbol(WrappedArray.inject, Decl(underscoreTest1_underscore.ts, 87, 77), Decl(underscoreTest1_underscore.ts, 88, 76))
+        inject(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>inject : Symbol(WrappedArray.inject, Decl(underscoreTest1_underscore.ts, 87, 85), Decl(underscoreTest1_underscore.ts, 88, 84))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 88, 15))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 88, 39))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 88, 47))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 88, 57))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 88, 65))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
-        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->inject : Symbol(WrappedArray.inject, Decl(underscoreTest1_underscore.ts, 87, 77), Decl(underscoreTest1_underscore.ts, 88, 76))
+        inject<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>inject : Symbol(WrappedArray.inject, Decl(underscoreTest1_underscore.ts, 87, 85), Decl(underscoreTest1_underscore.ts, 88, 84))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 89, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 89, 18))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 89, 15))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 89, 42))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 89, 50))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 89, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 89, 59))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 89, 67))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 89, 15))
 
-        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->reduceRight : Symbol(WrappedArray.reduceRight, Decl(underscoreTest1_underscore.ts, 89, 78), Decl(underscoreTest1_underscore.ts, 90, 81))
+        reduceRight(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>reduceRight : Symbol(WrappedArray.reduceRight, Decl(underscoreTest1_underscore.ts, 89, 86), Decl(underscoreTest1_underscore.ts, 90, 89))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 90, 20))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 90, 44))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 90, 52))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 90, 62))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 90, 70))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
-        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->reduceRight : Symbol(WrappedArray.reduceRight, Decl(underscoreTest1_underscore.ts, 89, 78), Decl(underscoreTest1_underscore.ts, 90, 81))
+        reduceRight<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>reduceRight : Symbol(WrappedArray.reduceRight, Decl(underscoreTest1_underscore.ts, 89, 86), Decl(underscoreTest1_underscore.ts, 90, 89))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 91, 20))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 91, 23))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 91, 20))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 91, 47))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 91, 55))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 91, 20))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 91, 64))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 91, 72))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 91, 20))
 
-        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->foldr : Symbol(WrappedArray.foldr, Decl(underscoreTest1_underscore.ts, 91, 83), Decl(underscoreTest1_underscore.ts, 92, 75))
+        foldr(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>foldr : Symbol(WrappedArray.foldr, Decl(underscoreTest1_underscore.ts, 91, 91), Decl(underscoreTest1_underscore.ts, 92, 83))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 92, 14))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 92, 38))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 92, 46))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 92, 56))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 92, 64))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
-        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->foldr : Symbol(WrappedArray.foldr, Decl(underscoreTest1_underscore.ts, 91, 83), Decl(underscoreTest1_underscore.ts, 92, 75))
+        foldr<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>foldr : Symbol(WrappedArray.foldr, Decl(underscoreTest1_underscore.ts, 91, 91), Decl(underscoreTest1_underscore.ts, 92, 83))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 93, 14))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 93, 17))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 93, 14))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 93, 41))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 93, 49))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 93, 14))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 93, 58))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 93, 66))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 93, 14))
 
-        find(iterator: Iterator<T, boolean>, context?: any): T;
->find : Symbol(WrappedArray.find, Decl(underscoreTest1_underscore.ts, 93, 77))
+        find(iterator: IteratorCallback<T, boolean>, context?: any): T;
+>find : Symbol(WrappedArray.find, Decl(underscoreTest1_underscore.ts, 93, 85))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 94, 13))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 94, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 94, 52))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
-        detect(iterator: Iterator<T, boolean>, context?: any): T;
->detect : Symbol(WrappedArray.detect, Decl(underscoreTest1_underscore.ts, 94, 63))
+        detect(iterator: IteratorCallback<T, boolean>, context?: any): T;
+>detect : Symbol(WrappedArray.detect, Decl(underscoreTest1_underscore.ts, 94, 71))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 95, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 95, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 95, 54))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
-        filter(iterator: Iterator<T, boolean>, context?: any): T[];
->filter : Symbol(WrappedArray.filter, Decl(underscoreTest1_underscore.ts, 95, 65))
+        filter(iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>filter : Symbol(WrappedArray.filter, Decl(underscoreTest1_underscore.ts, 95, 73))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 96, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 96, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 96, 54))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
-        select(iterator: Iterator<T, boolean>, context?: any): T[];
->select : Symbol(WrappedArray.select, Decl(underscoreTest1_underscore.ts, 96, 67))
+        select(iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>select : Symbol(WrappedArray.select, Decl(underscoreTest1_underscore.ts, 96, 75))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 97, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 97, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 97, 54))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
         where(properties: Object): T[];
->where : Symbol(WrappedArray.where, Decl(underscoreTest1_underscore.ts, 97, 67))
+>where : Symbol(WrappedArray.where, Decl(underscoreTest1_underscore.ts, 97, 75))
 >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 98, 14))
 >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
@@ -1443,44 +1443,44 @@ module Underscore {
 >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
-        reject(iterator: Iterator<T, boolean>, context?: any): T[];
+        reject(iterator: IteratorCallback<T, boolean>, context?: any): T[];
 >reject : Symbol(WrappedArray.reject, Decl(underscoreTest1_underscore.ts, 99, 41))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 100, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 100, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 100, 54))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
-        every(iterator?: Iterator<T, boolean>, context?: any): boolean;
->every : Symbol(WrappedArray.every, Decl(underscoreTest1_underscore.ts, 100, 67))
+        every(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>every : Symbol(WrappedArray.every, Decl(underscoreTest1_underscore.ts, 100, 75))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 101, 14))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 101, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 101, 54))
 
-        all(iterator?: Iterator<T, boolean>, context?: any): boolean;
->all : Symbol(WrappedArray.all, Decl(underscoreTest1_underscore.ts, 101, 71))
+        all(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>all : Symbol(WrappedArray.all, Decl(underscoreTest1_underscore.ts, 101, 79))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 102, 12))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 102, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 102, 52))
 
-        some(iterator?: Iterator<T, boolean>, context?: any): boolean;
->some : Symbol(WrappedArray.some, Decl(underscoreTest1_underscore.ts, 102, 69))
+        some(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>some : Symbol(WrappedArray.some, Decl(underscoreTest1_underscore.ts, 102, 77))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 103, 13))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 103, 45))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 103, 53))
 
-        any(iterator?: Iterator<T, boolean>, context?: any): boolean;
->any : Symbol(WrappedArray.any, Decl(underscoreTest1_underscore.ts, 103, 70))
+        any(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>any : Symbol(WrappedArray.any, Decl(underscoreTest1_underscore.ts, 103, 78))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 104, 12))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 104, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 104, 52))
 
         contains(value: T): boolean;
->contains : Symbol(WrappedArray.contains, Decl(underscoreTest1_underscore.ts, 104, 69))
+>contains : Symbol(WrappedArray.contains, Decl(underscoreTest1_underscore.ts, 104, 77))
 >value : Symbol(value, Decl(underscoreTest1_underscore.ts, 105, 17))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
@@ -1498,60 +1498,60 @@ module Underscore {
 >pluck : Symbol(WrappedArray.pluck, Decl(underscoreTest1_underscore.ts, 107, 58))
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 108, 14))
 
-        max(iterator?: Iterator<T, any>, context?: any): T;
+        max(iterator?: IteratorCallback<T, any>, context?: any): T;
 >max : Symbol(WrappedArray.max, Decl(underscoreTest1_underscore.ts, 108, 43))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 109, 12))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 109, 40))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 109, 48))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
-        min(iterator?: Iterator<T, any>, context?: any): T;
->min : Symbol(WrappedArray.min, Decl(underscoreTest1_underscore.ts, 109, 59))
+        min(iterator?: IteratorCallback<T, any>, context?: any): T;
+>min : Symbol(WrappedArray.min, Decl(underscoreTest1_underscore.ts, 109, 67))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 110, 12))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 110, 40))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 110, 48))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
-        sortBy(iterator: Iterator<T, any>, context?: any): T[];
->sortBy : Symbol(WrappedArray.sortBy, Decl(underscoreTest1_underscore.ts, 110, 59), Decl(underscoreTest1_underscore.ts, 111, 63))
+        sortBy(iterator: IteratorCallback<T, any>, context?: any): T[];
+>sortBy : Symbol(WrappedArray.sortBy, Decl(underscoreTest1_underscore.ts, 110, 67), Decl(underscoreTest1_underscore.ts, 111, 71))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 111, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 111, 42))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 111, 50))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
         sortBy(propertyName: string): T[];
->sortBy : Symbol(WrappedArray.sortBy, Decl(underscoreTest1_underscore.ts, 110, 59), Decl(underscoreTest1_underscore.ts, 111, 63))
+>sortBy : Symbol(WrappedArray.sortBy, Decl(underscoreTest1_underscore.ts, 110, 67), Decl(underscoreTest1_underscore.ts, 111, 71))
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 112, 15))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
-        groupBy(iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
->groupBy : Symbol(WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 77))
+        groupBy(iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>;
+>groupBy : Symbol(WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 85))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 113, 16))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 113, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 113, 52))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
         groupBy(propertyName: string): Dictionary<T[]>;
->groupBy : Symbol(WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 77))
+>groupBy : Symbol(WrappedArray.groupBy, Decl(underscoreTest1_underscore.ts, 112, 42), Decl(underscoreTest1_underscore.ts, 113, 85))
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 114, 16))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
-        countBy(iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
->countBy : Symbol(WrappedArray.countBy, Decl(underscoreTest1_underscore.ts, 114, 55), Decl(underscoreTest1_underscore.ts, 115, 80))
+        countBy(iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>;
+>countBy : Symbol(WrappedArray.countBy, Decl(underscoreTest1_underscore.ts, 114, 55), Decl(underscoreTest1_underscore.ts, 115, 88))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 115, 16))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 115, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 115, 52))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 
         countBy(propertyName: string): Dictionary<number>;
->countBy : Symbol(WrappedArray.countBy, Decl(underscoreTest1_underscore.ts, 114, 55), Decl(underscoreTest1_underscore.ts, 115, 80))
+>countBy : Symbol(WrappedArray.countBy, Decl(underscoreTest1_underscore.ts, 114, 55), Decl(underscoreTest1_underscore.ts, 115, 88))
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 116, 16))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 
@@ -1655,35 +1655,35 @@ module Underscore {
 >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 137, 13))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
-        uniq<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
+        uniq<U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[];
 >uniq : Symbol(WrappedArray.uniq, Decl(underscoreTest1_underscore.ts, 136, 42), Decl(underscoreTest1_underscore.ts, 137, 38))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 138, 13))
 >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 138, 16))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 138, 34))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 138, 13))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 138, 60))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 138, 68))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 138, 13))
 
         unique(isSorted?: boolean): T[];
->unique : Symbol(WrappedArray.unique, Decl(underscoreTest1_underscore.ts, 138, 81), Decl(underscoreTest1_underscore.ts, 139, 40))
+>unique : Symbol(WrappedArray.unique, Decl(underscoreTest1_underscore.ts, 138, 89), Decl(underscoreTest1_underscore.ts, 139, 40))
 >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 139, 15))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 
-        unique<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
->unique : Symbol(WrappedArray.unique, Decl(underscoreTest1_underscore.ts, 138, 81), Decl(underscoreTest1_underscore.ts, 139, 40))
+        unique<U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[];
+>unique : Symbol(WrappedArray.unique, Decl(underscoreTest1_underscore.ts, 138, 89), Decl(underscoreTest1_underscore.ts, 139, 40))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 140, 15))
 >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 140, 18))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 140, 36))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 140, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 140, 62))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 140, 70))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 140, 15))
 
         zip(...arrays: any[][]): any[][];
->zip : Symbol(WrappedArray.zip, Decl(underscoreTest1_underscore.ts, 140, 83))
+>zip : Symbol(WrappedArray.zip, Decl(underscoreTest1_underscore.ts, 140, 91))
 >arrays : Symbol(arrays, Decl(underscoreTest1_underscore.ts, 141, 12))
 
         object(): any;
@@ -1711,18 +1711,18 @@ module Underscore {
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 146, 27))
 
-        sortedIndex(obj: T, iterator?: Iterator<T, any>, context?: any): number;
+        sortedIndex(obj: T, iterator?: IteratorCallback<T, any>, context?: any): number;
 >sortedIndex : Symbol(WrappedArray.sortedIndex, Decl(underscoreTest1_underscore.ts, 145, 58), Decl(underscoreTest1_underscore.ts, 146, 58))
 >obj : Symbol(obj, Decl(underscoreTest1_underscore.ts, 147, 20))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 147, 27))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 147, 56))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 147, 64))
 
         // Methods from Array
         concat(...items: T[]): T[];
->concat : Symbol(WrappedArray.concat, Decl(underscoreTest1_underscore.ts, 147, 80))
+>concat : Symbol(WrappedArray.concat, Decl(underscoreTest1_underscore.ts, 147, 88))
 >items : Symbol(items, Decl(underscoreTest1_underscore.ts, 149, 15))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34))
@@ -1789,189 +1789,189 @@ module Underscore {
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
-        each(iterator: Iterator<T, void>, context?: any): void;
+        each(iterator: IteratorCallback<T, void>, context?: any): void;
 >each : Symbol(WrappedDictionary.each, Decl(underscoreTest1_underscore.ts, 162, 80))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 163, 13))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 163, 41))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 163, 49))
 
-        forEach(iterator: Iterator<T, void>, context?: any): void;
->forEach : Symbol(WrappedDictionary.forEach, Decl(underscoreTest1_underscore.ts, 163, 63))
+        forEach(iterator: IteratorCallback<T, void>, context?: any): void;
+>forEach : Symbol(WrappedDictionary.forEach, Decl(underscoreTest1_underscore.ts, 163, 71))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 164, 16))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 164, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 164, 52))
 
-        map<U>(iterator: Iterator<T, U>, context?: any): U[];
->map : Symbol(WrappedDictionary.map, Decl(underscoreTest1_underscore.ts, 164, 66))
+        map<U>(iterator: IteratorCallback<T, U>, context?: any): U[];
+>map : Symbol(WrappedDictionary.map, Decl(underscoreTest1_underscore.ts, 164, 74))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 165, 12))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 165, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 165, 12))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 165, 40))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 165, 48))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 165, 12))
 
-        collect<U>(iterator: Iterator<T, U>, context?: any): U[];
->collect : Symbol(WrappedDictionary.collect, Decl(underscoreTest1_underscore.ts, 165, 61))
+        collect<U>(iterator: IteratorCallback<T, U>, context?: any): U[];
+>collect : Symbol(WrappedDictionary.collect, Decl(underscoreTest1_underscore.ts, 165, 69))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 166, 16))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 166, 19))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 166, 16))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 166, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 166, 52))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 166, 16))
 
-        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->reduce : Symbol(WrappedDictionary.reduce, Decl(underscoreTest1_underscore.ts, 166, 65), Decl(underscoreTest1_underscore.ts, 167, 76))
+        reduce(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>reduce : Symbol(WrappedDictionary.reduce, Decl(underscoreTest1_underscore.ts, 166, 73), Decl(underscoreTest1_underscore.ts, 167, 84))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 167, 15))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 167, 39))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 167, 47))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 167, 57))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 167, 65))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
-        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->reduce : Symbol(WrappedDictionary.reduce, Decl(underscoreTest1_underscore.ts, 166, 65), Decl(underscoreTest1_underscore.ts, 167, 76))
+        reduce<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>reduce : Symbol(WrappedDictionary.reduce, Decl(underscoreTest1_underscore.ts, 166, 73), Decl(underscoreTest1_underscore.ts, 167, 84))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 168, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 168, 18))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 168, 15))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 168, 42))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 168, 50))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 168, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 168, 59))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 168, 67))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 168, 15))
 
-        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->foldl : Symbol(WrappedDictionary.foldl, Decl(underscoreTest1_underscore.ts, 168, 78), Decl(underscoreTest1_underscore.ts, 169, 75))
+        foldl(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>foldl : Symbol(WrappedDictionary.foldl, Decl(underscoreTest1_underscore.ts, 168, 86), Decl(underscoreTest1_underscore.ts, 169, 83))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 169, 14))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 169, 38))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 169, 46))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 169, 56))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 169, 64))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
-        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->foldl : Symbol(WrappedDictionary.foldl, Decl(underscoreTest1_underscore.ts, 168, 78), Decl(underscoreTest1_underscore.ts, 169, 75))
+        foldl<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>foldl : Symbol(WrappedDictionary.foldl, Decl(underscoreTest1_underscore.ts, 168, 86), Decl(underscoreTest1_underscore.ts, 169, 83))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 170, 14))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 170, 17))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 170, 14))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 170, 41))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 170, 49))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 170, 14))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 170, 58))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 170, 66))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 170, 14))
 
-        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->inject : Symbol(WrappedDictionary.inject, Decl(underscoreTest1_underscore.ts, 170, 77), Decl(underscoreTest1_underscore.ts, 171, 76))
+        inject(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>inject : Symbol(WrappedDictionary.inject, Decl(underscoreTest1_underscore.ts, 170, 85), Decl(underscoreTest1_underscore.ts, 171, 84))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 171, 15))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 171, 39))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 171, 47))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 171, 57))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 171, 65))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
-        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->inject : Symbol(WrappedDictionary.inject, Decl(underscoreTest1_underscore.ts, 170, 77), Decl(underscoreTest1_underscore.ts, 171, 76))
+        inject<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>inject : Symbol(WrappedDictionary.inject, Decl(underscoreTest1_underscore.ts, 170, 85), Decl(underscoreTest1_underscore.ts, 171, 84))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 172, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 172, 18))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 172, 15))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 172, 42))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 172, 50))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 172, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 172, 59))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 172, 67))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 172, 15))
 
-        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->reduceRight : Symbol(WrappedDictionary.reduceRight, Decl(underscoreTest1_underscore.ts, 172, 78), Decl(underscoreTest1_underscore.ts, 173, 81))
+        reduceRight(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>reduceRight : Symbol(WrappedDictionary.reduceRight, Decl(underscoreTest1_underscore.ts, 172, 86), Decl(underscoreTest1_underscore.ts, 173, 89))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 173, 20))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 173, 44))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 173, 52))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 173, 62))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 173, 70))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
-        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->reduceRight : Symbol(WrappedDictionary.reduceRight, Decl(underscoreTest1_underscore.ts, 172, 78), Decl(underscoreTest1_underscore.ts, 173, 81))
+        reduceRight<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>reduceRight : Symbol(WrappedDictionary.reduceRight, Decl(underscoreTest1_underscore.ts, 172, 86), Decl(underscoreTest1_underscore.ts, 173, 89))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 174, 20))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 174, 23))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 174, 20))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 174, 47))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 174, 55))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 174, 20))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 174, 64))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 174, 72))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 174, 20))
 
-        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->foldr : Symbol(WrappedDictionary.foldr, Decl(underscoreTest1_underscore.ts, 174, 83), Decl(underscoreTest1_underscore.ts, 175, 75))
+        foldr(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>foldr : Symbol(WrappedDictionary.foldr, Decl(underscoreTest1_underscore.ts, 174, 91), Decl(underscoreTest1_underscore.ts, 175, 83))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 175, 14))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 175, 38))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 175, 46))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 175, 56))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 175, 64))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
-        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->foldr : Symbol(WrappedDictionary.foldr, Decl(underscoreTest1_underscore.ts, 174, 83), Decl(underscoreTest1_underscore.ts, 175, 75))
+        foldr<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>foldr : Symbol(WrappedDictionary.foldr, Decl(underscoreTest1_underscore.ts, 174, 91), Decl(underscoreTest1_underscore.ts, 175, 83))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 176, 14))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 176, 17))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 176, 14))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 176, 41))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 176, 49))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 176, 14))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 176, 58))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 176, 66))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 176, 14))
 
-        find(iterator: Iterator<T, boolean>, context?: any): T;
->find : Symbol(WrappedDictionary.find, Decl(underscoreTest1_underscore.ts, 176, 77))
+        find(iterator: IteratorCallback<T, boolean>, context?: any): T;
+>find : Symbol(WrappedDictionary.find, Decl(underscoreTest1_underscore.ts, 176, 85))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 177, 13))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 177, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 177, 52))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
-        detect(iterator: Iterator<T, boolean>, context?: any): T;
->detect : Symbol(WrappedDictionary.detect, Decl(underscoreTest1_underscore.ts, 177, 63))
+        detect(iterator: IteratorCallback<T, boolean>, context?: any): T;
+>detect : Symbol(WrappedDictionary.detect, Decl(underscoreTest1_underscore.ts, 177, 71))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 178, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 178, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 178, 54))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
-        filter(iterator: Iterator<T, boolean>, context?: any): T[];
->filter : Symbol(WrappedDictionary.filter, Decl(underscoreTest1_underscore.ts, 178, 65))
+        filter(iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>filter : Symbol(WrappedDictionary.filter, Decl(underscoreTest1_underscore.ts, 178, 73))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 179, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 179, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 179, 54))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
-        select(iterator: Iterator<T, boolean>, context?: any): T[];
->select : Symbol(WrappedDictionary.select, Decl(underscoreTest1_underscore.ts, 179, 67))
+        select(iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>select : Symbol(WrappedDictionary.select, Decl(underscoreTest1_underscore.ts, 179, 75))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 180, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 180, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 180, 54))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
         where(properties: Object): T[];
->where : Symbol(WrappedDictionary.where, Decl(underscoreTest1_underscore.ts, 180, 67))
+>where : Symbol(WrappedDictionary.where, Decl(underscoreTest1_underscore.ts, 180, 75))
 >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 181, 14))
 >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
@@ -1982,44 +1982,44 @@ module Underscore {
 >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
-        reject(iterator: Iterator<T, boolean>, context?: any): T[];
+        reject(iterator: IteratorCallback<T, boolean>, context?: any): T[];
 >reject : Symbol(WrappedDictionary.reject, Decl(underscoreTest1_underscore.ts, 182, 41))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 183, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 183, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 183, 54))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
-        every(iterator?: Iterator<T, boolean>, context?: any): boolean;
->every : Symbol(WrappedDictionary.every, Decl(underscoreTest1_underscore.ts, 183, 67))
+        every(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>every : Symbol(WrappedDictionary.every, Decl(underscoreTest1_underscore.ts, 183, 75))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 184, 14))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 184, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 184, 54))
 
-        all(iterator?: Iterator<T, boolean>, context?: any): boolean;
->all : Symbol(WrappedDictionary.all, Decl(underscoreTest1_underscore.ts, 184, 71))
+        all(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>all : Symbol(WrappedDictionary.all, Decl(underscoreTest1_underscore.ts, 184, 79))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 185, 12))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 185, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 185, 52))
 
-        some(iterator?: Iterator<T, boolean>, context?: any): boolean;
->some : Symbol(WrappedDictionary.some, Decl(underscoreTest1_underscore.ts, 185, 69))
+        some(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>some : Symbol(WrappedDictionary.some, Decl(underscoreTest1_underscore.ts, 185, 77))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 186, 13))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 186, 45))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 186, 53))
 
-        any(iterator?: Iterator<T, boolean>, context?: any): boolean;
->any : Symbol(WrappedDictionary.any, Decl(underscoreTest1_underscore.ts, 186, 70))
+        any(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>any : Symbol(WrappedDictionary.any, Decl(underscoreTest1_underscore.ts, 186, 78))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 187, 12))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 187, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 187, 52))
 
         contains(value: T): boolean;
->contains : Symbol(WrappedDictionary.contains, Decl(underscoreTest1_underscore.ts, 187, 69))
+>contains : Symbol(WrappedDictionary.contains, Decl(underscoreTest1_underscore.ts, 187, 77))
 >value : Symbol(value, Decl(underscoreTest1_underscore.ts, 188, 17))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
@@ -2037,60 +2037,60 @@ module Underscore {
 >pluck : Symbol(WrappedDictionary.pluck, Decl(underscoreTest1_underscore.ts, 190, 58))
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 191, 14))
 
-        max(iterator?: Iterator<T, any>, context?: any): T;
+        max(iterator?: IteratorCallback<T, any>, context?: any): T;
 >max : Symbol(WrappedDictionary.max, Decl(underscoreTest1_underscore.ts, 191, 43))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 192, 12))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 192, 40))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 192, 48))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
-        min(iterator?: Iterator<T, any>, context?: any): T;
->min : Symbol(WrappedDictionary.min, Decl(underscoreTest1_underscore.ts, 192, 59))
+        min(iterator?: IteratorCallback<T, any>, context?: any): T;
+>min : Symbol(WrappedDictionary.min, Decl(underscoreTest1_underscore.ts, 192, 67))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 193, 12))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 193, 40))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 193, 48))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
-        sortBy(iterator: Iterator<T, any>, context?: any): T[];
->sortBy : Symbol(WrappedDictionary.sortBy, Decl(underscoreTest1_underscore.ts, 193, 59), Decl(underscoreTest1_underscore.ts, 194, 63))
+        sortBy(iterator: IteratorCallback<T, any>, context?: any): T[];
+>sortBy : Symbol(WrappedDictionary.sortBy, Decl(underscoreTest1_underscore.ts, 193, 67), Decl(underscoreTest1_underscore.ts, 194, 71))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 194, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 194, 42))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 194, 50))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
         sortBy(propertyName: string): T[];
->sortBy : Symbol(WrappedDictionary.sortBy, Decl(underscoreTest1_underscore.ts, 193, 59), Decl(underscoreTest1_underscore.ts, 194, 63))
+>sortBy : Symbol(WrappedDictionary.sortBy, Decl(underscoreTest1_underscore.ts, 193, 67), Decl(underscoreTest1_underscore.ts, 194, 71))
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 195, 15))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
-        groupBy(iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
->groupBy : Symbol(WrappedDictionary.groupBy, Decl(underscoreTest1_underscore.ts, 195, 42), Decl(underscoreTest1_underscore.ts, 196, 77))
+        groupBy(iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>;
+>groupBy : Symbol(WrappedDictionary.groupBy, Decl(underscoreTest1_underscore.ts, 195, 42), Decl(underscoreTest1_underscore.ts, 196, 85))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 196, 16))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 196, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 196, 52))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
         groupBy(propertyName: string): Dictionary<T[]>;
->groupBy : Symbol(WrappedDictionary.groupBy, Decl(underscoreTest1_underscore.ts, 195, 42), Decl(underscoreTest1_underscore.ts, 196, 77))
+>groupBy : Symbol(WrappedDictionary.groupBy, Decl(underscoreTest1_underscore.ts, 195, 42), Decl(underscoreTest1_underscore.ts, 196, 85))
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 197, 16))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
 
-        countBy(iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
->countBy : Symbol(WrappedDictionary.countBy, Decl(underscoreTest1_underscore.ts, 197, 55), Decl(underscoreTest1_underscore.ts, 198, 80))
+        countBy(iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>;
+>countBy : Symbol(WrappedDictionary.countBy, Decl(underscoreTest1_underscore.ts, 197, 55), Decl(underscoreTest1_underscore.ts, 198, 88))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 198, 16))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 198, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 198, 52))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 
         countBy(propertyName: string): Dictionary<number>;
->countBy : Symbol(WrappedDictionary.countBy, Decl(underscoreTest1_underscore.ts, 197, 55), Decl(underscoreTest1_underscore.ts, 198, 80))
+>countBy : Symbol(WrappedDictionary.countBy, Decl(underscoreTest1_underscore.ts, 197, 55), Decl(underscoreTest1_underscore.ts, 198, 88))
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 199, 16))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 
@@ -2254,207 +2254,207 @@ module Underscore {
 >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
-        each(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
+        each(iterator: IteratorCallback<T, void>, context?: any): ChainedObject<void>;
 >each : Symbol(ChainedArray.each, Decl(underscoreTest1_underscore.ts, 238, 70))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 239, 13))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 239, 41))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 239, 49))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 
-        forEach(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
->forEach : Symbol(ChainedArray.forEach, Decl(underscoreTest1_underscore.ts, 239, 78))
+        forEach(iterator: IteratorCallback<T, void>, context?: any): ChainedObject<void>;
+>forEach : Symbol(ChainedArray.forEach, Decl(underscoreTest1_underscore.ts, 239, 86))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 240, 16))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 240, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 240, 52))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 
-        map<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
->map : Symbol(ChainedArray.map, Decl(underscoreTest1_underscore.ts, 240, 81))
+        map<U>(iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
+>map : Symbol(ChainedArray.map, Decl(underscoreTest1_underscore.ts, 240, 89))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 241, 12))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 241, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 241, 12))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 241, 40))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 241, 48))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 241, 12))
 
-        collect<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
->collect : Symbol(ChainedArray.collect, Decl(underscoreTest1_underscore.ts, 241, 73))
+        collect<U>(iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
+>collect : Symbol(ChainedArray.collect, Decl(underscoreTest1_underscore.ts, 241, 81))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 242, 16))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 242, 19))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 242, 16))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 242, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 242, 52))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 242, 16))
 
-        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->reduce : Symbol(ChainedArray.reduce, Decl(underscoreTest1_underscore.ts, 242, 77), Decl(underscoreTest1_underscore.ts, 243, 91))
+        reduce(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>reduce : Symbol(ChainedArray.reduce, Decl(underscoreTest1_underscore.ts, 242, 85), Decl(underscoreTest1_underscore.ts, 243, 99))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 243, 15))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 243, 39))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 243, 47))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 243, 57))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 243, 65))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
-        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->reduce : Symbol(ChainedArray.reduce, Decl(underscoreTest1_underscore.ts, 242, 77), Decl(underscoreTest1_underscore.ts, 243, 91))
+        reduce<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>reduce : Symbol(ChainedArray.reduce, Decl(underscoreTest1_underscore.ts, 242, 85), Decl(underscoreTest1_underscore.ts, 243, 99))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 244, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 244, 18))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 244, 15))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 244, 42))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 244, 50))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 244, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 244, 59))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 244, 67))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 244, 15))
 
-        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->foldl : Symbol(ChainedArray.foldl, Decl(underscoreTest1_underscore.ts, 244, 93), Decl(underscoreTest1_underscore.ts, 245, 90))
+        foldl(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>foldl : Symbol(ChainedArray.foldl, Decl(underscoreTest1_underscore.ts, 244, 101), Decl(underscoreTest1_underscore.ts, 245, 98))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 245, 14))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 245, 38))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 245, 46))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 245, 56))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 245, 64))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
-        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->foldl : Symbol(ChainedArray.foldl, Decl(underscoreTest1_underscore.ts, 244, 93), Decl(underscoreTest1_underscore.ts, 245, 90))
+        foldl<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>foldl : Symbol(ChainedArray.foldl, Decl(underscoreTest1_underscore.ts, 244, 101), Decl(underscoreTest1_underscore.ts, 245, 98))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 246, 14))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 246, 17))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 246, 14))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 246, 41))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 246, 49))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 246, 14))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 246, 58))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 246, 66))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 246, 14))
 
-        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->inject : Symbol(ChainedArray.inject, Decl(underscoreTest1_underscore.ts, 246, 92), Decl(underscoreTest1_underscore.ts, 247, 91))
+        inject(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>inject : Symbol(ChainedArray.inject, Decl(underscoreTest1_underscore.ts, 246, 100), Decl(underscoreTest1_underscore.ts, 247, 99))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 247, 15))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 247, 39))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 247, 47))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 247, 57))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 247, 65))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
-        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->inject : Symbol(ChainedArray.inject, Decl(underscoreTest1_underscore.ts, 246, 92), Decl(underscoreTest1_underscore.ts, 247, 91))
+        inject<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>inject : Symbol(ChainedArray.inject, Decl(underscoreTest1_underscore.ts, 246, 100), Decl(underscoreTest1_underscore.ts, 247, 99))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 248, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 248, 18))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 248, 15))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 248, 42))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 248, 50))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 248, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 248, 59))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 248, 67))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 248, 15))
 
-        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->reduceRight : Symbol(ChainedArray.reduceRight, Decl(underscoreTest1_underscore.ts, 248, 93), Decl(underscoreTest1_underscore.ts, 249, 96))
+        reduceRight(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>reduceRight : Symbol(ChainedArray.reduceRight, Decl(underscoreTest1_underscore.ts, 248, 101), Decl(underscoreTest1_underscore.ts, 249, 104))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 249, 20))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 249, 44))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 249, 52))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 249, 62))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 249, 70))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
-        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->reduceRight : Symbol(ChainedArray.reduceRight, Decl(underscoreTest1_underscore.ts, 248, 93), Decl(underscoreTest1_underscore.ts, 249, 96))
+        reduceRight<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>reduceRight : Symbol(ChainedArray.reduceRight, Decl(underscoreTest1_underscore.ts, 248, 101), Decl(underscoreTest1_underscore.ts, 249, 104))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 250, 20))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 250, 23))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 250, 20))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 250, 47))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 250, 55))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 250, 20))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 250, 64))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 250, 72))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 250, 20))
 
-        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->foldr : Symbol(ChainedArray.foldr, Decl(underscoreTest1_underscore.ts, 250, 98), Decl(underscoreTest1_underscore.ts, 251, 90))
+        foldr(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>foldr : Symbol(ChainedArray.foldr, Decl(underscoreTest1_underscore.ts, 250, 106), Decl(underscoreTest1_underscore.ts, 251, 98))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 251, 14))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 251, 38))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 251, 46))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 251, 56))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 251, 64))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
-        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->foldr : Symbol(ChainedArray.foldr, Decl(underscoreTest1_underscore.ts, 250, 98), Decl(underscoreTest1_underscore.ts, 251, 90))
+        foldr<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>foldr : Symbol(ChainedArray.foldr, Decl(underscoreTest1_underscore.ts, 250, 106), Decl(underscoreTest1_underscore.ts, 251, 98))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 252, 14))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 252, 17))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 252, 14))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 252, 41))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 252, 49))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 252, 14))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 252, 58))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 252, 66))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 252, 14))
 
-        find(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
->find : Symbol(ChainedArray.find, Decl(underscoreTest1_underscore.ts, 252, 92))
+        find(iterator: IteratorCallback<T, boolean>, context?: any): ChainedObject<T>;
+>find : Symbol(ChainedArray.find, Decl(underscoreTest1_underscore.ts, 252, 100))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 253, 13))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 253, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 253, 52))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
-        detect(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
->detect : Symbol(ChainedArray.detect, Decl(underscoreTest1_underscore.ts, 253, 78))
+        detect(iterator: IteratorCallback<T, boolean>, context?: any): ChainedObject<T>;
+>detect : Symbol(ChainedArray.detect, Decl(underscoreTest1_underscore.ts, 253, 86))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 254, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 254, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 254, 54))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
-        filter(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
->filter : Symbol(ChainedArray.filter, Decl(underscoreTest1_underscore.ts, 254, 80))
+        filter(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
+>filter : Symbol(ChainedArray.filter, Decl(underscoreTest1_underscore.ts, 254, 88))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 255, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 255, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 255, 54))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
-        select(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
->select : Symbol(ChainedArray.select, Decl(underscoreTest1_underscore.ts, 255, 79))
+        select(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
+>select : Symbol(ChainedArray.select, Decl(underscoreTest1_underscore.ts, 255, 87))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 256, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 256, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 256, 54))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
         where(properties: Object): ChainedArray<T>;
->where : Symbol(ChainedArray.where, Decl(underscoreTest1_underscore.ts, 256, 79))
+>where : Symbol(ChainedArray.where, Decl(underscoreTest1_underscore.ts, 256, 87))
 >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 257, 14))
 >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
@@ -2467,49 +2467,49 @@ module Underscore {
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
-        reject(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
+        reject(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
 >reject : Symbol(ChainedArray.reject, Decl(underscoreTest1_underscore.ts, 258, 56))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 259, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 259, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 259, 54))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
-        every(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
->every : Symbol(ChainedArray.every, Decl(underscoreTest1_underscore.ts, 259, 79))
+        every(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+>every : Symbol(ChainedArray.every, Decl(underscoreTest1_underscore.ts, 259, 87))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 260, 14))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 260, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 260, 54))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 
-        all(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
->all : Symbol(ChainedArray.all, Decl(underscoreTest1_underscore.ts, 260, 86))
+        all(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+>all : Symbol(ChainedArray.all, Decl(underscoreTest1_underscore.ts, 260, 94))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 261, 12))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 261, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 261, 52))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 
-        some(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
->some : Symbol(ChainedArray.some, Decl(underscoreTest1_underscore.ts, 261, 84))
+        some(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+>some : Symbol(ChainedArray.some, Decl(underscoreTest1_underscore.ts, 261, 92))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 262, 13))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 262, 45))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 262, 53))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 
-        any(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
->any : Symbol(ChainedArray.any, Decl(underscoreTest1_underscore.ts, 262, 85))
+        any(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+>any : Symbol(ChainedArray.any, Decl(underscoreTest1_underscore.ts, 262, 93))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 263, 12))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 263, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 263, 52))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 
         contains(value: T): ChainedObject<boolean>;
->contains : Symbol(ChainedArray.contains, Decl(underscoreTest1_underscore.ts, 263, 84))
+>contains : Symbol(ChainedArray.contains, Decl(underscoreTest1_underscore.ts, 263, 92))
 >value : Symbol(value, Decl(underscoreTest1_underscore.ts, 264, 17))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
@@ -2531,63 +2531,63 @@ module Underscore {
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 267, 14))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 
-        max(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
+        max(iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<T>;
 >max : Symbol(ChainedArray.max, Decl(underscoreTest1_underscore.ts, 267, 55))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 268, 12))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 268, 40))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 268, 48))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
-        min(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
->min : Symbol(ChainedArray.min, Decl(underscoreTest1_underscore.ts, 268, 74))
+        min(iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<T>;
+>min : Symbol(ChainedArray.min, Decl(underscoreTest1_underscore.ts, 268, 82))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 269, 12))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 269, 40))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 269, 48))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
-        sortBy(iterator: Iterator<T, any>, context?: any): ChainedArray<T>;
->sortBy : Symbol(ChainedArray.sortBy, Decl(underscoreTest1_underscore.ts, 269, 74), Decl(underscoreTest1_underscore.ts, 270, 75))
+        sortBy(iterator: IteratorCallback<T, any>, context?: any): ChainedArray<T>;
+>sortBy : Symbol(ChainedArray.sortBy, Decl(underscoreTest1_underscore.ts, 269, 82), Decl(underscoreTest1_underscore.ts, 270, 83))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 270, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 270, 42))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 270, 50))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
         sortBy(propertyName: string): ChainedArray<T>;
->sortBy : Symbol(ChainedArray.sortBy, Decl(underscoreTest1_underscore.ts, 269, 74), Decl(underscoreTest1_underscore.ts, 270, 75))
+>sortBy : Symbol(ChainedArray.sortBy, Decl(underscoreTest1_underscore.ts, 269, 82), Decl(underscoreTest1_underscore.ts, 270, 83))
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 271, 15))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
         // Should return ChainedDictionary<T[]>, but expansive recursion not allowed
-        groupBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<any[]>;
->groupBy : Symbol(ChainedArray.groupBy, Decl(underscoreTest1_underscore.ts, 271, 54), Decl(underscoreTest1_underscore.ts, 273, 86))
+        groupBy(iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<any[]>;
+>groupBy : Symbol(ChainedArray.groupBy, Decl(underscoreTest1_underscore.ts, 271, 54), Decl(underscoreTest1_underscore.ts, 273, 94))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 273, 16))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 273, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 273, 52))
 >ChainedDictionary : Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))
 
         groupBy(propertyName: string): ChainedDictionary<any[]>;
->groupBy : Symbol(ChainedArray.groupBy, Decl(underscoreTest1_underscore.ts, 271, 54), Decl(underscoreTest1_underscore.ts, 273, 86))
+>groupBy : Symbol(ChainedArray.groupBy, Decl(underscoreTest1_underscore.ts, 271, 54), Decl(underscoreTest1_underscore.ts, 273, 94))
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 274, 16))
 >ChainedDictionary : Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))
 
-        countBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<number>;
->countBy : Symbol(ChainedArray.countBy, Decl(underscoreTest1_underscore.ts, 274, 64), Decl(underscoreTest1_underscore.ts, 275, 87))
+        countBy(iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<number>;
+>countBy : Symbol(ChainedArray.countBy, Decl(underscoreTest1_underscore.ts, 274, 64), Decl(underscoreTest1_underscore.ts, 275, 95))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 275, 16))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 275, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 275, 52))
 >ChainedDictionary : Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))
 
         countBy(propertyName: string): ChainedDictionary<number>;
->countBy : Symbol(ChainedArray.countBy, Decl(underscoreTest1_underscore.ts, 274, 64), Decl(underscoreTest1_underscore.ts, 275, 87))
+>countBy : Symbol(ChainedArray.countBy, Decl(underscoreTest1_underscore.ts, 274, 64), Decl(underscoreTest1_underscore.ts, 275, 95))
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 276, 16))
 >ChainedDictionary : Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))
 
@@ -2712,38 +2712,38 @@ module Underscore {
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
-        uniq<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
+        uniq<U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
 >uniq : Symbol(ChainedArray.uniq, Decl(underscoreTest1_underscore.ts, 296, 54), Decl(underscoreTest1_underscore.ts, 297, 50))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 298, 13))
 >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 298, 16))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 298, 34))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 298, 13))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 298, 60))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 298, 68))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 298, 13))
 
         unique(isSorted?: boolean): ChainedArray<T>;
->unique : Symbol(ChainedArray.unique, Decl(underscoreTest1_underscore.ts, 298, 93), Decl(underscoreTest1_underscore.ts, 299, 52))
+>unique : Symbol(ChainedArray.unique, Decl(underscoreTest1_underscore.ts, 298, 101), Decl(underscoreTest1_underscore.ts, 299, 52))
 >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 299, 15))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 
-        unique<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
->unique : Symbol(ChainedArray.unique, Decl(underscoreTest1_underscore.ts, 298, 93), Decl(underscoreTest1_underscore.ts, 299, 52))
+        unique<U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
+>unique : Symbol(ChainedArray.unique, Decl(underscoreTest1_underscore.ts, 298, 101), Decl(underscoreTest1_underscore.ts, 299, 52))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 300, 15))
 >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 300, 18))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 300, 36))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 300, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 300, 62))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 300, 70))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 300, 15))
 
         zip(...arrays: any[][]): ChainedArray<any[]>;
->zip : Symbol(ChainedArray.zip, Decl(underscoreTest1_underscore.ts, 300, 95))
+>zip : Symbol(ChainedArray.zip, Decl(underscoreTest1_underscore.ts, 300, 103))
 >arrays : Symbol(arrays, Decl(underscoreTest1_underscore.ts, 301, 12))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 
@@ -2777,19 +2777,19 @@ module Underscore {
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 306, 27))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 
-        sortedIndex(obj: T, iterator?: Iterator<T, any>, context?: any): ChainedObject<number>;
+        sortedIndex(obj: T, iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<number>;
 >sortedIndex : Symbol(ChainedArray.sortedIndex, Decl(underscoreTest1_underscore.ts, 305, 73), Decl(underscoreTest1_underscore.ts, 306, 73))
 >obj : Symbol(obj, Decl(underscoreTest1_underscore.ts, 307, 20))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 307, 27))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 307, 56))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 307, 64))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 
         // Methods from Array
         concat(...items: T[]): ChainedArray<T>;
->concat : Symbol(ChainedArray.concat, Decl(underscoreTest1_underscore.ts, 307, 95))
+>concat : Symbol(ChainedArray.concat, Decl(underscoreTest1_underscore.ts, 307, 103))
 >items : Symbol(items, Decl(underscoreTest1_underscore.ts, 309, 15))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
@@ -2905,207 +2905,207 @@ module Underscore {
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 
-        each(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
+        each(iterator: IteratorCallback<T, void>, context?: any): ChainedObject<void>;
 >each : Symbol(ChainedDictionary.each, Decl(underscoreTest1_underscore.ts, 329, 80))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 330, 13))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 330, 41))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 330, 49))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 
-        forEach(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
->forEach : Symbol(ChainedDictionary.forEach, Decl(underscoreTest1_underscore.ts, 330, 78))
+        forEach(iterator: IteratorCallback<T, void>, context?: any): ChainedObject<void>;
+>forEach : Symbol(ChainedDictionary.forEach, Decl(underscoreTest1_underscore.ts, 330, 86))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 331, 16))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 331, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 331, 52))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 
-        map<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
->map : Symbol(ChainedDictionary.map, Decl(underscoreTest1_underscore.ts, 331, 81))
+        map<U>(iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
+>map : Symbol(ChainedDictionary.map, Decl(underscoreTest1_underscore.ts, 331, 89))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 332, 12))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 332, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 332, 12))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 332, 40))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 332, 48))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 332, 12))
 
-        collect<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
->collect : Symbol(ChainedDictionary.collect, Decl(underscoreTest1_underscore.ts, 332, 73))
+        collect<U>(iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
+>collect : Symbol(ChainedDictionary.collect, Decl(underscoreTest1_underscore.ts, 332, 81))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 333, 16))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 333, 19))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 333, 16))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 333, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 333, 52))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 333, 16))
 
-        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->reduce : Symbol(ChainedDictionary.reduce, Decl(underscoreTest1_underscore.ts, 333, 77), Decl(underscoreTest1_underscore.ts, 334, 91))
+        reduce(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>reduce : Symbol(ChainedDictionary.reduce, Decl(underscoreTest1_underscore.ts, 333, 85), Decl(underscoreTest1_underscore.ts, 334, 99))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 334, 15))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 334, 39))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 334, 47))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 334, 57))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 334, 65))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 
-        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->reduce : Symbol(ChainedDictionary.reduce, Decl(underscoreTest1_underscore.ts, 333, 77), Decl(underscoreTest1_underscore.ts, 334, 91))
+        reduce<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>reduce : Symbol(ChainedDictionary.reduce, Decl(underscoreTest1_underscore.ts, 333, 85), Decl(underscoreTest1_underscore.ts, 334, 99))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 335, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 335, 18))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 335, 15))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 335, 42))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 335, 50))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 335, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 335, 59))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 335, 67))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 335, 15))
 
-        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->foldl : Symbol(ChainedDictionary.foldl, Decl(underscoreTest1_underscore.ts, 335, 93), Decl(underscoreTest1_underscore.ts, 336, 90))
+        foldl(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>foldl : Symbol(ChainedDictionary.foldl, Decl(underscoreTest1_underscore.ts, 335, 101), Decl(underscoreTest1_underscore.ts, 336, 98))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 336, 14))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 336, 38))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 336, 46))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 336, 56))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 336, 64))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 
-        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->foldl : Symbol(ChainedDictionary.foldl, Decl(underscoreTest1_underscore.ts, 335, 93), Decl(underscoreTest1_underscore.ts, 336, 90))
+        foldl<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>foldl : Symbol(ChainedDictionary.foldl, Decl(underscoreTest1_underscore.ts, 335, 101), Decl(underscoreTest1_underscore.ts, 336, 98))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 337, 14))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 337, 17))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 337, 14))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 337, 41))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 337, 49))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 337, 14))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 337, 58))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 337, 66))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 337, 14))
 
-        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->inject : Symbol(ChainedDictionary.inject, Decl(underscoreTest1_underscore.ts, 337, 92), Decl(underscoreTest1_underscore.ts, 338, 91))
+        inject(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>inject : Symbol(ChainedDictionary.inject, Decl(underscoreTest1_underscore.ts, 337, 100), Decl(underscoreTest1_underscore.ts, 338, 99))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 338, 15))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 338, 39))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 338, 47))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 338, 57))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 338, 65))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 
-        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->inject : Symbol(ChainedDictionary.inject, Decl(underscoreTest1_underscore.ts, 337, 92), Decl(underscoreTest1_underscore.ts, 338, 91))
+        inject<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>inject : Symbol(ChainedDictionary.inject, Decl(underscoreTest1_underscore.ts, 337, 100), Decl(underscoreTest1_underscore.ts, 338, 99))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 339, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 339, 18))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 339, 15))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 339, 42))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 339, 50))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 339, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 339, 59))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 339, 67))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 339, 15))
 
-        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->reduceRight : Symbol(ChainedDictionary.reduceRight, Decl(underscoreTest1_underscore.ts, 339, 93), Decl(underscoreTest1_underscore.ts, 340, 96))
+        reduceRight(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>reduceRight : Symbol(ChainedDictionary.reduceRight, Decl(underscoreTest1_underscore.ts, 339, 101), Decl(underscoreTest1_underscore.ts, 340, 104))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 340, 20))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 340, 44))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 340, 52))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 340, 62))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 340, 70))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 
-        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->reduceRight : Symbol(ChainedDictionary.reduceRight, Decl(underscoreTest1_underscore.ts, 339, 93), Decl(underscoreTest1_underscore.ts, 340, 96))
+        reduceRight<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>reduceRight : Symbol(ChainedDictionary.reduceRight, Decl(underscoreTest1_underscore.ts, 339, 101), Decl(underscoreTest1_underscore.ts, 340, 104))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 341, 20))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 341, 23))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 341, 20))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 341, 47))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 341, 55))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 341, 20))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 341, 64))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 341, 72))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 341, 20))
 
-        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->foldr : Symbol(ChainedDictionary.foldr, Decl(underscoreTest1_underscore.ts, 341, 98), Decl(underscoreTest1_underscore.ts, 342, 90))
+        foldr(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>foldr : Symbol(ChainedDictionary.foldr, Decl(underscoreTest1_underscore.ts, 341, 106), Decl(underscoreTest1_underscore.ts, 342, 98))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 342, 14))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 342, 38))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 342, 46))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 342, 56))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 342, 64))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 
-        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->foldr : Symbol(ChainedDictionary.foldr, Decl(underscoreTest1_underscore.ts, 341, 98), Decl(underscoreTest1_underscore.ts, 342, 90))
+        foldr<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>foldr : Symbol(ChainedDictionary.foldr, Decl(underscoreTest1_underscore.ts, 341, 106), Decl(underscoreTest1_underscore.ts, 342, 98))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 343, 14))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 343, 17))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 343, 14))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 343, 41))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 343, 49))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 343, 14))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 343, 58))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 343, 66))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 343, 14))
 
-        find(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
->find : Symbol(ChainedDictionary.find, Decl(underscoreTest1_underscore.ts, 343, 92))
+        find(iterator: IteratorCallback<T, boolean>, context?: any): ChainedObject<T>;
+>find : Symbol(ChainedDictionary.find, Decl(underscoreTest1_underscore.ts, 343, 100))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 344, 13))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 344, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 344, 52))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 
-        detect(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
->detect : Symbol(ChainedDictionary.detect, Decl(underscoreTest1_underscore.ts, 344, 78))
+        detect(iterator: IteratorCallback<T, boolean>, context?: any): ChainedObject<T>;
+>detect : Symbol(ChainedDictionary.detect, Decl(underscoreTest1_underscore.ts, 344, 86))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 345, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 345, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 345, 54))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 
-        filter(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
->filter : Symbol(ChainedDictionary.filter, Decl(underscoreTest1_underscore.ts, 345, 80))
+        filter(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
+>filter : Symbol(ChainedDictionary.filter, Decl(underscoreTest1_underscore.ts, 345, 88))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 346, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 346, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 346, 54))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 
-        select(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
->select : Symbol(ChainedDictionary.select, Decl(underscoreTest1_underscore.ts, 346, 79))
+        select(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
+>select : Symbol(ChainedDictionary.select, Decl(underscoreTest1_underscore.ts, 346, 87))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 347, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 347, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 347, 54))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 
         where(properties: Object): ChainedArray<T>;
->where : Symbol(ChainedDictionary.where, Decl(underscoreTest1_underscore.ts, 347, 79))
+>where : Symbol(ChainedDictionary.where, Decl(underscoreTest1_underscore.ts, 347, 87))
 >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 348, 14))
 >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
@@ -3118,49 +3118,49 @@ module Underscore {
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 
-        reject(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
+        reject(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
 >reject : Symbol(ChainedDictionary.reject, Decl(underscoreTest1_underscore.ts, 349, 56))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 350, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 350, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 350, 54))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 
-        every(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
->every : Symbol(ChainedDictionary.every, Decl(underscoreTest1_underscore.ts, 350, 79))
+        every(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+>every : Symbol(ChainedDictionary.every, Decl(underscoreTest1_underscore.ts, 350, 87))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 351, 14))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 351, 46))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 351, 54))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 
-        all(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
->all : Symbol(ChainedDictionary.all, Decl(underscoreTest1_underscore.ts, 351, 86))
+        all(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+>all : Symbol(ChainedDictionary.all, Decl(underscoreTest1_underscore.ts, 351, 94))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 352, 12))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 352, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 352, 52))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 
-        some(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
->some : Symbol(ChainedDictionary.some, Decl(underscoreTest1_underscore.ts, 352, 84))
+        some(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+>some : Symbol(ChainedDictionary.some, Decl(underscoreTest1_underscore.ts, 352, 92))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 353, 13))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 353, 45))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 353, 53))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 
-        any(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
->any : Symbol(ChainedDictionary.any, Decl(underscoreTest1_underscore.ts, 353, 85))
+        any(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+>any : Symbol(ChainedDictionary.any, Decl(underscoreTest1_underscore.ts, 353, 93))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 354, 12))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 354, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 354, 52))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 
         contains(value: T): ChainedObject<boolean>;
->contains : Symbol(ChainedDictionary.contains, Decl(underscoreTest1_underscore.ts, 354, 84))
+>contains : Symbol(ChainedDictionary.contains, Decl(underscoreTest1_underscore.ts, 354, 92))
 >value : Symbol(value, Decl(underscoreTest1_underscore.ts, 355, 17))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
@@ -3182,63 +3182,63 @@ module Underscore {
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 358, 14))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 
-        max(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
+        max(iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<T>;
 >max : Symbol(ChainedDictionary.max, Decl(underscoreTest1_underscore.ts, 358, 55))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 359, 12))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 359, 40))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 359, 48))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 
-        min(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
->min : Symbol(ChainedDictionary.min, Decl(underscoreTest1_underscore.ts, 359, 74))
+        min(iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<T>;
+>min : Symbol(ChainedDictionary.min, Decl(underscoreTest1_underscore.ts, 359, 82))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 360, 12))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 360, 40))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 360, 48))
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 
-        sortBy(iterator: Iterator<T, any>, context?: any): ChainedArray<T>;
->sortBy : Symbol(ChainedDictionary.sortBy, Decl(underscoreTest1_underscore.ts, 360, 74), Decl(underscoreTest1_underscore.ts, 361, 75))
+        sortBy(iterator: IteratorCallback<T, any>, context?: any): ChainedArray<T>;
+>sortBy : Symbol(ChainedDictionary.sortBy, Decl(underscoreTest1_underscore.ts, 360, 82), Decl(underscoreTest1_underscore.ts, 361, 83))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 361, 15))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 361, 42))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 361, 50))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 
         sortBy(propertyName: string): ChainedArray<T>;
->sortBy : Symbol(ChainedDictionary.sortBy, Decl(underscoreTest1_underscore.ts, 360, 74), Decl(underscoreTest1_underscore.ts, 361, 75))
+>sortBy : Symbol(ChainedDictionary.sortBy, Decl(underscoreTest1_underscore.ts, 360, 82), Decl(underscoreTest1_underscore.ts, 361, 83))
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 362, 15))
 >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
 
         // Should return ChainedDictionary<T[]>, but expansive recursion not allowed
-        groupBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<any[]>;
->groupBy : Symbol(ChainedDictionary.groupBy, Decl(underscoreTest1_underscore.ts, 362, 54), Decl(underscoreTest1_underscore.ts, 364, 86))
+        groupBy(iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<any[]>;
+>groupBy : Symbol(ChainedDictionary.groupBy, Decl(underscoreTest1_underscore.ts, 362, 54), Decl(underscoreTest1_underscore.ts, 364, 94))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 364, 16))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 364, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 364, 52))
 >ChainedDictionary : Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))
 
         groupBy(propertyName: string): ChainedDictionary<any[]>;
->groupBy : Symbol(ChainedDictionary.groupBy, Decl(underscoreTest1_underscore.ts, 362, 54), Decl(underscoreTest1_underscore.ts, 364, 86))
+>groupBy : Symbol(ChainedDictionary.groupBy, Decl(underscoreTest1_underscore.ts, 362, 54), Decl(underscoreTest1_underscore.ts, 364, 94))
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 365, 16))
 >ChainedDictionary : Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))
 
-        countBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<number>;
->countBy : Symbol(ChainedDictionary.countBy, Decl(underscoreTest1_underscore.ts, 365, 64), Decl(underscoreTest1_underscore.ts, 366, 87))
+        countBy(iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<number>;
+>countBy : Symbol(ChainedDictionary.countBy, Decl(underscoreTest1_underscore.ts, 365, 64), Decl(underscoreTest1_underscore.ts, 366, 95))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 366, 16))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 366, 44))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 366, 52))
 >ChainedDictionary : Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))
 
         countBy(propertyName: string): ChainedDictionary<number>;
->countBy : Symbol(ChainedDictionary.countBy, Decl(underscoreTest1_underscore.ts, 365, 64), Decl(underscoreTest1_underscore.ts, 366, 87))
+>countBy : Symbol(ChainedDictionary.countBy, Decl(underscoreTest1_underscore.ts, 365, 64), Decl(underscoreTest1_underscore.ts, 366, 95))
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 367, 16))
 >ChainedDictionary : Symbol(ChainedDictionary, Decl(underscoreTest1_underscore.ts, 327, 5))
 
@@ -3373,496 +3373,496 @@ module Underscore {
 >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 395, 14))
 
-        each<T>(list: T[], iterator: Iterator<T, void>, context?: any): void;
->each : Symbol(Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77))
+        each<T>(list: T[], iterator: IteratorCallback<T, void>, context?: any): void;
+>each : Symbol(Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 85))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 397, 13))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 397, 16))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 397, 13))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 397, 26))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 397, 13))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 397, 55))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 397, 63))
 
-        each<T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void;
->each : Symbol(Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77))
+        each<T>(list: Dictionary<T>, iterator: IteratorCallback<T, void>, context?: any): void;
+>each : Symbol(Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 85))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 398, 13))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 398, 16))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 398, 13))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 398, 36))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 398, 13))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 398, 65))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 398, 73))
 
-        forEach<T>(list: T[], iterator: Iterator<T, void>, context?: any): void;
->forEach : Symbol(Static.forEach, Decl(underscoreTest1_underscore.ts, 398, 87), Decl(underscoreTest1_underscore.ts, 399, 80))
+        forEach<T>(list: T[], iterator: IteratorCallback<T, void>, context?: any): void;
+>forEach : Symbol(Static.forEach, Decl(underscoreTest1_underscore.ts, 398, 95), Decl(underscoreTest1_underscore.ts, 399, 88))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 399, 16))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 399, 19))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 399, 16))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 399, 29))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 399, 16))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 399, 58))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 399, 66))
 
-        forEach<T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void;
->forEach : Symbol(Static.forEach, Decl(underscoreTest1_underscore.ts, 398, 87), Decl(underscoreTest1_underscore.ts, 399, 80))
+        forEach<T>(list: Dictionary<T>, iterator: IteratorCallback<T, void>, context?: any): void;
+>forEach : Symbol(Static.forEach, Decl(underscoreTest1_underscore.ts, 398, 95), Decl(underscoreTest1_underscore.ts, 399, 88))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 400, 16))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 400, 19))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 400, 16))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 400, 39))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 400, 16))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 400, 68))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 400, 76))
 
-        map<T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[];
->map : Symbol(Static.map, Decl(underscoreTest1_underscore.ts, 400, 90), Decl(underscoreTest1_underscore.ts, 402, 75))
+        map<T, U>(list: T[], iterator: IteratorCallback<T, U>, context?: any): U[];
+>map : Symbol(Static.map, Decl(underscoreTest1_underscore.ts, 400, 98), Decl(underscoreTest1_underscore.ts, 402, 83))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 402, 12))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 402, 14))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 402, 18))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 402, 12))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 402, 28))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 402, 12))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 402, 14))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 402, 54))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 402, 62))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 402, 14))
 
-        map<T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[];
->map : Symbol(Static.map, Decl(underscoreTest1_underscore.ts, 400, 90), Decl(underscoreTest1_underscore.ts, 402, 75))
+        map<T, U>(list: Dictionary<T>, iterator: IteratorCallback<T, U>, context?: any): U[];
+>map : Symbol(Static.map, Decl(underscoreTest1_underscore.ts, 400, 98), Decl(underscoreTest1_underscore.ts, 402, 83))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 403, 12))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 403, 14))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 403, 18))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 403, 12))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 403, 38))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 403, 12))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 403, 14))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 403, 64))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 403, 72))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 403, 14))
 
-        collect<T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[];
->collect : Symbol(Static.collect, Decl(underscoreTest1_underscore.ts, 403, 85), Decl(underscoreTest1_underscore.ts, 404, 79))
+        collect<T, U>(list: T[], iterator: IteratorCallback<T, U>, context?: any): U[];
+>collect : Symbol(Static.collect, Decl(underscoreTest1_underscore.ts, 403, 93), Decl(underscoreTest1_underscore.ts, 404, 87))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 404, 16))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 404, 18))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 404, 22))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 404, 16))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 404, 32))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 404, 16))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 404, 18))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 404, 58))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 404, 66))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 404, 18))
 
-        collect<T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[];
->collect : Symbol(Static.collect, Decl(underscoreTest1_underscore.ts, 403, 85), Decl(underscoreTest1_underscore.ts, 404, 79))
+        collect<T, U>(list: Dictionary<T>, iterator: IteratorCallback<T, U>, context?: any): U[];
+>collect : Symbol(Static.collect, Decl(underscoreTest1_underscore.ts, 403, 93), Decl(underscoreTest1_underscore.ts, 404, 87))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 405, 16))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 405, 18))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 405, 22))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 405, 16))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 405, 42))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 405, 16))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 405, 18))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 405, 68))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 405, 76))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 405, 18))
 
-        reduce<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->reduce : Symbol(Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 89), Decl(underscoreTest1_underscore.ts, 407, 90), Decl(underscoreTest1_underscore.ts, 408, 92), Decl(underscoreTest1_underscore.ts, 409, 100))
+        reduce<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>reduce : Symbol(Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 97), Decl(underscoreTest1_underscore.ts, 407, 98), Decl(underscoreTest1_underscore.ts, 408, 100), Decl(underscoreTest1_underscore.ts, 409, 108))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 407, 15))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 407, 18))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 407, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 407, 28))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 407, 15))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 407, 15))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 407, 53))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 407, 61))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 407, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 407, 71))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 407, 79))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 407, 15))
 
-        reduce<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->reduce : Symbol(Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 89), Decl(underscoreTest1_underscore.ts, 407, 90), Decl(underscoreTest1_underscore.ts, 408, 92), Decl(underscoreTest1_underscore.ts, 409, 100))
+        reduce<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>reduce : Symbol(Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 97), Decl(underscoreTest1_underscore.ts, 407, 98), Decl(underscoreTest1_underscore.ts, 408, 100), Decl(underscoreTest1_underscore.ts, 409, 108))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 408, 15))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 408, 17))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 408, 21))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 408, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 408, 31))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 408, 15))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 408, 17))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 408, 56))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 408, 64))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 408, 17))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 408, 73))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 408, 81))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 408, 17))
 
-        reduce<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->reduce : Symbol(Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 89), Decl(underscoreTest1_underscore.ts, 407, 90), Decl(underscoreTest1_underscore.ts, 408, 92), Decl(underscoreTest1_underscore.ts, 409, 100))
+        reduce<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>reduce : Symbol(Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 97), Decl(underscoreTest1_underscore.ts, 407, 98), Decl(underscoreTest1_underscore.ts, 408, 100), Decl(underscoreTest1_underscore.ts, 409, 108))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 409, 15))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 409, 18))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 409, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 409, 38))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 409, 15))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 409, 15))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 409, 63))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 409, 71))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 409, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 409, 81))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 409, 89))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 409, 15))
 
-        reduce<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->reduce : Symbol(Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 89), Decl(underscoreTest1_underscore.ts, 407, 90), Decl(underscoreTest1_underscore.ts, 408, 92), Decl(underscoreTest1_underscore.ts, 409, 100))
+        reduce<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>reduce : Symbol(Static.reduce, Decl(underscoreTest1_underscore.ts, 405, 97), Decl(underscoreTest1_underscore.ts, 407, 98), Decl(underscoreTest1_underscore.ts, 408, 100), Decl(underscoreTest1_underscore.ts, 409, 108))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 410, 15))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 410, 17))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 410, 21))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 410, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 410, 41))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 410, 15))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 410, 17))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 410, 66))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 410, 74))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 410, 17))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 410, 83))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 410, 91))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 410, 17))
 
-        foldl<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->foldl : Symbol(Static.foldl, Decl(underscoreTest1_underscore.ts, 410, 102), Decl(underscoreTest1_underscore.ts, 411, 89), Decl(underscoreTest1_underscore.ts, 412, 91), Decl(underscoreTest1_underscore.ts, 413, 99))
+        foldl<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>foldl : Symbol(Static.foldl, Decl(underscoreTest1_underscore.ts, 410, 110), Decl(underscoreTest1_underscore.ts, 411, 97), Decl(underscoreTest1_underscore.ts, 412, 99), Decl(underscoreTest1_underscore.ts, 413, 107))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 411, 14))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 411, 17))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 411, 14))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 411, 27))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 411, 14))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 411, 14))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 411, 52))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 411, 60))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 411, 14))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 411, 70))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 411, 78))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 411, 14))
 
-        foldl<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->foldl : Symbol(Static.foldl, Decl(underscoreTest1_underscore.ts, 410, 102), Decl(underscoreTest1_underscore.ts, 411, 89), Decl(underscoreTest1_underscore.ts, 412, 91), Decl(underscoreTest1_underscore.ts, 413, 99))
+        foldl<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>foldl : Symbol(Static.foldl, Decl(underscoreTest1_underscore.ts, 410, 110), Decl(underscoreTest1_underscore.ts, 411, 97), Decl(underscoreTest1_underscore.ts, 412, 99), Decl(underscoreTest1_underscore.ts, 413, 107))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 412, 14))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 412, 16))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 412, 20))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 412, 14))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 412, 30))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 412, 14))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 412, 16))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 412, 55))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 412, 63))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 412, 16))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 412, 72))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 412, 80))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 412, 16))
 
-        foldl<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->foldl : Symbol(Static.foldl, Decl(underscoreTest1_underscore.ts, 410, 102), Decl(underscoreTest1_underscore.ts, 411, 89), Decl(underscoreTest1_underscore.ts, 412, 91), Decl(underscoreTest1_underscore.ts, 413, 99))
+        foldl<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>foldl : Symbol(Static.foldl, Decl(underscoreTest1_underscore.ts, 410, 110), Decl(underscoreTest1_underscore.ts, 411, 97), Decl(underscoreTest1_underscore.ts, 412, 99), Decl(underscoreTest1_underscore.ts, 413, 107))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 413, 14))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 413, 17))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 413, 14))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 413, 37))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 413, 14))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 413, 14))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 413, 62))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 413, 70))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 413, 14))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 413, 80))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 413, 88))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 413, 14))
 
-        foldl<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->foldl : Symbol(Static.foldl, Decl(underscoreTest1_underscore.ts, 410, 102), Decl(underscoreTest1_underscore.ts, 411, 89), Decl(underscoreTest1_underscore.ts, 412, 91), Decl(underscoreTest1_underscore.ts, 413, 99))
+        foldl<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>foldl : Symbol(Static.foldl, Decl(underscoreTest1_underscore.ts, 410, 110), Decl(underscoreTest1_underscore.ts, 411, 97), Decl(underscoreTest1_underscore.ts, 412, 99), Decl(underscoreTest1_underscore.ts, 413, 107))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 414, 14))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 414, 16))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 414, 20))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 414, 14))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 414, 40))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 414, 14))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 414, 16))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 414, 65))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 414, 73))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 414, 16))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 414, 82))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 414, 90))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 414, 16))
 
-        inject<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->inject : Symbol(Static.inject, Decl(underscoreTest1_underscore.ts, 414, 101), Decl(underscoreTest1_underscore.ts, 415, 90), Decl(underscoreTest1_underscore.ts, 416, 92), Decl(underscoreTest1_underscore.ts, 417, 100))
+        inject<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>inject : Symbol(Static.inject, Decl(underscoreTest1_underscore.ts, 414, 109), Decl(underscoreTest1_underscore.ts, 415, 98), Decl(underscoreTest1_underscore.ts, 416, 100), Decl(underscoreTest1_underscore.ts, 417, 108))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 415, 15))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 415, 18))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 415, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 415, 28))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 415, 15))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 415, 15))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 415, 53))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 415, 61))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 415, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 415, 71))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 415, 79))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 415, 15))
 
-        inject<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->inject : Symbol(Static.inject, Decl(underscoreTest1_underscore.ts, 414, 101), Decl(underscoreTest1_underscore.ts, 415, 90), Decl(underscoreTest1_underscore.ts, 416, 92), Decl(underscoreTest1_underscore.ts, 417, 100))
+        inject<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>inject : Symbol(Static.inject, Decl(underscoreTest1_underscore.ts, 414, 109), Decl(underscoreTest1_underscore.ts, 415, 98), Decl(underscoreTest1_underscore.ts, 416, 100), Decl(underscoreTest1_underscore.ts, 417, 108))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 416, 15))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 416, 17))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 416, 21))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 416, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 416, 31))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 416, 15))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 416, 17))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 416, 56))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 416, 64))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 416, 17))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 416, 73))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 416, 81))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 416, 17))
 
-        inject<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->inject : Symbol(Static.inject, Decl(underscoreTest1_underscore.ts, 414, 101), Decl(underscoreTest1_underscore.ts, 415, 90), Decl(underscoreTest1_underscore.ts, 416, 92), Decl(underscoreTest1_underscore.ts, 417, 100))
+        inject<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>inject : Symbol(Static.inject, Decl(underscoreTest1_underscore.ts, 414, 109), Decl(underscoreTest1_underscore.ts, 415, 98), Decl(underscoreTest1_underscore.ts, 416, 100), Decl(underscoreTest1_underscore.ts, 417, 108))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 417, 15))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 417, 18))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 417, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 417, 38))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 417, 15))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 417, 15))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 417, 63))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 417, 71))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 417, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 417, 81))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 417, 89))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 417, 15))
 
-        inject<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->inject : Symbol(Static.inject, Decl(underscoreTest1_underscore.ts, 414, 101), Decl(underscoreTest1_underscore.ts, 415, 90), Decl(underscoreTest1_underscore.ts, 416, 92), Decl(underscoreTest1_underscore.ts, 417, 100))
+        inject<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>inject : Symbol(Static.inject, Decl(underscoreTest1_underscore.ts, 414, 109), Decl(underscoreTest1_underscore.ts, 415, 98), Decl(underscoreTest1_underscore.ts, 416, 100), Decl(underscoreTest1_underscore.ts, 417, 108))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 418, 15))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 418, 17))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 418, 21))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 418, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 418, 41))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 418, 15))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 418, 17))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 418, 66))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 418, 74))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 418, 17))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 418, 83))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 418, 91))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 418, 17))
 
-        reduceRight<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->reduceRight : Symbol(Static.reduceRight, Decl(underscoreTest1_underscore.ts, 418, 102), Decl(underscoreTest1_underscore.ts, 420, 95), Decl(underscoreTest1_underscore.ts, 421, 97), Decl(underscoreTest1_underscore.ts, 422, 105))
+        reduceRight<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>reduceRight : Symbol(Static.reduceRight, Decl(underscoreTest1_underscore.ts, 418, 110), Decl(underscoreTest1_underscore.ts, 420, 103), Decl(underscoreTest1_underscore.ts, 421, 105), Decl(underscoreTest1_underscore.ts, 422, 113))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 420, 20))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 420, 23))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 420, 20))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 420, 33))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 420, 20))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 420, 20))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 420, 58))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 420, 66))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 420, 20))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 420, 76))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 420, 84))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 420, 20))
 
-        reduceRight<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->reduceRight : Symbol(Static.reduceRight, Decl(underscoreTest1_underscore.ts, 418, 102), Decl(underscoreTest1_underscore.ts, 420, 95), Decl(underscoreTest1_underscore.ts, 421, 97), Decl(underscoreTest1_underscore.ts, 422, 105))
+        reduceRight<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>reduceRight : Symbol(Static.reduceRight, Decl(underscoreTest1_underscore.ts, 418, 110), Decl(underscoreTest1_underscore.ts, 420, 103), Decl(underscoreTest1_underscore.ts, 421, 105), Decl(underscoreTest1_underscore.ts, 422, 113))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 421, 20))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 421, 22))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 421, 26))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 421, 20))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 421, 36))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 421, 20))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 421, 22))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 421, 61))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 421, 69))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 421, 22))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 421, 78))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 421, 86))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 421, 22))
 
-        reduceRight<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->reduceRight : Symbol(Static.reduceRight, Decl(underscoreTest1_underscore.ts, 418, 102), Decl(underscoreTest1_underscore.ts, 420, 95), Decl(underscoreTest1_underscore.ts, 421, 97), Decl(underscoreTest1_underscore.ts, 422, 105))
+        reduceRight<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>reduceRight : Symbol(Static.reduceRight, Decl(underscoreTest1_underscore.ts, 418, 110), Decl(underscoreTest1_underscore.ts, 420, 103), Decl(underscoreTest1_underscore.ts, 421, 105), Decl(underscoreTest1_underscore.ts, 422, 113))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 422, 20))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 422, 23))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 422, 20))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 422, 43))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 422, 20))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 422, 20))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 422, 68))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 422, 76))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 422, 20))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 422, 86))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 422, 94))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 422, 20))
 
-        reduceRight<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->reduceRight : Symbol(Static.reduceRight, Decl(underscoreTest1_underscore.ts, 418, 102), Decl(underscoreTest1_underscore.ts, 420, 95), Decl(underscoreTest1_underscore.ts, 421, 97), Decl(underscoreTest1_underscore.ts, 422, 105))
+        reduceRight<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>reduceRight : Symbol(Static.reduceRight, Decl(underscoreTest1_underscore.ts, 418, 110), Decl(underscoreTest1_underscore.ts, 420, 103), Decl(underscoreTest1_underscore.ts, 421, 105), Decl(underscoreTest1_underscore.ts, 422, 113))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 423, 20))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 423, 22))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 423, 26))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 423, 20))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 423, 46))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 423, 20))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 423, 22))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 423, 71))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 423, 79))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 423, 22))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 423, 88))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 423, 96))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 423, 22))
 
-        foldr<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->foldr : Symbol(Static.foldr, Decl(underscoreTest1_underscore.ts, 423, 107), Decl(underscoreTest1_underscore.ts, 424, 89), Decl(underscoreTest1_underscore.ts, 425, 91), Decl(underscoreTest1_underscore.ts, 426, 99))
+        foldr<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>foldr : Symbol(Static.foldr, Decl(underscoreTest1_underscore.ts, 423, 115), Decl(underscoreTest1_underscore.ts, 424, 97), Decl(underscoreTest1_underscore.ts, 425, 99), Decl(underscoreTest1_underscore.ts, 426, 107))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 424, 14))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 424, 17))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 424, 14))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 424, 27))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 424, 14))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 424, 14))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 424, 52))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 424, 60))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 424, 14))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 424, 70))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 424, 78))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 424, 14))
 
-        foldr<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->foldr : Symbol(Static.foldr, Decl(underscoreTest1_underscore.ts, 423, 107), Decl(underscoreTest1_underscore.ts, 424, 89), Decl(underscoreTest1_underscore.ts, 425, 91), Decl(underscoreTest1_underscore.ts, 426, 99))
+        foldr<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>foldr : Symbol(Static.foldr, Decl(underscoreTest1_underscore.ts, 423, 115), Decl(underscoreTest1_underscore.ts, 424, 97), Decl(underscoreTest1_underscore.ts, 425, 99), Decl(underscoreTest1_underscore.ts, 426, 107))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 425, 14))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 425, 16))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 425, 20))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 425, 14))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 425, 30))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 425, 14))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 425, 16))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 425, 55))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 425, 63))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 425, 16))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 425, 72))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 425, 80))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 425, 16))
 
-        foldr<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->foldr : Symbol(Static.foldr, Decl(underscoreTest1_underscore.ts, 423, 107), Decl(underscoreTest1_underscore.ts, 424, 89), Decl(underscoreTest1_underscore.ts, 425, 91), Decl(underscoreTest1_underscore.ts, 426, 99))
+        foldr<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>foldr : Symbol(Static.foldr, Decl(underscoreTest1_underscore.ts, 423, 115), Decl(underscoreTest1_underscore.ts, 424, 97), Decl(underscoreTest1_underscore.ts, 425, 99), Decl(underscoreTest1_underscore.ts, 426, 107))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 426, 14))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 426, 17))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 426, 14))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 426, 37))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 426, 14))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 426, 14))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 426, 62))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 426, 70))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 426, 14))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 426, 80))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 426, 88))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 426, 14))
 
-        foldr<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->foldr : Symbol(Static.foldr, Decl(underscoreTest1_underscore.ts, 423, 107), Decl(underscoreTest1_underscore.ts, 424, 89), Decl(underscoreTest1_underscore.ts, 425, 91), Decl(underscoreTest1_underscore.ts, 426, 99))
+        foldr<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>foldr : Symbol(Static.foldr, Decl(underscoreTest1_underscore.ts, 423, 115), Decl(underscoreTest1_underscore.ts, 424, 97), Decl(underscoreTest1_underscore.ts, 425, 99), Decl(underscoreTest1_underscore.ts, 426, 107))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 427, 14))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 427, 16))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 427, 20))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 427, 14))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 427, 40))
->Reducer : Symbol(Reducer, Decl(underscoreTest1_underscore.ts, 6, 1))
+>ReducerCallback : Symbol(ReducerCallback, Decl(underscoreTest1_underscore.ts, 6, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 427, 14))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 427, 16))
->initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 427, 65))
+>initialValue : Symbol(initialValue, Decl(underscoreTest1_underscore.ts, 427, 73))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 427, 16))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 427, 82))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 427, 90))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 427, 16))
 
-        find<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T;
->find : Symbol(Static.find, Decl(underscoreTest1_underscore.ts, 427, 101), Decl(underscoreTest1_underscore.ts, 429, 77))
+        find<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T;
+>find : Symbol(Static.find, Decl(underscoreTest1_underscore.ts, 427, 109), Decl(underscoreTest1_underscore.ts, 429, 85))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 429, 13))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 429, 16))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 429, 13))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 429, 26))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 429, 13))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 429, 58))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 429, 66))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 429, 13))
 
-        find<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T;
->find : Symbol(Static.find, Decl(underscoreTest1_underscore.ts, 427, 101), Decl(underscoreTest1_underscore.ts, 429, 77))
+        find<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T;
+>find : Symbol(Static.find, Decl(underscoreTest1_underscore.ts, 427, 109), Decl(underscoreTest1_underscore.ts, 429, 85))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 430, 13))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 430, 16))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 430, 13))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 430, 36))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 430, 13))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 430, 68))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 430, 76))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 430, 13))
 
-        detect<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T;
->detect : Symbol(Static.detect, Decl(underscoreTest1_underscore.ts, 430, 87), Decl(underscoreTest1_underscore.ts, 431, 79))
+        detect<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T;
+>detect : Symbol(Static.detect, Decl(underscoreTest1_underscore.ts, 430, 95), Decl(underscoreTest1_underscore.ts, 431, 87))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 431, 15))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 431, 18))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 431, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 431, 28))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 431, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 431, 60))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 431, 68))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 431, 15))
 
-        detect<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T;
->detect : Symbol(Static.detect, Decl(underscoreTest1_underscore.ts, 430, 87), Decl(underscoreTest1_underscore.ts, 431, 79))
+        detect<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T;
+>detect : Symbol(Static.detect, Decl(underscoreTest1_underscore.ts, 430, 95), Decl(underscoreTest1_underscore.ts, 431, 87))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 432, 15))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 432, 18))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 432, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 432, 38))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 432, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 432, 70))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 432, 78))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 432, 15))
 
-        filter<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[];
->filter : Symbol(Static.filter, Decl(underscoreTest1_underscore.ts, 432, 89), Decl(underscoreTest1_underscore.ts, 434, 81))
+        filter<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>filter : Symbol(Static.filter, Decl(underscoreTest1_underscore.ts, 432, 97), Decl(underscoreTest1_underscore.ts, 434, 89))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 434, 15))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 434, 18))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 434, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 434, 28))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 434, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 434, 60))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 434, 68))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 434, 15))
 
-        filter<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[];
->filter : Symbol(Static.filter, Decl(underscoreTest1_underscore.ts, 432, 89), Decl(underscoreTest1_underscore.ts, 434, 81))
+        filter<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>filter : Symbol(Static.filter, Decl(underscoreTest1_underscore.ts, 432, 97), Decl(underscoreTest1_underscore.ts, 434, 89))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 435, 15))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 435, 18))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 435, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 435, 38))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 435, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 435, 70))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 435, 78))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 435, 15))
 
-        select<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[];
->select : Symbol(Static.select, Decl(underscoreTest1_underscore.ts, 435, 91), Decl(underscoreTest1_underscore.ts, 436, 81))
+        select<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>select : Symbol(Static.select, Decl(underscoreTest1_underscore.ts, 435, 99), Decl(underscoreTest1_underscore.ts, 436, 89))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 436, 15))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 436, 18))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 436, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 436, 28))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 436, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 436, 60))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 436, 68))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 436, 15))
 
-        select<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[];
->select : Symbol(Static.select, Decl(underscoreTest1_underscore.ts, 435, 91), Decl(underscoreTest1_underscore.ts, 436, 81))
+        select<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>select : Symbol(Static.select, Decl(underscoreTest1_underscore.ts, 435, 99), Decl(underscoreTest1_underscore.ts, 436, 89))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 437, 15))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 437, 18))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 437, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 437, 38))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 437, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 437, 70))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 437, 78))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 437, 15))
 
         where<T>(list: T[], properties: Object): T[];
->where : Symbol(Static.where, Decl(underscoreTest1_underscore.ts, 437, 91), Decl(underscoreTest1_underscore.ts, 439, 53))
+>where : Symbol(Static.where, Decl(underscoreTest1_underscore.ts, 437, 99), Decl(underscoreTest1_underscore.ts, 439, 53))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 439, 14))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 439, 17))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 439, 14))
@@ -3871,7 +3871,7 @@ module Underscore {
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 439, 14))
 
         where<T>(list: Dictionary<T>, properties: Object): T[];
->where : Symbol(Static.where, Decl(underscoreTest1_underscore.ts, 437, 91), Decl(underscoreTest1_underscore.ts, 439, 53))
+>where : Symbol(Static.where, Decl(underscoreTest1_underscore.ts, 437, 99), Decl(underscoreTest1_underscore.ts, 439, 53))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 440, 14))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 440, 17))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
@@ -3899,115 +3899,115 @@ module Underscore {
 >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 443, 18))
 
-        reject<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[];
->reject : Symbol(Static.reject, Decl(underscoreTest1_underscore.ts, 443, 65), Decl(underscoreTest1_underscore.ts, 445, 81))
+        reject<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>reject : Symbol(Static.reject, Decl(underscoreTest1_underscore.ts, 443, 65), Decl(underscoreTest1_underscore.ts, 445, 89))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 445, 15))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 445, 18))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 445, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 445, 28))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 445, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 445, 60))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 445, 68))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 445, 15))
 
-        reject<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[];
->reject : Symbol(Static.reject, Decl(underscoreTest1_underscore.ts, 443, 65), Decl(underscoreTest1_underscore.ts, 445, 81))
+        reject<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>reject : Symbol(Static.reject, Decl(underscoreTest1_underscore.ts, 443, 65), Decl(underscoreTest1_underscore.ts, 445, 89))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 446, 15))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 446, 18))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 446, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 446, 38))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 446, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 446, 70))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 446, 78))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 446, 15))
 
-        every<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
->every : Symbol(Static.every, Decl(underscoreTest1_underscore.ts, 446, 91), Decl(underscoreTest1_underscore.ts, 448, 85))
+        every<T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>every : Symbol(Static.every, Decl(underscoreTest1_underscore.ts, 446, 99), Decl(underscoreTest1_underscore.ts, 448, 93))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 448, 14))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 448, 17))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 448, 14))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 448, 27))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 448, 14))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 448, 60))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 448, 68))
 
-        every<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
->every : Symbol(Static.every, Decl(underscoreTest1_underscore.ts, 446, 91), Decl(underscoreTest1_underscore.ts, 448, 85))
+        every<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>every : Symbol(Static.every, Decl(underscoreTest1_underscore.ts, 446, 99), Decl(underscoreTest1_underscore.ts, 448, 93))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 449, 14))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 449, 17))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 449, 14))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 449, 37))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 449, 14))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 449, 70))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 449, 78))
 
-        all<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
->all : Symbol(Static.all, Decl(underscoreTest1_underscore.ts, 449, 95), Decl(underscoreTest1_underscore.ts, 450, 83))
+        all<T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>all : Symbol(Static.all, Decl(underscoreTest1_underscore.ts, 449, 103), Decl(underscoreTest1_underscore.ts, 450, 91))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 450, 12))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 450, 15))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 450, 12))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 450, 25))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 450, 12))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 450, 58))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 450, 66))
 
-        all<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
->all : Symbol(Static.all, Decl(underscoreTest1_underscore.ts, 449, 95), Decl(underscoreTest1_underscore.ts, 450, 83))
+        all<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>all : Symbol(Static.all, Decl(underscoreTest1_underscore.ts, 449, 103), Decl(underscoreTest1_underscore.ts, 450, 91))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 451, 12))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 451, 15))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 451, 12))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 451, 35))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 451, 12))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 451, 68))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 451, 76))
 
-        some<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
->some : Symbol(Static.some, Decl(underscoreTest1_underscore.ts, 451, 93), Decl(underscoreTest1_underscore.ts, 453, 84))
+        some<T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>some : Symbol(Static.some, Decl(underscoreTest1_underscore.ts, 451, 101), Decl(underscoreTest1_underscore.ts, 453, 92))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 453, 13))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 453, 16))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 453, 13))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 453, 26))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 453, 13))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 453, 59))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 453, 67))
 
-        some<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
->some : Symbol(Static.some, Decl(underscoreTest1_underscore.ts, 451, 93), Decl(underscoreTest1_underscore.ts, 453, 84))
+        some<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>some : Symbol(Static.some, Decl(underscoreTest1_underscore.ts, 451, 101), Decl(underscoreTest1_underscore.ts, 453, 92))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 454, 13))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 454, 16))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 454, 13))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 454, 36))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 454, 13))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 454, 69))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 454, 77))
 
-        any<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
->any : Symbol(Static.any, Decl(underscoreTest1_underscore.ts, 454, 94), Decl(underscoreTest1_underscore.ts, 455, 83))
+        any<T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>any : Symbol(Static.any, Decl(underscoreTest1_underscore.ts, 454, 102), Decl(underscoreTest1_underscore.ts, 455, 91))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 455, 12))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 455, 15))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 455, 12))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 455, 25))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 455, 12))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 455, 58))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 455, 66))
 
-        any<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
->any : Symbol(Static.any, Decl(underscoreTest1_underscore.ts, 454, 94), Decl(underscoreTest1_underscore.ts, 455, 83))
+        any<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>any : Symbol(Static.any, Decl(underscoreTest1_underscore.ts, 454, 102), Decl(underscoreTest1_underscore.ts, 455, 91))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 456, 12))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 456, 15))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 456, 12))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 456, 35))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 456, 12))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 456, 68))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 456, 76))
 
         contains<T>(list: T[], value: T): boolean;
->contains : Symbol(Static.contains, Decl(underscoreTest1_underscore.ts, 456, 93), Decl(underscoreTest1_underscore.ts, 458, 50))
+>contains : Symbol(Static.contains, Decl(underscoreTest1_underscore.ts, 456, 101), Decl(underscoreTest1_underscore.ts, 458, 50))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 458, 17))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 458, 20))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 458, 17))
@@ -4015,7 +4015,7 @@ module Underscore {
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 458, 17))
 
         contains<T>(list: Dictionary<T>, value: T): boolean;
->contains : Symbol(Static.contains, Decl(underscoreTest1_underscore.ts, 456, 93), Decl(underscoreTest1_underscore.ts, 458, 50))
+>contains : Symbol(Static.contains, Decl(underscoreTest1_underscore.ts, 456, 101), Decl(underscoreTest1_underscore.ts, 458, 50))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 459, 17))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 459, 20))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
@@ -4064,77 +4064,77 @@ module Underscore {
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 467, 36))
 
-        max<T>(list: T[], iterator?: Iterator<T, any>, context?: any): T;
->max : Symbol(Static.max, Decl(underscoreTest1_underscore.ts, 467, 66), Decl(underscoreTest1_underscore.ts, 469, 73))
+        max<T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): T;
+>max : Symbol(Static.max, Decl(underscoreTest1_underscore.ts, 467, 66), Decl(underscoreTest1_underscore.ts, 469, 81))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 469, 12))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 469, 15))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 469, 12))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 469, 25))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 469, 12))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 469, 54))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 469, 62))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 469, 12))
 
-        max<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T;
->max : Symbol(Static.max, Decl(underscoreTest1_underscore.ts, 467, 66), Decl(underscoreTest1_underscore.ts, 469, 73))
+        max<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): T;
+>max : Symbol(Static.max, Decl(underscoreTest1_underscore.ts, 467, 66), Decl(underscoreTest1_underscore.ts, 469, 81))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 470, 12))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 470, 15))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 470, 12))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 470, 35))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 470, 12))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 470, 64))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 470, 72))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 470, 12))
 
-        min<T>(list: T[], iterator?: Iterator<T, any>, context?: any): T;
->min : Symbol(Static.min, Decl(underscoreTest1_underscore.ts, 470, 83), Decl(underscoreTest1_underscore.ts, 472, 73))
+        min<T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): T;
+>min : Symbol(Static.min, Decl(underscoreTest1_underscore.ts, 470, 91), Decl(underscoreTest1_underscore.ts, 472, 81))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 472, 12))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 472, 15))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 472, 12))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 472, 25))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 472, 12))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 472, 54))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 472, 62))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 472, 12))
 
-        min<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T;
->min : Symbol(Static.min, Decl(underscoreTest1_underscore.ts, 470, 83), Decl(underscoreTest1_underscore.ts, 472, 73))
+        min<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): T;
+>min : Symbol(Static.min, Decl(underscoreTest1_underscore.ts, 470, 91), Decl(underscoreTest1_underscore.ts, 472, 81))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 473, 12))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 473, 15))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 473, 12))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 473, 35))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 473, 12))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 473, 64))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 473, 72))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 473, 12))
 
-        sortBy<T>(list: T[], iterator: Iterator<T, any>, context?: any): T[];
->sortBy : Symbol(Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 83), Decl(underscoreTest1_underscore.ts, 475, 77), Decl(underscoreTest1_underscore.ts, 476, 87), Decl(underscoreTest1_underscore.ts, 477, 56))
+        sortBy<T>(list: T[], iterator: IteratorCallback<T, any>, context?: any): T[];
+>sortBy : Symbol(Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 91), Decl(underscoreTest1_underscore.ts, 475, 85), Decl(underscoreTest1_underscore.ts, 476, 95), Decl(underscoreTest1_underscore.ts, 477, 56))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 475, 15))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 475, 18))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 475, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 475, 28))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 475, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 475, 56))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 475, 64))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 475, 15))
 
-        sortBy<T>(list: Dictionary<T>, iterator: Iterator<T, any>, context?: any): T[];
->sortBy : Symbol(Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 83), Decl(underscoreTest1_underscore.ts, 475, 77), Decl(underscoreTest1_underscore.ts, 476, 87), Decl(underscoreTest1_underscore.ts, 477, 56))
+        sortBy<T>(list: Dictionary<T>, iterator: IteratorCallback<T, any>, context?: any): T[];
+>sortBy : Symbol(Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 91), Decl(underscoreTest1_underscore.ts, 475, 85), Decl(underscoreTest1_underscore.ts, 476, 95), Decl(underscoreTest1_underscore.ts, 477, 56))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 476, 15))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 476, 18))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 476, 15))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 476, 38))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 476, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 476, 66))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 476, 74))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 476, 15))
 
         sortBy<T>(list: T[], propertyName: string): T[];
->sortBy : Symbol(Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 83), Decl(underscoreTest1_underscore.ts, 475, 77), Decl(underscoreTest1_underscore.ts, 476, 87), Decl(underscoreTest1_underscore.ts, 477, 56))
+>sortBy : Symbol(Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 91), Decl(underscoreTest1_underscore.ts, 475, 85), Decl(underscoreTest1_underscore.ts, 476, 95), Decl(underscoreTest1_underscore.ts, 477, 56))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 477, 15))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 477, 18))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 477, 15))
@@ -4142,7 +4142,7 @@ module Underscore {
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 477, 15))
 
         sortBy<T>(list: Dictionary<T>, propertyName: string): T[];
->sortBy : Symbol(Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 83), Decl(underscoreTest1_underscore.ts, 475, 77), Decl(underscoreTest1_underscore.ts, 476, 87), Decl(underscoreTest1_underscore.ts, 477, 56))
+>sortBy : Symbol(Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 91), Decl(underscoreTest1_underscore.ts, 475, 85), Decl(underscoreTest1_underscore.ts, 476, 95), Decl(underscoreTest1_underscore.ts, 477, 56))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 478, 15))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 478, 18))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
@@ -4150,33 +4150,33 @@ module Underscore {
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 478, 38))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 478, 15))
 
-        groupBy<T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
->groupBy : Symbol(Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 91), Decl(underscoreTest1_underscore.ts, 481, 101), Decl(underscoreTest1_underscore.ts, 482, 69))
+        groupBy<T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>;
+>groupBy : Symbol(Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 99), Decl(underscoreTest1_underscore.ts, 481, 109), Decl(underscoreTest1_underscore.ts, 482, 69))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 480, 16))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 480, 19))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 480, 16))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 480, 29))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 480, 16))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 480, 58))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 480, 66))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 480, 16))
 
-        groupBy<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
->groupBy : Symbol(Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 91), Decl(underscoreTest1_underscore.ts, 481, 101), Decl(underscoreTest1_underscore.ts, 482, 69))
+        groupBy<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>;
+>groupBy : Symbol(Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 99), Decl(underscoreTest1_underscore.ts, 481, 109), Decl(underscoreTest1_underscore.ts, 482, 69))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 481, 16))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 481, 19))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 481, 16))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 481, 39))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 481, 16))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 481, 68))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 481, 76))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 481, 16))
 
         groupBy<T>(list: T[], propertyName: string): Dictionary<T[]>;
->groupBy : Symbol(Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 91), Decl(underscoreTest1_underscore.ts, 481, 101), Decl(underscoreTest1_underscore.ts, 482, 69))
+>groupBy : Symbol(Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 99), Decl(underscoreTest1_underscore.ts, 481, 109), Decl(underscoreTest1_underscore.ts, 482, 69))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 482, 16))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 482, 19))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 482, 16))
@@ -4185,7 +4185,7 @@ module Underscore {
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 482, 16))
 
         groupBy<T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>;
->groupBy : Symbol(Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 91), Decl(underscoreTest1_underscore.ts, 481, 101), Decl(underscoreTest1_underscore.ts, 482, 69))
+>groupBy : Symbol(Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 99), Decl(underscoreTest1_underscore.ts, 481, 109), Decl(underscoreTest1_underscore.ts, 482, 69))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 483, 16))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 483, 19))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
@@ -4194,31 +4194,31 @@ module Underscore {
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 483, 16))
 
-        countBy<T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
->countBy : Symbol(Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 94), Decl(underscoreTest1_underscore.ts, 486, 104), Decl(underscoreTest1_underscore.ts, 487, 72))
+        countBy<T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>;
+>countBy : Symbol(Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 102), Decl(underscoreTest1_underscore.ts, 486, 112), Decl(underscoreTest1_underscore.ts, 487, 72))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 485, 16))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 485, 19))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 485, 16))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 485, 29))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 485, 16))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 485, 58))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 485, 66))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 
-        countBy<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
->countBy : Symbol(Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 94), Decl(underscoreTest1_underscore.ts, 486, 104), Decl(underscoreTest1_underscore.ts, 487, 72))
+        countBy<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>;
+>countBy : Symbol(Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 102), Decl(underscoreTest1_underscore.ts, 486, 112), Decl(underscoreTest1_underscore.ts, 487, 72))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 486, 16))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 486, 19))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 486, 16))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 486, 39))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 486, 16))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 486, 68))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 486, 76))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 
         countBy<T>(list: T[], propertyName: string): Dictionary<number>;
->countBy : Symbol(Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 94), Decl(underscoreTest1_underscore.ts, 486, 104), Decl(underscoreTest1_underscore.ts, 487, 72))
+>countBy : Symbol(Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 102), Decl(underscoreTest1_underscore.ts, 486, 112), Decl(underscoreTest1_underscore.ts, 487, 72))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 487, 16))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 487, 19))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 487, 16))
@@ -4226,7 +4226,7 @@ module Underscore {
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
 
         countBy<T>(list: Dictionary<T>, propertyName: string): Dictionary<number>;
->countBy : Symbol(Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 94), Decl(underscoreTest1_underscore.ts, 486, 104), Decl(underscoreTest1_underscore.ts, 487, 72))
+>countBy : Symbol(Static.countBy, Decl(underscoreTest1_underscore.ts, 483, 79), Decl(underscoreTest1_underscore.ts, 485, 102), Decl(underscoreTest1_underscore.ts, 486, 112), Decl(underscoreTest1_underscore.ts, 487, 72))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 488, 16))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 488, 19))
 >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0))
@@ -4421,7 +4421,7 @@ module Underscore {
 >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 527, 26))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 527, 13))
 
-        uniq<T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
+        uniq<T, U>(list: T[], isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[];
 >uniq : Symbol(Static.uniq, Decl(underscoreTest1_underscore.ts, 525, 56), Decl(underscoreTest1_underscore.ts, 527, 52))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 528, 13))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 528, 15))
@@ -4429,36 +4429,36 @@ module Underscore {
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 528, 13))
 >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 528, 29))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 528, 48))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 528, 13))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 528, 15))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 528, 74))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 528, 82))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 528, 15))
 
         unique<T>(list: T[], isSorted?: boolean): T[];
->unique : Symbol(Static.unique, Decl(underscoreTest1_underscore.ts, 528, 95), Decl(underscoreTest1_underscore.ts, 529, 54))
+>unique : Symbol(Static.unique, Decl(underscoreTest1_underscore.ts, 528, 103), Decl(underscoreTest1_underscore.ts, 529, 54))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 529, 15))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 529, 18))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 529, 15))
 >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 529, 28))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 529, 15))
 
-        unique<T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
->unique : Symbol(Static.unique, Decl(underscoreTest1_underscore.ts, 528, 95), Decl(underscoreTest1_underscore.ts, 529, 54))
+        unique<T, U>(list: T[], isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[];
+>unique : Symbol(Static.unique, Decl(underscoreTest1_underscore.ts, 528, 103), Decl(underscoreTest1_underscore.ts, 529, 54))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 530, 15))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 530, 17))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 530, 21))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 530, 15))
 >isSorted : Symbol(isSorted, Decl(underscoreTest1_underscore.ts, 530, 31))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 530, 50))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 530, 15))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 530, 17))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 530, 76))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 530, 84))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 530, 17))
 
         zip<T0, T1>(a0: T0[], a1: T1[]): Tuple2<T0, T1>[];
->zip : Symbol(Static.zip, Decl(underscoreTest1_underscore.ts, 530, 97), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94))
+>zip : Symbol(Static.zip, Decl(underscoreTest1_underscore.ts, 530, 105), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94))
 >T0 : Symbol(T0, Decl(underscoreTest1_underscore.ts, 532, 12))
 >T1 : Symbol(T1, Decl(underscoreTest1_underscore.ts, 532, 15))
 >a0 : Symbol(a0, Decl(underscoreTest1_underscore.ts, 532, 20))
@@ -4470,7 +4470,7 @@ module Underscore {
 >T1 : Symbol(T1, Decl(underscoreTest1_underscore.ts, 532, 15))
 
         zip<T0, T1, T2>(a0: T0[], a1: T1[], a2: T2[]): Tuple3<T0, T1, T2>[];
->zip : Symbol(Static.zip, Decl(underscoreTest1_underscore.ts, 530, 97), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94))
+>zip : Symbol(Static.zip, Decl(underscoreTest1_underscore.ts, 530, 105), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94))
 >T0 : Symbol(T0, Decl(underscoreTest1_underscore.ts, 533, 12))
 >T1 : Symbol(T1, Decl(underscoreTest1_underscore.ts, 533, 15))
 >T2 : Symbol(T2, Decl(underscoreTest1_underscore.ts, 533, 19))
@@ -4486,7 +4486,7 @@ module Underscore {
 >T2 : Symbol(T2, Decl(underscoreTest1_underscore.ts, 533, 19))
 
         zip<T0, T1, T2, T3>(a0: T0[], a1: T1[], a2: T2[], a3: T3[]): Tuple4<T0, T1, T2, T3>[];
->zip : Symbol(Static.zip, Decl(underscoreTest1_underscore.ts, 530, 97), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94))
+>zip : Symbol(Static.zip, Decl(underscoreTest1_underscore.ts, 530, 105), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94))
 >T0 : Symbol(T0, Decl(underscoreTest1_underscore.ts, 534, 12))
 >T1 : Symbol(T1, Decl(underscoreTest1_underscore.ts, 534, 15))
 >T2 : Symbol(T2, Decl(underscoreTest1_underscore.ts, 534, 19))
@@ -4506,7 +4506,7 @@ module Underscore {
 >T3 : Symbol(T3, Decl(underscoreTest1_underscore.ts, 534, 23))
 
         zip(...arrays: any[][]): any[][];
->zip : Symbol(Static.zip, Decl(underscoreTest1_underscore.ts, 530, 97), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94))
+>zip : Symbol(Static.zip, Decl(underscoreTest1_underscore.ts, 530, 105), Decl(underscoreTest1_underscore.ts, 532, 58), Decl(underscoreTest1_underscore.ts, 533, 76), Decl(underscoreTest1_underscore.ts, 534, 94))
 >arrays : Symbol(arrays, Decl(underscoreTest1_underscore.ts, 535, 12))
 
         object(list: any[][]): any;
@@ -4545,7 +4545,7 @@ module Underscore {
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 544, 20))
 >propertyName : Symbol(propertyName, Decl(underscoreTest1_underscore.ts, 544, 41))
 
-        sortedIndex<T>(list: T[], obj: T, iterator?: Iterator<T, any>, context?: any): number;
+        sortedIndex<T>(list: T[], obj: T, iterator?: IteratorCallback<T, any>, context?: any): number;
 >sortedIndex : Symbol(Static.sortedIndex, Decl(underscoreTest1_underscore.ts, 542, 72), Decl(underscoreTest1_underscore.ts, 544, 72))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 545, 20))
 >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 545, 23))
@@ -4553,16 +4553,16 @@ module Underscore {
 >obj : Symbol(obj, Decl(underscoreTest1_underscore.ts, 545, 33))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 545, 20))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 545, 41))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 545, 20))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 545, 70))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 545, 78))
 
         range(stop: number): number[];
->range : Symbol(Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38))
+>range : Symbol(Static.range, Decl(underscoreTest1_underscore.ts, 545, 102), Decl(underscoreTest1_underscore.ts, 547, 38))
 >stop : Symbol(stop, Decl(underscoreTest1_underscore.ts, 547, 14))
 
         range(start: number, stop: number, step?: number): number[];
->range : Symbol(Static.range, Decl(underscoreTest1_underscore.ts, 545, 94), Decl(underscoreTest1_underscore.ts, 547, 38))
+>range : Symbol(Static.range, Decl(underscoreTest1_underscore.ts, 545, 102), Decl(underscoreTest1_underscore.ts, 547, 38))
 >start : Symbol(start, Decl(underscoreTest1_underscore.ts, 548, 14))
 >stop : Symbol(stop, Decl(underscoreTest1_underscore.ts, 548, 28))
 >step : Symbol(step, Decl(underscoreTest1_underscore.ts, 548, 42))
@@ -4833,22 +4833,22 @@ module Underscore {
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 620, 17))
 >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 620, 17))
 
-        times<U>(n: number, iterator: Iterator<number, U>, context?: any): U[];
+        times<U>(n: number, iterator: IteratorCallback<number, U>, context?: any): U[];
 >times : Symbol(Static.times, Decl(underscoreTest1_underscore.ts, 620, 33))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 622, 14))
 >n : Symbol(n, Decl(underscoreTest1_underscore.ts, 622, 17))
 >iterator : Symbol(iterator, Decl(underscoreTest1_underscore.ts, 622, 27))
->Iterator : Symbol(Iterator, Decl(underscoreTest1_underscore.ts, 2, 1))
+>IteratorCallback : Symbol(IteratorCallback, Decl(underscoreTest1_underscore.ts, 2, 1))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 622, 14))
->context : Symbol(context, Decl(underscoreTest1_underscore.ts, 622, 58))
+>context : Symbol(context, Decl(underscoreTest1_underscore.ts, 622, 66))
 >U : Symbol(U, Decl(underscoreTest1_underscore.ts, 622, 14))
 
         random(max: number): number;
->random : Symbol(Static.random, Decl(underscoreTest1_underscore.ts, 622, 79), Decl(underscoreTest1_underscore.ts, 624, 36))
+>random : Symbol(Static.random, Decl(underscoreTest1_underscore.ts, 622, 87), Decl(underscoreTest1_underscore.ts, 624, 36))
 >max : Symbol(max, Decl(underscoreTest1_underscore.ts, 624, 15))
 
         random(min: number, max: number): number;
->random : Symbol(Static.random, Decl(underscoreTest1_underscore.ts, 622, 79), Decl(underscoreTest1_underscore.ts, 624, 36))
+>random : Symbol(Static.random, Decl(underscoreTest1_underscore.ts, 622, 87), Decl(underscoreTest1_underscore.ts, 624, 36))
 >min : Symbol(min, Decl(underscoreTest1_underscore.ts, 625, 15))
 >max : Symbol(max, Decl(underscoreTest1_underscore.ts, 625, 27))
 
diff --git a/tests/baselines/reference/underscoreTest1.types b/tests/baselines/reference/underscoreTest1.types
index 5950e50efa1..0c6e1055e19 100644
--- a/tests/baselines/reference/underscoreTest1.types
+++ b/tests/baselines/reference/underscoreTest1.types
@@ -10,9 +10,9 @@ declare function alert(x: string): void;
 
 _.each([1, 2, 3], (num) => alert(num.toString()));
 >_.each([1, 2, 3], (num) => alert(num.toString())) : void
->_.each : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }
+>_.each : { <T>(list: T[], iterator: IteratorCallback<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, void>, context?: any): void; }
 >_ : Underscore.Static
->each : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }
+>each : { <T>(list: T[], iterator: IteratorCallback<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, void>, context?: any): void; }
 >[1, 2, 3] : number[]
 >1 : number
 >2 : number
@@ -28,9 +28,9 @@ _.each([1, 2, 3], (num) => alert(num.toString()));
 
 _.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(value.toString()));
 >_.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(value.toString())) : void
->_.each : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }
+>_.each : { <T>(list: T[], iterator: IteratorCallback<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, void>, context?: any): void; }
 >_ : Underscore.Static
->each : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }
+>each : { <T>(list: T[], iterator: IteratorCallback<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, void>, context?: any): void; }
 >{ one: 1, two: 2, three: 3 } : { one: number; two: number; three: number; }
 >one : number
 >1 : number
@@ -50,9 +50,9 @@ _.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(valu
 
 _.map([1, 2, 3], (num) => num * 3);
 >_.map([1, 2, 3], (num) => num * 3) : number[]
->_.map : { <T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[]; }
+>_.map : { <T, U>(list: T[], iterator: IteratorCallback<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: IteratorCallback<T, U>, context?: any): U[]; }
 >_ : Underscore.Static
->map : { <T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[]; }
+>map : { <T, U>(list: T[], iterator: IteratorCallback<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: IteratorCallback<T, U>, context?: any): U[]; }
 >[1, 2, 3] : number[]
 >1 : number
 >2 : number
@@ -65,9 +65,9 @@ _.map([1, 2, 3], (num) => num * 3);
 
 _.map({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => value * 3);
 >_.map({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => value * 3) : number[]
->_.map : { <T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[]; }
+>_.map : { <T, U>(list: T[], iterator: IteratorCallback<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: IteratorCallback<T, U>, context?: any): U[]; }
 >_ : Underscore.Static
->map : { <T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[]; }
+>map : { <T, U>(list: T[], iterator: IteratorCallback<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: IteratorCallback<T, U>, context?: any): U[]; }
 >{ one: 1, two: 2, three: 3 } : { one: number; two: number; three: number; }
 >one : number
 >1 : number
@@ -85,9 +85,9 @@ _.map({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => value * 3);
 var sum = _.reduce([1, 2, 3], (memo, num) => memo + num, 0);
 >sum : number
 >_.reduce([1, 2, 3], (memo, num) => memo + num, 0) : number
->_.reduce : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+>_.reduce : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >_ : Underscore.Static
->reduce : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+>reduce : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >[1, 2, 3] : number[]
 >1 : number
 >2 : number
@@ -116,9 +116,9 @@ var list = [[0, 1], [2, 3], [4, 5]];
 var flat = _.reduceRight(list, (a, b) => a.concat(b), []);
 >flat : number[]
 >_.reduceRight(list, (a, b) => a.concat(b), []) : number[]
->_.reduceRight : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+>_.reduceRight : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >_ : Underscore.Static
->reduceRight : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+>reduceRight : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >list : number[][]
 >(a, b) => a.concat(b) : (a: number[], b: number[]) => number[]
 >a : number[]
@@ -133,9 +133,9 @@ var flat = _.reduceRight(list, (a, b) => a.concat(b), []);
 var even = _.find([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
 >even : number
 >_.find([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0) : number
->_.find : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T; }
+>_.find : { <T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T; }
 >_ : Underscore.Static
->find : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T; }
+>find : { <T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T; }
 >[1, 2, 3, 4, 5, 6] : number[]
 >1 : number
 >2 : number
@@ -154,9 +154,9 @@ var even = _.find([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
 var evens = _.filter([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
 >evens : number[]
 >_.filter([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0) : number[]
->_.filter : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }
+>_.filter : { <T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[]; }
 >_ : Underscore.Static
->filter : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }
+>filter : { <T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[]; }
 >[1, 2, 3, 4, 5, 6] : number[]
 >1 : number
 >2 : number
@@ -212,9 +212,9 @@ _.where(listOfPlays, { author: "Shakespeare", year: 1611 });
 var odds = _.reject([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
 >odds : number[]
 >_.reject([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0) : number[]
->_.reject : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }
+>_.reject : { <T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[]; }
 >_ : Underscore.Static
->reject : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }
+>reject : { <T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[]; }
 >[1, 2, 3, 4, 5, 6] : number[]
 >1 : number
 >2 : number
@@ -232,9 +232,9 @@ var odds = _.reject([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
 
 _.all([true, 1, null, 'yes'], _.identity);
 >_.all([true, 1, null, 'yes'], _.identity) : boolean
->_.all : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
+>_.all : { <T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean; }
 >_ : Underscore.Static
->all : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
+>all : { <T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean; }
 >[true, 1, null, 'yes'] : (string | number | boolean)[]
 >true : boolean
 >1 : number
@@ -246,9 +246,9 @@ _.all([true, 1, null, 'yes'], _.identity);
 
 _.any([null, 0, 'yes', false]);
 >_.any([null, 0, 'yes', false]) : boolean
->_.any : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
+>_.any : { <T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean; }
 >_ : Underscore.Static
->any : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
+>any : { <T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean; }
 >[null, 0, 'yes', false] : (string | number | boolean)[]
 >null : null
 >0 : number
@@ -311,9 +311,9 @@ _.pluck(stooges, 'name');
 
 _.max(stooges, (stooge) => stooge.age);
 >_.max(stooges, (stooge) => stooge.age) : { name: string; age: number; }
->_.max : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T; }
+>_.max : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): T; }
 >_ : Underscore.Static
->max : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T; }
+>max : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): T; }
 >stooges : { name: string; age: number; }[]
 >(stooge) => stooge.age : (stooge: { name: string; age: number; }) => number
 >stooge : { name: string; age: number; }
@@ -332,16 +332,16 @@ var numbers = [10, 5, 100, 2, 1000];
 
 _.min(numbers);
 >_.min(numbers) : number
->_.min : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T; }
+>_.min : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): T; }
 >_ : Underscore.Static
->min : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T; }
+>min : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): T; }
 >numbers : number[]
 
 _.sortBy([1, 2, 3, 4, 5, 6], (num) => Math.sin(num));
 >_.sortBy([1, 2, 3, 4, 5, 6], (num) => Math.sin(num)) : number[]
->_.sortBy : { <T>(list: T[], iterator: Iterator<T, any>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, any>, context?: any): T[]; <T>(list: T[], propertyName: string): T[]; <T>(list: Dictionary<T>, propertyName: string): T[]; }
+>_.sortBy : { <T>(list: T[], iterator: IteratorCallback<T, any>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, any>, context?: any): T[]; <T>(list: T[], propertyName: string): T[]; <T>(list: Dictionary<T>, propertyName: string): T[]; }
 >_ : Underscore.Static
->sortBy : { <T>(list: T[], iterator: Iterator<T, any>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, any>, context?: any): T[]; <T>(list: T[], propertyName: string): T[]; <T>(list: Dictionary<T>, propertyName: string): T[]; }
+>sortBy : { <T>(list: T[], iterator: IteratorCallback<T, any>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, any>, context?: any): T[]; <T>(list: T[], propertyName: string): T[]; <T>(list: Dictionary<T>, propertyName: string): T[]; }
 >[1, 2, 3, 4, 5, 6] : number[]
 >1 : number
 >2 : number
@@ -361,14 +361,14 @@ _.sortBy([1, 2, 3, 4, 5, 6], (num) => Math.sin(num));
 // not sure how this is typechecking at all.. Math.floor(e) is number not string..?
 _([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floor(e));
 >_([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floor(e)) : Dictionary<number[]>
->_([1.3, 2.1, 2.4]).groupBy : { (iterator?: Iterator<number, any>, context?: any): Dictionary<number[]>; (propertyName: string): Dictionary<number[]>; }
+>_([1.3, 2.1, 2.4]).groupBy : { (iterator?: IteratorCallback<number, any>, context?: any): Dictionary<number[]>; (propertyName: string): Dictionary<number[]>; }
 >_([1.3, 2.1, 2.4]) : Underscore.WrappedArray<number>
 >_ : Underscore.Static
 >[1.3, 2.1, 2.4] : number[]
 >1.3 : number
 >2.1 : number
 >2.4 : number
->groupBy : { (iterator?: Iterator<number, any>, context?: any): Dictionary<number[]>; (propertyName: string): Dictionary<number[]>; }
+>groupBy : { (iterator?: IteratorCallback<number, any>, context?: any): Dictionary<number[]>; (propertyName: string): Dictionary<number[]>; }
 >(e: number, i?: number, list?: number[]) => Math.floor(e) : (e: number, i?: number, list?: number[]) => number
 >e : number
 >i : number
@@ -381,9 +381,9 @@ _([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floo
 
 _.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num));
 >_.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num)) : Dictionary<number[]>
->_.groupBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }
+>_.groupBy : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }
 >_ : Underscore.Static
->groupBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }
+>groupBy : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }
 >[1.3, 2.1, 2.4] : number[]
 >1.3 : number
 >2.1 : number
@@ -398,9 +398,9 @@ _.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num));
 
 _.groupBy(['one', 'two', 'three'], 'length');
 >_.groupBy(['one', 'two', 'three'], 'length') : Dictionary<string[]>
->_.groupBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }
+>_.groupBy : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }
 >_ : Underscore.Static
->groupBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }
+>groupBy : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }
 >['one', 'two', 'three'] : string[]
 >'one' : string
 >'two' : string
@@ -409,9 +409,9 @@ _.groupBy(['one', 'two', 'three'], 'length');
 
 _.countBy([1, 2, 3, 4, 5], (num) => num % 2 == 0 ? 'even' : 'odd');
 >_.countBy([1, 2, 3, 4, 5], (num) => num % 2 == 0 ? 'even' : 'odd') : Dictionary<number>
->_.countBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: T[], propertyName: string): Dictionary<number>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<number>; }
+>_.countBy : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>; <T>(list: T[], propertyName: string): Dictionary<number>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<number>; }
 >_ : Underscore.Static
->countBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: T[], propertyName: string): Dictionary<number>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<number>; }
+>countBy : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>; <T>(list: T[], propertyName: string): Dictionary<number>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<number>; }
 >[1, 2, 3, 4, 5] : number[]
 >1 : number
 >2 : number
@@ -643,9 +643,9 @@ _.difference([1, 2, 3, 4, 5], [5, 2, 10]);
 
 _.uniq([1, 2, 1, 3, 1, 4]);
 >_.uniq([1, 2, 1, 3, 1, 4]) : number[]
->_.uniq : { <T>(list: T[], isSorted?: boolean): T[]; <T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }
+>_.uniq : { <T>(list: T[], isSorted?: boolean): T[]; <T, U>(list: T[], isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[]; }
 >_ : Underscore.Static
->uniq : { <T>(list: T[], isSorted?: boolean): T[]; <T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }
+>uniq : { <T>(list: T[], isSorted?: boolean): T[]; <T, U>(list: T[], isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[]; }
 >[1, 2, 1, 3, 1, 4] : number[]
 >1 : number
 >2 : number
@@ -729,9 +729,9 @@ _.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
 
 _.sortedIndex([10, 20, 30, 40, 50], 35);
 >_.sortedIndex([10, 20, 30, 40, 50], 35) : number
->_.sortedIndex : { <T>(list: T[], obj: T, propertyName: string): number; <T>(list: T[], obj: T, iterator?: Iterator<T, any>, context?: any): number; }
+>_.sortedIndex : { <T>(list: T[], obj: T, propertyName: string): number; <T>(list: T[], obj: T, iterator?: IteratorCallback<T, any>, context?: any): number; }
 >_ : Underscore.Static
->sortedIndex : { <T>(list: T[], obj: T, propertyName: string): number; <T>(list: T[], obj: T, iterator?: Iterator<T, any>, context?: any): number; }
+>sortedIndex : { <T>(list: T[], obj: T, propertyName: string): number; <T>(list: T[], obj: T, iterator?: IteratorCallback<T, any>, context?: any): number; }
 >[10, 20, 30, 40, 50] : number[]
 >10 : number
 >20 : number
@@ -1017,9 +1017,9 @@ var renderNotes = _.after(notes.length, render);
 
 _.each(notes, (note) => note.asyncSave({ success: renderNotes }));
 >_.each(notes, (note) => note.asyncSave({ success: renderNotes })) : void
->_.each : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }
+>_.each : { <T>(list: T[], iterator: IteratorCallback<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, void>, context?: any): void; }
 >_ : Underscore.Static
->each : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }
+>each : { <T>(list: T[], iterator: IteratorCallback<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, void>, context?: any): void; }
 >notes : any[]
 >(note) => note.asyncSave({ success: renderNotes }) : (note: any) => any
 >note : any
@@ -1226,11 +1226,11 @@ _.chain([1, 2, 3, 200])
 >_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap(<any>alert)    .map(function (num) { return num * num })    .value() : number[]
 >_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap(<any>alert)    .map(function (num) { return num * num })    .value : () => number[]
 >_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap(<any>alert)    .map(function (num) { return num * num }) : Underscore.ChainedArray<number>
->_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap(<any>alert)    .map : <U>(iterator: Iterator<number, U>, context?: any) => Underscore.ChainedArray<U>
+>_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap(<any>alert)    .map : <U>(iterator: IteratorCallback<number, U>, context?: any) => Underscore.ChainedArray<U>
 >_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap(<any>alert) : Underscore.ChainedArray<number>
 >_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; })    .tap : (interceptor: (object: number[]) => void) => Underscore.ChainedArray<number>
 >_.chain([1, 2, 3, 200])    .filter(function (num) { return num % 2 == 0; }) : Underscore.ChainedArray<number>
->_.chain([1, 2, 3, 200])    .filter : (iterator: Iterator<number, boolean>, context?: any) => Underscore.ChainedArray<number>
+>_.chain([1, 2, 3, 200])    .filter : (iterator: IteratorCallback<number, boolean>, context?: any) => Underscore.ChainedArray<number>
 >_.chain([1, 2, 3, 200]) : Underscore.ChainedArray<number>
 >_.chain : { <T>(list: T[]): Underscore.ChainedArray<T>; <T>(list: Dictionary<T>): Underscore.ChainedDictionary<T>; <T>(obj: T): Underscore.ChainedObject<T>; }
 >_ : Underscore.Static
@@ -1242,7 +1242,7 @@ _.chain([1, 2, 3, 200])
 >200 : number
 
     .filter(function (num) { return num % 2 == 0; })
->filter : (iterator: Iterator<number, boolean>, context?: any) => Underscore.ChainedArray<number>
+>filter : (iterator: IteratorCallback<number, boolean>, context?: any) => Underscore.ChainedArray<number>
 >function (num) { return num % 2 == 0; } : (num: number) => boolean
 >num : number
 >num % 2 == 0 : boolean
@@ -1257,7 +1257,7 @@ _.chain([1, 2, 3, 200])
 >alert : (x: string) => void
 
     .map(function (num) { return num * num })
->map : <U>(iterator: Iterator<number, U>, context?: any) => Underscore.ChainedArray<U>
+>map : <U>(iterator: IteratorCallback<number, U>, context?: any) => Underscore.ChainedArray<U>
 >function (num) { return num * num } : (num: number) => number
 >num : number
 >num * num : number
@@ -1524,9 +1524,9 @@ var genie;
 
 _.times(3, function (n) { genie.grantWishNumber(n); });
 >_.times(3, function (n) { genie.grantWishNumber(n); }) : void[]
->_.times : <U>(n: number, iterator: Iterator<number, U>, context?: any) => U[]
+>_.times : <U>(n: number, iterator: IteratorCallback<number, U>, context?: any) => U[]
 >_ : Underscore.Static
->times : <U>(n: number, iterator: Iterator<number, U>, context?: any) => U[]
+>times : <U>(n: number, iterator: IteratorCallback<number, U>, context?: any) => U[]
 >3 : number
 >function (n) { genie.grantWishNumber(n); } : (n: number) => void
 >n : number
@@ -1737,8 +1737,8 @@ interface Dictionary<T> {
 >T : T
 }
 
-interface Iterator<T, U> {
->Iterator : Iterator<T, U>
+interface IteratorCallback<T, U> {
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >U : U
 
@@ -1750,8 +1750,8 @@ interface Iterator<T, U> {
 >U : U
 }
 
-interface Reducer<T, U> {
->Reducer : Reducer<T, U>
+interface ReducerCallback<T, U> {
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 
@@ -2011,44 +2011,44 @@ module Underscore {
 >Array : T[]
 >T : T
 
-        each(iterator: Iterator<T, void>, context?: any): void;
->each : (iterator: Iterator<T, void>, context?: any) => void
->iterator : Iterator<T, void>
->Iterator : Iterator<T, U>
+        each(iterator: IteratorCallback<T, void>, context?: any): void;
+>each : (iterator: IteratorCallback<T, void>, context?: any) => void
+>iterator : IteratorCallback<T, void>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        forEach(iterator: Iterator<T, void>, context?: any): void;
->forEach : (iterator: Iterator<T, void>, context?: any) => void
->iterator : Iterator<T, void>
->Iterator : Iterator<T, U>
+        forEach(iterator: IteratorCallback<T, void>, context?: any): void;
+>forEach : (iterator: IteratorCallback<T, void>, context?: any) => void
+>iterator : IteratorCallback<T, void>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        map<U>(iterator: Iterator<T, U>, context?: any): U[];
->map : <U>(iterator: Iterator<T, U>, context?: any) => U[]
+        map<U>(iterator: IteratorCallback<T, U>, context?: any): U[];
+>map : <U>(iterator: IteratorCallback<T, U>, context?: any) => U[]
 >U : U
->iterator : Iterator<T, U>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, U>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >U : U
 >context : any
 >U : U
 
-        collect<U>(iterator: Iterator<T, U>, context?: any): U[];
->collect : <U>(iterator: Iterator<T, U>, context?: any) => U[]
+        collect<U>(iterator: IteratorCallback<T, U>, context?: any): U[];
+>collect : <U>(iterator: IteratorCallback<T, U>, context?: any) => U[]
 >U : U
->iterator : Iterator<T, U>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, U>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >U : U
 >context : any
 >U : U
 
-        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->reduce : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        reduce(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>reduce : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -2056,11 +2056,11 @@ module Underscore {
 >context : any
 >T : T
 
-        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->reduce : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        reduce<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>reduce : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -2068,10 +2068,10 @@ module Underscore {
 >context : any
 >U : U
 
-        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->foldl : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        foldl(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>foldl : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -2079,11 +2079,11 @@ module Underscore {
 >context : any
 >T : T
 
-        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->foldl : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        foldl<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>foldl : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -2091,10 +2091,10 @@ module Underscore {
 >context : any
 >U : U
 
-        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->inject : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        inject(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>inject : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -2102,11 +2102,11 @@ module Underscore {
 >context : any
 >T : T
 
-        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->inject : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        inject<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>inject : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -2114,10 +2114,10 @@ module Underscore {
 >context : any
 >U : U
 
-        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->reduceRight : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        reduceRight(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>reduceRight : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -2125,11 +2125,11 @@ module Underscore {
 >context : any
 >T : T
 
-        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->reduceRight : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        reduceRight<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>reduceRight : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -2137,10 +2137,10 @@ module Underscore {
 >context : any
 >U : U
 
-        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->foldr : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        foldr(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>foldr : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -2148,11 +2148,11 @@ module Underscore {
 >context : any
 >T : T
 
-        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->foldr : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        foldr<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>foldr : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -2160,34 +2160,34 @@ module Underscore {
 >context : any
 >U : U
 
-        find(iterator: Iterator<T, boolean>, context?: any): T;
->find : (iterator: Iterator<T, boolean>, context?: any) => T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        find(iterator: IteratorCallback<T, boolean>, context?: any): T;
+>find : (iterator: IteratorCallback<T, boolean>, context?: any) => T
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        detect(iterator: Iterator<T, boolean>, context?: any): T;
->detect : (iterator: Iterator<T, boolean>, context?: any) => T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        detect(iterator: IteratorCallback<T, boolean>, context?: any): T;
+>detect : (iterator: IteratorCallback<T, boolean>, context?: any) => T
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        filter(iterator: Iterator<T, boolean>, context?: any): T[];
->filter : (iterator: Iterator<T, boolean>, context?: any) => T[]
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        filter(iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>filter : (iterator: IteratorCallback<T, boolean>, context?: any) => T[]
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        select(iterator: Iterator<T, boolean>, context?: any): T[];
->select : (iterator: Iterator<T, boolean>, context?: any) => T[]
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        select(iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>select : (iterator: IteratorCallback<T, boolean>, context?: any) => T[]
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
@@ -2204,39 +2204,39 @@ module Underscore {
 >Object : Object
 >T : T
 
-        reject(iterator: Iterator<T, boolean>, context?: any): T[];
->reject : (iterator: Iterator<T, boolean>, context?: any) => T[]
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        reject(iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>reject : (iterator: IteratorCallback<T, boolean>, context?: any) => T[]
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        every(iterator?: Iterator<T, boolean>, context?: any): boolean;
->every : (iterator?: Iterator<T, boolean>, context?: any) => boolean
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        every(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>every : (iterator?: IteratorCallback<T, boolean>, context?: any) => boolean
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        all(iterator?: Iterator<T, boolean>, context?: any): boolean;
->all : (iterator?: Iterator<T, boolean>, context?: any) => boolean
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        all(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>all : (iterator?: IteratorCallback<T, boolean>, context?: any) => boolean
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        some(iterator?: Iterator<T, boolean>, context?: any): boolean;
->some : (iterator?: Iterator<T, boolean>, context?: any) => boolean
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        some(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>some : (iterator?: IteratorCallback<T, boolean>, context?: any) => boolean
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        any(iterator?: Iterator<T, boolean>, context?: any): boolean;
->any : (iterator?: Iterator<T, boolean>, context?: any) => boolean
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        any(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>any : (iterator?: IteratorCallback<T, boolean>, context?: any) => boolean
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
@@ -2259,60 +2259,60 @@ module Underscore {
 >pluck : (propertyName: string) => any[]
 >propertyName : string
 
-        max(iterator?: Iterator<T, any>, context?: any): T;
->max : (iterator?: Iterator<T, any>, context?: any) => T
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        max(iterator?: IteratorCallback<T, any>, context?: any): T;
+>max : (iterator?: IteratorCallback<T, any>, context?: any) => T
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        min(iterator?: Iterator<T, any>, context?: any): T;
->min : (iterator?: Iterator<T, any>, context?: any) => T
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        min(iterator?: IteratorCallback<T, any>, context?: any): T;
+>min : (iterator?: IteratorCallback<T, any>, context?: any) => T
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        sortBy(iterator: Iterator<T, any>, context?: any): T[];
->sortBy : { (iterator: Iterator<T, any>, context?: any): T[]; (propertyName: string): T[]; }
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        sortBy(iterator: IteratorCallback<T, any>, context?: any): T[];
+>sortBy : { (iterator: IteratorCallback<T, any>, context?: any): T[]; (propertyName: string): T[]; }
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
         sortBy(propertyName: string): T[];
->sortBy : { (iterator: Iterator<T, any>, context?: any): T[]; (propertyName: string): T[]; }
+>sortBy : { (iterator: IteratorCallback<T, any>, context?: any): T[]; (propertyName: string): T[]; }
 >propertyName : string
 >T : T
 
-        groupBy(iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
->groupBy : { (iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; (propertyName: string): Dictionary<T[]>; }
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        groupBy(iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>;
+>groupBy : { (iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; (propertyName: string): Dictionary<T[]>; }
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >Dictionary : Dictionary<T>
 >T : T
 
         groupBy(propertyName: string): Dictionary<T[]>;
->groupBy : { (iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; (propertyName: string): Dictionary<T[]>; }
+>groupBy : { (iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; (propertyName: string): Dictionary<T[]>; }
 >propertyName : string
 >Dictionary : Dictionary<T>
 >T : T
 
-        countBy(iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
->countBy : { (iterator?: Iterator<T, any>, context?: any): Dictionary<number>; (propertyName: string): Dictionary<number>; }
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        countBy(iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>;
+>countBy : { (iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>; (propertyName: string): Dictionary<number>; }
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >Dictionary : Dictionary<T>
 
         countBy(propertyName: string): Dictionary<number>;
->countBy : { (iterator?: Iterator<T, any>, context?: any): Dictionary<number>; (propertyName: string): Dictionary<number>; }
+>countBy : { (iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>; (propertyName: string): Dictionary<number>; }
 >propertyName : string
 >Dictionary : Dictionary<T>
 
@@ -2412,32 +2412,32 @@ module Underscore {
 >T : T
 
         uniq(isSorted?: boolean): T[];
->uniq : { (isSorted?: boolean): T[]; <U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }
+>uniq : { (isSorted?: boolean): T[]; <U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[]; }
 >isSorted : boolean
 >T : T
 
-        uniq<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
->uniq : { (isSorted?: boolean): T[]; <U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }
+        uniq<U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[];
+>uniq : { (isSorted?: boolean): T[]; <U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[]; }
 >U : U
 >isSorted : boolean
->iterator : Iterator<T, U>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, U>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >U : U
 >context : any
 >U : U
 
         unique(isSorted?: boolean): T[];
->unique : { (isSorted?: boolean): T[]; <U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }
+>unique : { (isSorted?: boolean): T[]; <U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[]; }
 >isSorted : boolean
 >T : T
 
-        unique<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
->unique : { (isSorted?: boolean): T[]; <U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }
+        unique<U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[];
+>unique : { (isSorted?: boolean): T[]; <U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[]; }
 >U : U
 >isSorted : boolean
->iterator : Iterator<T, U>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, U>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >U : U
 >context : any
@@ -2467,17 +2467,17 @@ module Underscore {
 >fromIndex : number
 
         sortedIndex(obj: T, propertyName: string): number;
->sortedIndex : { (obj: T, propertyName: string): number; (obj: T, iterator?: Iterator<T, any>, context?: any): number; }
+>sortedIndex : { (obj: T, propertyName: string): number; (obj: T, iterator?: IteratorCallback<T, any>, context?: any): number; }
 >obj : T
 >T : T
 >propertyName : string
 
-        sortedIndex(obj: T, iterator?: Iterator<T, any>, context?: any): number;
->sortedIndex : { (obj: T, propertyName: string): number; (obj: T, iterator?: Iterator<T, any>, context?: any): number; }
+        sortedIndex(obj: T, iterator?: IteratorCallback<T, any>, context?: any): number;
+>sortedIndex : { (obj: T, propertyName: string): number; (obj: T, iterator?: IteratorCallback<T, any>, context?: any): number; }
 >obj : T
 >T : T
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
@@ -2550,44 +2550,44 @@ module Underscore {
 >Dictionary : Dictionary<T>
 >T : T
 
-        each(iterator: Iterator<T, void>, context?: any): void;
->each : (iterator: Iterator<T, void>, context?: any) => void
->iterator : Iterator<T, void>
->Iterator : Iterator<T, U>
+        each(iterator: IteratorCallback<T, void>, context?: any): void;
+>each : (iterator: IteratorCallback<T, void>, context?: any) => void
+>iterator : IteratorCallback<T, void>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        forEach(iterator: Iterator<T, void>, context?: any): void;
->forEach : (iterator: Iterator<T, void>, context?: any) => void
->iterator : Iterator<T, void>
->Iterator : Iterator<T, U>
+        forEach(iterator: IteratorCallback<T, void>, context?: any): void;
+>forEach : (iterator: IteratorCallback<T, void>, context?: any) => void
+>iterator : IteratorCallback<T, void>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        map<U>(iterator: Iterator<T, U>, context?: any): U[];
->map : <U>(iterator: Iterator<T, U>, context?: any) => U[]
+        map<U>(iterator: IteratorCallback<T, U>, context?: any): U[];
+>map : <U>(iterator: IteratorCallback<T, U>, context?: any) => U[]
 >U : U
->iterator : Iterator<T, U>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, U>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >U : U
 >context : any
 >U : U
 
-        collect<U>(iterator: Iterator<T, U>, context?: any): U[];
->collect : <U>(iterator: Iterator<T, U>, context?: any) => U[]
+        collect<U>(iterator: IteratorCallback<T, U>, context?: any): U[];
+>collect : <U>(iterator: IteratorCallback<T, U>, context?: any) => U[]
 >U : U
->iterator : Iterator<T, U>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, U>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >U : U
 >context : any
 >U : U
 
-        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->reduce : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        reduce(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>reduce : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -2595,11 +2595,11 @@ module Underscore {
 >context : any
 >T : T
 
-        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->reduce : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        reduce<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>reduce : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -2607,10 +2607,10 @@ module Underscore {
 >context : any
 >U : U
 
-        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->foldl : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        foldl(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>foldl : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -2618,11 +2618,11 @@ module Underscore {
 >context : any
 >T : T
 
-        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->foldl : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        foldl<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>foldl : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -2630,10 +2630,10 @@ module Underscore {
 >context : any
 >U : U
 
-        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->inject : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        inject(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>inject : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -2641,11 +2641,11 @@ module Underscore {
 >context : any
 >T : T
 
-        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->inject : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        inject<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>inject : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -2653,10 +2653,10 @@ module Underscore {
 >context : any
 >U : U
 
-        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->reduceRight : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        reduceRight(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>reduceRight : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -2664,11 +2664,11 @@ module Underscore {
 >context : any
 >T : T
 
-        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->reduceRight : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        reduceRight<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>reduceRight : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -2676,10 +2676,10 @@ module Underscore {
 >context : any
 >U : U
 
-        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->foldr : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        foldr(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>foldr : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -2687,11 +2687,11 @@ module Underscore {
 >context : any
 >T : T
 
-        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->foldr : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        foldr<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>foldr : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -2699,34 +2699,34 @@ module Underscore {
 >context : any
 >U : U
 
-        find(iterator: Iterator<T, boolean>, context?: any): T;
->find : (iterator: Iterator<T, boolean>, context?: any) => T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        find(iterator: IteratorCallback<T, boolean>, context?: any): T;
+>find : (iterator: IteratorCallback<T, boolean>, context?: any) => T
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        detect(iterator: Iterator<T, boolean>, context?: any): T;
->detect : (iterator: Iterator<T, boolean>, context?: any) => T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        detect(iterator: IteratorCallback<T, boolean>, context?: any): T;
+>detect : (iterator: IteratorCallback<T, boolean>, context?: any) => T
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        filter(iterator: Iterator<T, boolean>, context?: any): T[];
->filter : (iterator: Iterator<T, boolean>, context?: any) => T[]
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        filter(iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>filter : (iterator: IteratorCallback<T, boolean>, context?: any) => T[]
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        select(iterator: Iterator<T, boolean>, context?: any): T[];
->select : (iterator: Iterator<T, boolean>, context?: any) => T[]
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        select(iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>select : (iterator: IteratorCallback<T, boolean>, context?: any) => T[]
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
@@ -2743,39 +2743,39 @@ module Underscore {
 >Object : Object
 >T : T
 
-        reject(iterator: Iterator<T, boolean>, context?: any): T[];
->reject : (iterator: Iterator<T, boolean>, context?: any) => T[]
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        reject(iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>reject : (iterator: IteratorCallback<T, boolean>, context?: any) => T[]
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        every(iterator?: Iterator<T, boolean>, context?: any): boolean;
->every : (iterator?: Iterator<T, boolean>, context?: any) => boolean
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        every(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>every : (iterator?: IteratorCallback<T, boolean>, context?: any) => boolean
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        all(iterator?: Iterator<T, boolean>, context?: any): boolean;
->all : (iterator?: Iterator<T, boolean>, context?: any) => boolean
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        all(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>all : (iterator?: IteratorCallback<T, boolean>, context?: any) => boolean
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        some(iterator?: Iterator<T, boolean>, context?: any): boolean;
->some : (iterator?: Iterator<T, boolean>, context?: any) => boolean
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        some(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>some : (iterator?: IteratorCallback<T, boolean>, context?: any) => boolean
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        any(iterator?: Iterator<T, boolean>, context?: any): boolean;
->any : (iterator?: Iterator<T, boolean>, context?: any) => boolean
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        any(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>any : (iterator?: IteratorCallback<T, boolean>, context?: any) => boolean
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
@@ -2798,60 +2798,60 @@ module Underscore {
 >pluck : (propertyName: string) => any[]
 >propertyName : string
 
-        max(iterator?: Iterator<T, any>, context?: any): T;
->max : (iterator?: Iterator<T, any>, context?: any) => T
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        max(iterator?: IteratorCallback<T, any>, context?: any): T;
+>max : (iterator?: IteratorCallback<T, any>, context?: any) => T
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        min(iterator?: Iterator<T, any>, context?: any): T;
->min : (iterator?: Iterator<T, any>, context?: any) => T
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        min(iterator?: IteratorCallback<T, any>, context?: any): T;
+>min : (iterator?: IteratorCallback<T, any>, context?: any) => T
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        sortBy(iterator: Iterator<T, any>, context?: any): T[];
->sortBy : { (iterator: Iterator<T, any>, context?: any): T[]; (propertyName: string): T[]; }
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        sortBy(iterator: IteratorCallback<T, any>, context?: any): T[];
+>sortBy : { (iterator: IteratorCallback<T, any>, context?: any): T[]; (propertyName: string): T[]; }
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
         sortBy(propertyName: string): T[];
->sortBy : { (iterator: Iterator<T, any>, context?: any): T[]; (propertyName: string): T[]; }
+>sortBy : { (iterator: IteratorCallback<T, any>, context?: any): T[]; (propertyName: string): T[]; }
 >propertyName : string
 >T : T
 
-        groupBy(iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
->groupBy : { (iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; (propertyName: string): Dictionary<T[]>; }
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        groupBy(iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>;
+>groupBy : { (iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; (propertyName: string): Dictionary<T[]>; }
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >Dictionary : Dictionary<T>
 >T : T
 
         groupBy(propertyName: string): Dictionary<T[]>;
->groupBy : { (iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; (propertyName: string): Dictionary<T[]>; }
+>groupBy : { (iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; (propertyName: string): Dictionary<T[]>; }
 >propertyName : string
 >Dictionary : Dictionary<T>
 >T : T
 
-        countBy(iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
->countBy : { (iterator?: Iterator<T, any>, context?: any): Dictionary<number>; (propertyName: string): Dictionary<number>; }
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        countBy(iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>;
+>countBy : { (iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>; (propertyName: string): Dictionary<number>; }
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >Dictionary : Dictionary<T>
 
         countBy(propertyName: string): Dictionary<number>;
->countBy : { (iterator?: Iterator<T, any>, context?: any): Dictionary<number>; (propertyName: string): Dictionary<number>; }
+>countBy : { (iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>; (propertyName: string): Dictionary<number>; }
 >propertyName : string
 >Dictionary : Dictionary<T>
 
@@ -3015,48 +3015,48 @@ module Underscore {
 >Array : T[]
 >T : T
 
-        each(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
->each : (iterator: Iterator<T, void>, context?: any) => ChainedObject<void>
->iterator : Iterator<T, void>
->Iterator : Iterator<T, U>
+        each(iterator: IteratorCallback<T, void>, context?: any): ChainedObject<void>;
+>each : (iterator: IteratorCallback<T, void>, context?: any) => ChainedObject<void>
+>iterator : IteratorCallback<T, void>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
 
-        forEach(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
->forEach : (iterator: Iterator<T, void>, context?: any) => ChainedObject<void>
->iterator : Iterator<T, void>
->Iterator : Iterator<T, U>
+        forEach(iterator: IteratorCallback<T, void>, context?: any): ChainedObject<void>;
+>forEach : (iterator: IteratorCallback<T, void>, context?: any) => ChainedObject<void>
+>iterator : IteratorCallback<T, void>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
 
-        map<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
->map : <U>(iterator: Iterator<T, U>, context?: any) => ChainedArray<U>
+        map<U>(iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
+>map : <U>(iterator: IteratorCallback<T, U>, context?: any) => ChainedArray<U>
 >U : U
->iterator : Iterator<T, U>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, U>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >U : U
 >context : any
 >ChainedArray : ChainedArray<T>
 >U : U
 
-        collect<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
->collect : <U>(iterator: Iterator<T, U>, context?: any) => ChainedArray<U>
+        collect<U>(iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
+>collect : <U>(iterator: IteratorCallback<T, U>, context?: any) => ChainedArray<U>
 >U : U
->iterator : Iterator<T, U>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, U>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >U : U
 >context : any
 >ChainedArray : ChainedArray<T>
 >U : U
 
-        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->reduce : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        reduce(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>reduce : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -3065,11 +3065,11 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->reduce : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+        reduce<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>reduce : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -3078,10 +3078,10 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >U : U
 
-        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->foldl : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        foldl(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>foldl : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -3090,11 +3090,11 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->foldl : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+        foldl<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>foldl : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -3103,10 +3103,10 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >U : U
 
-        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->inject : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        inject(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>inject : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -3115,11 +3115,11 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->inject : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+        inject<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>inject : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -3128,10 +3128,10 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >U : U
 
-        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->reduceRight : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        reduceRight(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>reduceRight : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -3140,11 +3140,11 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->reduceRight : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+        reduceRight<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>reduceRight : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -3153,10 +3153,10 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >U : U
 
-        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->foldr : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        foldr(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>foldr : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -3165,11 +3165,11 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->foldr : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+        foldr<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>foldr : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -3178,37 +3178,37 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >U : U
 
-        find(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
->find : (iterator: Iterator<T, boolean>, context?: any) => ChainedObject<T>
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        find(iterator: IteratorCallback<T, boolean>, context?: any): ChainedObject<T>;
+>find : (iterator: IteratorCallback<T, boolean>, context?: any) => ChainedObject<T>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        detect(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
->detect : (iterator: Iterator<T, boolean>, context?: any) => ChainedObject<T>
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        detect(iterator: IteratorCallback<T, boolean>, context?: any): ChainedObject<T>;
+>detect : (iterator: IteratorCallback<T, boolean>, context?: any) => ChainedObject<T>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        filter(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
->filter : (iterator: Iterator<T, boolean>, context?: any) => ChainedArray<T>
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        filter(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
+>filter : (iterator: IteratorCallback<T, boolean>, context?: any) => ChainedArray<T>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedArray : ChainedArray<T>
 >T : T
 
-        select(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
->select : (iterator: Iterator<T, boolean>, context?: any) => ChainedArray<T>
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        select(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
+>select : (iterator: IteratorCallback<T, boolean>, context?: any) => ChainedArray<T>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedArray : ChainedArray<T>
@@ -3228,43 +3228,43 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        reject(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
->reject : (iterator: Iterator<T, boolean>, context?: any) => ChainedArray<T>
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        reject(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
+>reject : (iterator: IteratorCallback<T, boolean>, context?: any) => ChainedArray<T>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedArray : ChainedArray<T>
 >T : T
 
-        every(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
->every : (iterator?: Iterator<T, boolean>, context?: any) => ChainedObject<boolean>
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        every(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+>every : (iterator?: IteratorCallback<T, boolean>, context?: any) => ChainedObject<boolean>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
 
-        all(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
->all : (iterator?: Iterator<T, boolean>, context?: any) => ChainedObject<boolean>
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        all(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+>all : (iterator?: IteratorCallback<T, boolean>, context?: any) => ChainedObject<boolean>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
 
-        some(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
->some : (iterator?: Iterator<T, boolean>, context?: any) => ChainedObject<boolean>
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        some(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+>some : (iterator?: IteratorCallback<T, boolean>, context?: any) => ChainedObject<boolean>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
 
-        any(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
->any : (iterator?: Iterator<T, boolean>, context?: any) => ChainedObject<boolean>
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        any(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+>any : (iterator?: IteratorCallback<T, boolean>, context?: any) => ChainedObject<boolean>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
@@ -3292,63 +3292,63 @@ module Underscore {
 >propertyName : string
 >ChainedArray : ChainedArray<T>
 
-        max(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
->max : (iterator?: Iterator<T, any>, context?: any) => ChainedObject<T>
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        max(iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<T>;
+>max : (iterator?: IteratorCallback<T, any>, context?: any) => ChainedObject<T>
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        min(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
->min : (iterator?: Iterator<T, any>, context?: any) => ChainedObject<T>
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        min(iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<T>;
+>min : (iterator?: IteratorCallback<T, any>, context?: any) => ChainedObject<T>
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        sortBy(iterator: Iterator<T, any>, context?: any): ChainedArray<T>;
->sortBy : { (iterator: Iterator<T, any>, context?: any): ChainedArray<T>; (propertyName: string): ChainedArray<T>; }
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        sortBy(iterator: IteratorCallback<T, any>, context?: any): ChainedArray<T>;
+>sortBy : { (iterator: IteratorCallback<T, any>, context?: any): ChainedArray<T>; (propertyName: string): ChainedArray<T>; }
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedArray : ChainedArray<T>
 >T : T
 
         sortBy(propertyName: string): ChainedArray<T>;
->sortBy : { (iterator: Iterator<T, any>, context?: any): ChainedArray<T>; (propertyName: string): ChainedArray<T>; }
+>sortBy : { (iterator: IteratorCallback<T, any>, context?: any): ChainedArray<T>; (propertyName: string): ChainedArray<T>; }
 >propertyName : string
 >ChainedArray : ChainedArray<T>
 >T : T
 
         // Should return ChainedDictionary<T[]>, but expansive recursion not allowed
-        groupBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<any[]>;
->groupBy : { (iterator?: Iterator<T, any>, context?: any): ChainedDictionary<any[]>; (propertyName: string): ChainedDictionary<any[]>; }
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        groupBy(iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<any[]>;
+>groupBy : { (iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<any[]>; (propertyName: string): ChainedDictionary<any[]>; }
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedDictionary : ChainedDictionary<T>
 
         groupBy(propertyName: string): ChainedDictionary<any[]>;
->groupBy : { (iterator?: Iterator<T, any>, context?: any): ChainedDictionary<any[]>; (propertyName: string): ChainedDictionary<any[]>; }
+>groupBy : { (iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<any[]>; (propertyName: string): ChainedDictionary<any[]>; }
 >propertyName : string
 >ChainedDictionary : ChainedDictionary<T>
 
-        countBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<number>;
->countBy : { (iterator?: Iterator<T, any>, context?: any): ChainedDictionary<number>; (propertyName: string): ChainedDictionary<number>; }
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        countBy(iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<number>;
+>countBy : { (iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<number>; (propertyName: string): ChainedDictionary<number>; }
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedDictionary : ChainedDictionary<T>
 
         countBy(propertyName: string): ChainedDictionary<number>;
->countBy : { (iterator?: Iterator<T, any>, context?: any): ChainedDictionary<number>; (propertyName: string): ChainedDictionary<number>; }
+>countBy : { (iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<number>; (propertyName: string): ChainedDictionary<number>; }
 >propertyName : string
 >ChainedDictionary : ChainedDictionary<T>
 
@@ -3468,17 +3468,17 @@ module Underscore {
 >T : T
 
         uniq(isSorted?: boolean): ChainedArray<T>;
->uniq : { (isSorted?: boolean): ChainedArray<T>; <U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): ChainedArray<U>; }
+>uniq : { (isSorted?: boolean): ChainedArray<T>; <U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>; }
 >isSorted : boolean
 >ChainedArray : ChainedArray<T>
 >T : T
 
-        uniq<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
->uniq : { (isSorted?: boolean): ChainedArray<T>; <U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): ChainedArray<U>; }
+        uniq<U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
+>uniq : { (isSorted?: boolean): ChainedArray<T>; <U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>; }
 >U : U
 >isSorted : boolean
->iterator : Iterator<T, U>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, U>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >U : U
 >context : any
@@ -3486,17 +3486,17 @@ module Underscore {
 >U : U
 
         unique(isSorted?: boolean): ChainedArray<T>;
->unique : { (isSorted?: boolean): ChainedArray<T>; <U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): ChainedArray<U>; }
+>unique : { (isSorted?: boolean): ChainedArray<T>; <U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>; }
 >isSorted : boolean
 >ChainedArray : ChainedArray<T>
 >T : T
 
-        unique<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
->unique : { (isSorted?: boolean): ChainedArray<T>; <U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): ChainedArray<U>; }
+        unique<U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
+>unique : { (isSorted?: boolean): ChainedArray<T>; <U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>; }
 >U : U
 >isSorted : boolean
->iterator : Iterator<T, U>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, U>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >U : U
 >context : any
@@ -3532,18 +3532,18 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 
         sortedIndex(obj: T, propertyName: string): ChainedObject<number>;
->sortedIndex : { (obj: T, propertyName: string): ChainedObject<number>; (obj: T, iterator?: Iterator<T, any>, context?: any): ChainedObject<number>; }
+>sortedIndex : { (obj: T, propertyName: string): ChainedObject<number>; (obj: T, iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<number>; }
 >obj : T
 >T : T
 >propertyName : string
 >ChainedObject : ChainedObject<T>
 
-        sortedIndex(obj: T, iterator?: Iterator<T, any>, context?: any): ChainedObject<number>;
->sortedIndex : { (obj: T, propertyName: string): ChainedObject<number>; (obj: T, iterator?: Iterator<T, any>, context?: any): ChainedObject<number>; }
+        sortedIndex(obj: T, iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<number>;
+>sortedIndex : { (obj: T, propertyName: string): ChainedObject<number>; (obj: T, iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<number>; }
 >obj : T
 >T : T
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
@@ -3666,48 +3666,48 @@ module Underscore {
 >Dictionary : Dictionary<T>
 >T : T
 
-        each(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
->each : (iterator: Iterator<T, void>, context?: any) => ChainedObject<void>
->iterator : Iterator<T, void>
->Iterator : Iterator<T, U>
+        each(iterator: IteratorCallback<T, void>, context?: any): ChainedObject<void>;
+>each : (iterator: IteratorCallback<T, void>, context?: any) => ChainedObject<void>
+>iterator : IteratorCallback<T, void>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
 
-        forEach(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
->forEach : (iterator: Iterator<T, void>, context?: any) => ChainedObject<void>
->iterator : Iterator<T, void>
->Iterator : Iterator<T, U>
+        forEach(iterator: IteratorCallback<T, void>, context?: any): ChainedObject<void>;
+>forEach : (iterator: IteratorCallback<T, void>, context?: any) => ChainedObject<void>
+>iterator : IteratorCallback<T, void>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
 
-        map<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
->map : <U>(iterator: Iterator<T, U>, context?: any) => ChainedArray<U>
+        map<U>(iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
+>map : <U>(iterator: IteratorCallback<T, U>, context?: any) => ChainedArray<U>
 >U : U
->iterator : Iterator<T, U>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, U>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >U : U
 >context : any
 >ChainedArray : ChainedArray<T>
 >U : U
 
-        collect<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
->collect : <U>(iterator: Iterator<T, U>, context?: any) => ChainedArray<U>
+        collect<U>(iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
+>collect : <U>(iterator: IteratorCallback<T, U>, context?: any) => ChainedArray<U>
 >U : U
->iterator : Iterator<T, U>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, U>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >U : U
 >context : any
 >ChainedArray : ChainedArray<T>
 >U : U
 
-        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->reduce : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        reduce(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>reduce : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -3716,11 +3716,11 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->reduce : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+        reduce<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>reduce : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -3729,10 +3729,10 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >U : U
 
-        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->foldl : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        foldl(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>foldl : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -3741,11 +3741,11 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->foldl : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+        foldl<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>foldl : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -3754,10 +3754,10 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >U : U
 
-        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->inject : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        inject(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>inject : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -3766,11 +3766,11 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->inject : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+        inject<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>inject : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -3779,10 +3779,10 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >U : U
 
-        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->reduceRight : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        reduceRight(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>reduceRight : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -3791,11 +3791,11 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->reduceRight : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+        reduceRight<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>reduceRight : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -3804,10 +3804,10 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >U : U
 
-        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
->foldr : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+        foldr(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+>foldr : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -3816,11 +3816,11 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
->foldr : { (iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
+        foldr<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+>foldr : { (iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>; <U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>; }
 >U : U
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -3829,37 +3829,37 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >U : U
 
-        find(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
->find : (iterator: Iterator<T, boolean>, context?: any) => ChainedObject<T>
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        find(iterator: IteratorCallback<T, boolean>, context?: any): ChainedObject<T>;
+>find : (iterator: IteratorCallback<T, boolean>, context?: any) => ChainedObject<T>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        detect(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
->detect : (iterator: Iterator<T, boolean>, context?: any) => ChainedObject<T>
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        detect(iterator: IteratorCallback<T, boolean>, context?: any): ChainedObject<T>;
+>detect : (iterator: IteratorCallback<T, boolean>, context?: any) => ChainedObject<T>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        filter(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
->filter : (iterator: Iterator<T, boolean>, context?: any) => ChainedArray<T>
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        filter(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
+>filter : (iterator: IteratorCallback<T, boolean>, context?: any) => ChainedArray<T>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedArray : ChainedArray<T>
 >T : T
 
-        select(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
->select : (iterator: Iterator<T, boolean>, context?: any) => ChainedArray<T>
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        select(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
+>select : (iterator: IteratorCallback<T, boolean>, context?: any) => ChainedArray<T>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedArray : ChainedArray<T>
@@ -3879,43 +3879,43 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        reject(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
->reject : (iterator: Iterator<T, boolean>, context?: any) => ChainedArray<T>
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        reject(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
+>reject : (iterator: IteratorCallback<T, boolean>, context?: any) => ChainedArray<T>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedArray : ChainedArray<T>
 >T : T
 
-        every(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
->every : (iterator?: Iterator<T, boolean>, context?: any) => ChainedObject<boolean>
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        every(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+>every : (iterator?: IteratorCallback<T, boolean>, context?: any) => ChainedObject<boolean>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
 
-        all(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
->all : (iterator?: Iterator<T, boolean>, context?: any) => ChainedObject<boolean>
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        all(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+>all : (iterator?: IteratorCallback<T, boolean>, context?: any) => ChainedObject<boolean>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
 
-        some(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
->some : (iterator?: Iterator<T, boolean>, context?: any) => ChainedObject<boolean>
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        some(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+>some : (iterator?: IteratorCallback<T, boolean>, context?: any) => ChainedObject<boolean>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
 
-        any(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
->any : (iterator?: Iterator<T, boolean>, context?: any) => ChainedObject<boolean>
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+        any(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+>any : (iterator?: IteratorCallback<T, boolean>, context?: any) => ChainedObject<boolean>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
@@ -3943,63 +3943,63 @@ module Underscore {
 >propertyName : string
 >ChainedArray : ChainedArray<T>
 
-        max(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
->max : (iterator?: Iterator<T, any>, context?: any) => ChainedObject<T>
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        max(iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<T>;
+>max : (iterator?: IteratorCallback<T, any>, context?: any) => ChainedObject<T>
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        min(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
->min : (iterator?: Iterator<T, any>, context?: any) => ChainedObject<T>
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        min(iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<T>;
+>min : (iterator?: IteratorCallback<T, any>, context?: any) => ChainedObject<T>
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        sortBy(iterator: Iterator<T, any>, context?: any): ChainedArray<T>;
->sortBy : { (iterator: Iterator<T, any>, context?: any): ChainedArray<T>; (propertyName: string): ChainedArray<T>; }
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        sortBy(iterator: IteratorCallback<T, any>, context?: any): ChainedArray<T>;
+>sortBy : { (iterator: IteratorCallback<T, any>, context?: any): ChainedArray<T>; (propertyName: string): ChainedArray<T>; }
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedArray : ChainedArray<T>
 >T : T
 
         sortBy(propertyName: string): ChainedArray<T>;
->sortBy : { (iterator: Iterator<T, any>, context?: any): ChainedArray<T>; (propertyName: string): ChainedArray<T>; }
+>sortBy : { (iterator: IteratorCallback<T, any>, context?: any): ChainedArray<T>; (propertyName: string): ChainedArray<T>; }
 >propertyName : string
 >ChainedArray : ChainedArray<T>
 >T : T
 
         // Should return ChainedDictionary<T[]>, but expansive recursion not allowed
-        groupBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<any[]>;
->groupBy : { (iterator?: Iterator<T, any>, context?: any): ChainedDictionary<any[]>; (propertyName: string): ChainedDictionary<any[]>; }
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        groupBy(iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<any[]>;
+>groupBy : { (iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<any[]>; (propertyName: string): ChainedDictionary<any[]>; }
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedDictionary : ChainedDictionary<T>
 
         groupBy(propertyName: string): ChainedDictionary<any[]>;
->groupBy : { (iterator?: Iterator<T, any>, context?: any): ChainedDictionary<any[]>; (propertyName: string): ChainedDictionary<any[]>; }
+>groupBy : { (iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<any[]>; (propertyName: string): ChainedDictionary<any[]>; }
 >propertyName : string
 >ChainedDictionary : ChainedDictionary<T>
 
-        countBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<number>;
->countBy : { (iterator?: Iterator<T, any>, context?: any): ChainedDictionary<number>; (propertyName: string): ChainedDictionary<number>; }
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+        countBy(iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<number>;
+>countBy : { (iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<number>; (propertyName: string): ChainedDictionary<number>; }
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >ChainedDictionary : ChainedDictionary<T>
 
         countBy(propertyName: string): ChainedDictionary<number>;
->countBy : { (iterator?: Iterator<T, any>, context?: any): ChainedDictionary<number>; (propertyName: string): ChainedDictionary<number>; }
+>countBy : { (iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<number>; (propertyName: string): ChainedDictionary<number>; }
 >propertyName : string
 >ChainedDictionary : ChainedDictionary<T>
 
@@ -4134,109 +4134,109 @@ module Underscore {
 >ChainedObject : ChainedObject<T>
 >T : T
 
-        each<T>(list: T[], iterator: Iterator<T, void>, context?: any): void;
->each : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }
+        each<T>(list: T[], iterator: IteratorCallback<T, void>, context?: any): void;
+>each : { <T>(list: T[], iterator: IteratorCallback<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, void>, context?: any): void; }
 >T : T
 >list : T[]
 >T : T
->iterator : Iterator<T, void>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, void>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        each<T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void;
->each : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }
+        each<T>(list: Dictionary<T>, iterator: IteratorCallback<T, void>, context?: any): void;
+>each : { <T>(list: T[], iterator: IteratorCallback<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, void>, context?: any): void; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Iterator<T, void>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, void>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        forEach<T>(list: T[], iterator: Iterator<T, void>, context?: any): void;
->forEach : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }
+        forEach<T>(list: T[], iterator: IteratorCallback<T, void>, context?: any): void;
+>forEach : { <T>(list: T[], iterator: IteratorCallback<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, void>, context?: any): void; }
 >T : T
 >list : T[]
 >T : T
->iterator : Iterator<T, void>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, void>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        forEach<T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void;
->forEach : { <T>(list: T[], iterator: Iterator<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void; }
+        forEach<T>(list: Dictionary<T>, iterator: IteratorCallback<T, void>, context?: any): void;
+>forEach : { <T>(list: T[], iterator: IteratorCallback<T, void>, context?: any): void; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, void>, context?: any): void; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Iterator<T, void>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, void>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        map<T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[];
->map : { <T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[]; }
+        map<T, U>(list: T[], iterator: IteratorCallback<T, U>, context?: any): U[];
+>map : { <T, U>(list: T[], iterator: IteratorCallback<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: IteratorCallback<T, U>, context?: any): U[]; }
 >T : T
 >U : U
 >list : T[]
 >T : T
->iterator : Iterator<T, U>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, U>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >U : U
 >context : any
 >U : U
 
-        map<T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[];
->map : { <T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[]; }
+        map<T, U>(list: Dictionary<T>, iterator: IteratorCallback<T, U>, context?: any): U[];
+>map : { <T, U>(list: T[], iterator: IteratorCallback<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: IteratorCallback<T, U>, context?: any): U[]; }
 >T : T
 >U : U
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Iterator<T, U>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, U>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >U : U
 >context : any
 >U : U
 
-        collect<T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[];
->collect : { <T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[]; }
+        collect<T, U>(list: T[], iterator: IteratorCallback<T, U>, context?: any): U[];
+>collect : { <T, U>(list: T[], iterator: IteratorCallback<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: IteratorCallback<T, U>, context?: any): U[]; }
 >T : T
 >U : U
 >list : T[]
 >T : T
->iterator : Iterator<T, U>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, U>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >U : U
 >context : any
 >U : U
 
-        collect<T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[];
->collect : { <T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[]; }
+        collect<T, U>(list: Dictionary<T>, iterator: IteratorCallback<T, U>, context?: any): U[];
+>collect : { <T, U>(list: T[], iterator: IteratorCallback<T, U>, context?: any): U[]; <T, U>(list: Dictionary<T>, iterator: IteratorCallback<T, U>, context?: any): U[]; }
 >T : T
 >U : U
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Iterator<T, U>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, U>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >U : U
 >context : any
 >U : U
 
-        reduce<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->reduce : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        reduce<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>reduce : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >list : T[]
 >T : T
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -4244,14 +4244,14 @@ module Underscore {
 >context : any
 >T : T
 
-        reduce<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->reduce : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        reduce<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>reduce : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >U : U
 >list : T[]
 >T : T
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -4259,14 +4259,14 @@ module Underscore {
 >context : any
 >U : U
 
-        reduce<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->reduce : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        reduce<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>reduce : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -4274,15 +4274,15 @@ module Underscore {
 >context : any
 >T : T
 
-        reduce<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->reduce : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        reduce<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>reduce : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >U : U
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -4290,13 +4290,13 @@ module Underscore {
 >context : any
 >U : U
 
-        foldl<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->foldl : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        foldl<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>foldl : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >list : T[]
 >T : T
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -4304,14 +4304,14 @@ module Underscore {
 >context : any
 >T : T
 
-        foldl<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->foldl : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        foldl<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>foldl : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >U : U
 >list : T[]
 >T : T
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -4319,14 +4319,14 @@ module Underscore {
 >context : any
 >U : U
 
-        foldl<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->foldl : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        foldl<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>foldl : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -4334,15 +4334,15 @@ module Underscore {
 >context : any
 >T : T
 
-        foldl<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->foldl : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        foldl<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>foldl : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >U : U
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -4350,13 +4350,13 @@ module Underscore {
 >context : any
 >U : U
 
-        inject<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->inject : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        inject<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>inject : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >list : T[]
 >T : T
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -4364,14 +4364,14 @@ module Underscore {
 >context : any
 >T : T
 
-        inject<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->inject : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        inject<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>inject : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >U : U
 >list : T[]
 >T : T
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -4379,14 +4379,14 @@ module Underscore {
 >context : any
 >U : U
 
-        inject<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->inject : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        inject<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>inject : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -4394,15 +4394,15 @@ module Underscore {
 >context : any
 >T : T
 
-        inject<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->inject : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        inject<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>inject : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >U : U
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -4410,13 +4410,13 @@ module Underscore {
 >context : any
 >U : U
 
-        reduceRight<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->reduceRight : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        reduceRight<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>reduceRight : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >list : T[]
 >T : T
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -4424,14 +4424,14 @@ module Underscore {
 >context : any
 >T : T
 
-        reduceRight<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->reduceRight : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        reduceRight<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>reduceRight : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >U : U
 >list : T[]
 >T : T
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -4439,14 +4439,14 @@ module Underscore {
 >context : any
 >U : U
 
-        reduceRight<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->reduceRight : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        reduceRight<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>reduceRight : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -4454,15 +4454,15 @@ module Underscore {
 >context : any
 >T : T
 
-        reduceRight<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->reduceRight : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        reduceRight<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>reduceRight : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >U : U
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -4470,13 +4470,13 @@ module Underscore {
 >context : any
 >U : U
 
-        foldr<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->foldr : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        foldr<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>foldr : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >list : T[]
 >T : T
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -4484,14 +4484,14 @@ module Underscore {
 >context : any
 >T : T
 
-        foldr<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->foldr : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        foldr<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>foldr : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >U : U
 >list : T[]
 >T : T
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -4499,14 +4499,14 @@ module Underscore {
 >context : any
 >U : U
 
-        foldr<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
->foldr : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        foldr<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+>foldr : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Reducer<T, T>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, T>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >T : T
 >initialValue : T
@@ -4514,15 +4514,15 @@ module Underscore {
 >context : any
 >T : T
 
-        foldr<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
->foldr : { <T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U; }
+        foldr<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+>foldr : { <T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; <T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T; <T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U; }
 >T : T
 >U : U
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Reducer<T, U>
->Reducer : Reducer<T, U>
+>iterator : ReducerCallback<T, U>
+>ReducerCallback : ReducerCallback<T, U>
 >T : T
 >U : U
 >initialValue : U
@@ -4530,94 +4530,94 @@ module Underscore {
 >context : any
 >U : U
 
-        find<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T;
->find : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T; }
+        find<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T;
+>find : { <T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T; }
 >T : T
 >list : T[]
 >T : T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        find<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T;
->find : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T; }
+        find<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T;
+>find : { <T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        detect<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T;
->detect : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T; }
+        detect<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T;
+>detect : { <T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T; }
 >T : T
 >list : T[]
 >T : T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        detect<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T;
->detect : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T; }
+        detect<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T;
+>detect : { <T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        filter<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[];
->filter : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }
+        filter<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>filter : { <T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[]; }
 >T : T
 >list : T[]
 >T : T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        filter<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[];
->filter : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }
+        filter<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>filter : { <T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[]; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        select<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[];
->select : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }
+        select<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>select : { <T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[]; }
 >T : T
 >list : T[]
 >T : T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        select<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[];
->select : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }
+        select<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>select : { <T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[]; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
@@ -4660,110 +4660,110 @@ module Underscore {
 >Object : Object
 >T : T
 
-        reject<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[];
->reject : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }
+        reject<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>reject : { <T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[]; }
 >T : T
 >list : T[]
 >T : T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        reject<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[];
->reject : { <T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[]; }
+        reject<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[];
+>reject : { <T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[]; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        every<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
->every : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
+        every<T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>every : { <T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean; }
 >T : T
 >list : T[]
 >T : T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        every<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
->every : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
+        every<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>every : { <T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        all<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
->all : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
+        all<T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>all : { <T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean; }
 >T : T
 >list : T[]
 >T : T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        all<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
->all : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
+        all<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>all : { <T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        some<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
->some : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
+        some<T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>some : { <T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean; }
 >T : T
 >list : T[]
 >T : T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        some<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
->some : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
+        some<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>some : { <T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        any<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
->any : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
+        any<T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>any : { <T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean; }
 >T : T
 >list : T[]
 >T : T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
-        any<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
->any : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
+        any<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+>any : { <T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Iterator<T, boolean>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, boolean>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
@@ -4825,77 +4825,77 @@ module Underscore {
 >Dictionary : Dictionary<T>
 >propertyName : string
 
-        max<T>(list: T[], iterator?: Iterator<T, any>, context?: any): T;
->max : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T; }
+        max<T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): T;
+>max : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): T; }
 >T : T
 >list : T[]
 >T : T
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        max<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T;
->max : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T; }
+        max<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): T;
+>max : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): T; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        min<T>(list: T[], iterator?: Iterator<T, any>, context?: any): T;
->min : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T; }
+        min<T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): T;
+>min : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): T; }
 >T : T
 >list : T[]
 >T : T
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        min<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T;
->min : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T; }
+        min<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): T;
+>min : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): T; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): T; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        sortBy<T>(list: T[], iterator: Iterator<T, any>, context?: any): T[];
->sortBy : { <T>(list: T[], iterator: Iterator<T, any>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, any>, context?: any): T[]; <T>(list: T[], propertyName: string): T[]; <T>(list: Dictionary<T>, propertyName: string): T[]; }
+        sortBy<T>(list: T[], iterator: IteratorCallback<T, any>, context?: any): T[];
+>sortBy : { <T>(list: T[], iterator: IteratorCallback<T, any>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, any>, context?: any): T[]; <T>(list: T[], propertyName: string): T[]; <T>(list: Dictionary<T>, propertyName: string): T[]; }
 >T : T
 >list : T[]
 >T : T
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
-        sortBy<T>(list: Dictionary<T>, iterator: Iterator<T, any>, context?: any): T[];
->sortBy : { <T>(list: T[], iterator: Iterator<T, any>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, any>, context?: any): T[]; <T>(list: T[], propertyName: string): T[]; <T>(list: Dictionary<T>, propertyName: string): T[]; }
+        sortBy<T>(list: Dictionary<T>, iterator: IteratorCallback<T, any>, context?: any): T[];
+>sortBy : { <T>(list: T[], iterator: IteratorCallback<T, any>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, any>, context?: any): T[]; <T>(list: T[], propertyName: string): T[]; <T>(list: Dictionary<T>, propertyName: string): T[]; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >T : T
 
         sortBy<T>(list: T[], propertyName: string): T[];
->sortBy : { <T>(list: T[], iterator: Iterator<T, any>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, any>, context?: any): T[]; <T>(list: T[], propertyName: string): T[]; <T>(list: Dictionary<T>, propertyName: string): T[]; }
+>sortBy : { <T>(list: T[], iterator: IteratorCallback<T, any>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, any>, context?: any): T[]; <T>(list: T[], propertyName: string): T[]; <T>(list: Dictionary<T>, propertyName: string): T[]; }
 >T : T
 >list : T[]
 >T : T
@@ -4903,7 +4903,7 @@ module Underscore {
 >T : T
 
         sortBy<T>(list: Dictionary<T>, propertyName: string): T[];
->sortBy : { <T>(list: T[], iterator: Iterator<T, any>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: Iterator<T, any>, context?: any): T[]; <T>(list: T[], propertyName: string): T[]; <T>(list: Dictionary<T>, propertyName: string): T[]; }
+>sortBy : { <T>(list: T[], iterator: IteratorCallback<T, any>, context?: any): T[]; <T>(list: Dictionary<T>, iterator: IteratorCallback<T, any>, context?: any): T[]; <T>(list: T[], propertyName: string): T[]; <T>(list: Dictionary<T>, propertyName: string): T[]; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
@@ -4911,33 +4911,33 @@ module Underscore {
 >propertyName : string
 >T : T
 
-        groupBy<T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
->groupBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }
+        groupBy<T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>;
+>groupBy : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }
 >T : T
 >list : T[]
 >T : T
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >Dictionary : Dictionary<T>
 >T : T
 
-        groupBy<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
->groupBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }
+        groupBy<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>;
+>groupBy : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >Dictionary : Dictionary<T>
 >T : T
 
         groupBy<T>(list: T[], propertyName: string): Dictionary<T[]>;
->groupBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }
+>groupBy : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }
 >T : T
 >list : T[]
 >T : T
@@ -4946,7 +4946,7 @@ module Underscore {
 >T : T
 
         groupBy<T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>;
->groupBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }
+>groupBy : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>; <T>(list: T[], propertyName: string): Dictionary<T[]>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
@@ -4955,31 +4955,31 @@ module Underscore {
 >Dictionary : Dictionary<T>
 >T : T
 
-        countBy<T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
->countBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: T[], propertyName: string): Dictionary<number>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<number>; }
+        countBy<T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>;
+>countBy : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>; <T>(list: T[], propertyName: string): Dictionary<number>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<number>; }
 >T : T
 >list : T[]
 >T : T
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >Dictionary : Dictionary<T>
 
-        countBy<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
->countBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: T[], propertyName: string): Dictionary<number>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<number>; }
+        countBy<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>;
+>countBy : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>; <T>(list: T[], propertyName: string): Dictionary<number>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<number>; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
 >T : T
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 >Dictionary : Dictionary<T>
 
         countBy<T>(list: T[], propertyName: string): Dictionary<number>;
->countBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: T[], propertyName: string): Dictionary<number>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<number>; }
+>countBy : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>; <T>(list: T[], propertyName: string): Dictionary<number>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<number>; }
 >T : T
 >list : T[]
 >T : T
@@ -4987,7 +4987,7 @@ module Underscore {
 >Dictionary : Dictionary<T>
 
         countBy<T>(list: Dictionary<T>, propertyName: string): Dictionary<number>;
->countBy : { <T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<number>; <T>(list: T[], propertyName: string): Dictionary<number>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<number>; }
+>countBy : { <T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>; <T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>; <T>(list: T[], propertyName: string): Dictionary<number>; <T>(list: Dictionary<T>, propertyName: string): Dictionary<number>; }
 >T : T
 >list : Dictionary<T>
 >Dictionary : Dictionary<T>
@@ -5175,44 +5175,44 @@ module Underscore {
 >T : T
 
         uniq<T>(list: T[], isSorted?: boolean): T[];
->uniq : { <T>(list: T[], isSorted?: boolean): T[]; <T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }
+>uniq : { <T>(list: T[], isSorted?: boolean): T[]; <T, U>(list: T[], isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[]; }
 >T : T
 >list : T[]
 >T : T
 >isSorted : boolean
 >T : T
 
-        uniq<T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
->uniq : { <T>(list: T[], isSorted?: boolean): T[]; <T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }
+        uniq<T, U>(list: T[], isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[];
+>uniq : { <T>(list: T[], isSorted?: boolean): T[]; <T, U>(list: T[], isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[]; }
 >T : T
 >U : U
 >list : T[]
 >T : T
 >isSorted : boolean
->iterator : Iterator<T, U>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, U>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >U : U
 >context : any
 >U : U
 
         unique<T>(list: T[], isSorted?: boolean): T[];
->unique : { <T>(list: T[], isSorted?: boolean): T[]; <T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }
+>unique : { <T>(list: T[], isSorted?: boolean): T[]; <T, U>(list: T[], isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[]; }
 >T : T
 >list : T[]
 >T : T
 >isSorted : boolean
 >T : T
 
-        unique<T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
->unique : { <T>(list: T[], isSorted?: boolean): T[]; <T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[]; }
+        unique<T, U>(list: T[], isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[];
+>unique : { <T>(list: T[], isSorted?: boolean): T[]; <T, U>(list: T[], isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[]; }
 >T : T
 >U : U
 >list : T[]
 >T : T
 >isSorted : boolean
->iterator : Iterator<T, U>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, U>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >U : U
 >context : any
@@ -5298,7 +5298,7 @@ module Underscore {
 >fromIndex : number
 
         sortedIndex<T>(list: T[], obj: T, propertyName: string): number;
->sortedIndex : { <T>(list: T[], obj: T, propertyName: string): number; <T>(list: T[], obj: T, iterator?: Iterator<T, any>, context?: any): number; }
+>sortedIndex : { <T>(list: T[], obj: T, propertyName: string): number; <T>(list: T[], obj: T, iterator?: IteratorCallback<T, any>, context?: any): number; }
 >T : T
 >list : T[]
 >T : T
@@ -5306,15 +5306,15 @@ module Underscore {
 >T : T
 >propertyName : string
 
-        sortedIndex<T>(list: T[], obj: T, iterator?: Iterator<T, any>, context?: any): number;
->sortedIndex : { <T>(list: T[], obj: T, propertyName: string): number; <T>(list: T[], obj: T, iterator?: Iterator<T, any>, context?: any): number; }
+        sortedIndex<T>(list: T[], obj: T, iterator?: IteratorCallback<T, any>, context?: any): number;
+>sortedIndex : { <T>(list: T[], obj: T, propertyName: string): number; <T>(list: T[], obj: T, iterator?: IteratorCallback<T, any>, context?: any): number; }
 >T : T
 >list : T[]
 >T : T
 >obj : T
 >T : T
->iterator : Iterator<T, any>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<T, any>
+>IteratorCallback : IteratorCallback<T, U>
 >T : T
 >context : any
 
@@ -5594,12 +5594,12 @@ module Underscore {
 >T : T
 >T : T
 
-        times<U>(n: number, iterator: Iterator<number, U>, context?: any): U[];
->times : <U>(n: number, iterator: Iterator<number, U>, context?: any) => U[]
+        times<U>(n: number, iterator: IteratorCallback<number, U>, context?: any): U[];
+>times : <U>(n: number, iterator: IteratorCallback<number, U>, context?: any) => U[]
 >U : U
 >n : number
->iterator : Iterator<number, U>
->Iterator : Iterator<T, U>
+>iterator : IteratorCallback<number, U>
+>IteratorCallback : IteratorCallback<T, U>
 >U : U
 >context : any
 >U : U
diff --git a/tests/baselines/reference/yieldExpression1.errors.txt b/tests/baselines/reference/yieldExpression1.errors.txt
deleted file mode 100644
index 2ab6f60fb76..00000000000
--- a/tests/baselines/reference/yieldExpression1.errors.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-tests/cases/compiler/yieldExpression1.ts(1,9): error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-
-
-==== tests/cases/compiler/yieldExpression1.ts (1 errors) ====
-    function* foo() {
-            ~
-!!! error TS1220: Generators are only available when targeting ECMAScript 2015 or higher.
-        yield
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/yieldExpression1.js b/tests/baselines/reference/yieldExpression1.js
index e4d5748a761..c2a53bce3f9 100644
--- a/tests/baselines/reference/yieldExpression1.js
+++ b/tests/baselines/reference/yieldExpression1.js
@@ -4,6 +4,58 @@ function* foo() {
 }
 
 //// [yieldExpression1.js]
-function* foo() {
-    yield;
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (sent[0] === 1) throw sent[1]; return sent[1]; }, trys: [], stack: [] }, sent, star, f;
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (1) {
+            if (_.done) switch (op[0]) {
+                case 0: return { value: void 0, done: true };
+                case 1: case 6: throw op[1];
+                case 2: return { value: op[1], done: true };
+            }
+            try {
+                f = 1;
+                if (star) {
+                    var v = star[["next", "throw", "return"][op[0]]];
+                    if (v && !(v = v.call(star, op[1])).done) return v;
+                    if (v) op = [0, v.value];
+                    star = void 0; continue;
+                }
+                switch (op[0]) {
+                    case 0: case 1: sent = op; break;
+                    case 4: return _.label++, { value: op[1], done: false };
+                    case 5: _.label++, star = op[1], op = [0]; continue;
+                    case 7: op = _.stack.pop(), _.trys.pop(); continue;
+                    default:
+                        var r = _.trys.length > 0 && _.trys[_.trys.length - 1];
+                        if (!r && (op[0] === 6 || op[0] === 2)) { _.done = 1; continue; }
+                        if (op[0] === 3 && (!r || (op[1] > r[0] && op[1] < r[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < r[1]) { _.label = r[1], sent = op; break; }
+                        if (r && _.label < r[2]) { _.label = r[2], _.stack.push(op); break; }
+                        if (r[2]) { _.stack.pop(); }
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) { op = [6, e], star = void 0; }
+            finally { f = 0, sent = v = void 0; }
+        }
+    }
+    return {
+        next: function (v) { return step([0, v]); },
+        "throw": function (v) { return step([1, v]); },
+        "return": function (v) { return step([2, v]); }
+    };
+};
+function foo() {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    });
 }
diff --git a/tests/baselines/reference/yieldExpression1.symbols b/tests/baselines/reference/yieldExpression1.symbols
new file mode 100644
index 00000000000..7ca46788047
--- /dev/null
+++ b/tests/baselines/reference/yieldExpression1.symbols
@@ -0,0 +1,6 @@
+=== tests/cases/compiler/yieldExpression1.ts ===
+function* foo() {
+>foo : Symbol(foo, Decl(yieldExpression1.ts, 0, 0))
+
+    yield
+}
diff --git a/tests/baselines/reference/yieldExpression1.types b/tests/baselines/reference/yieldExpression1.types
new file mode 100644
index 00000000000..70632a11aa1
--- /dev/null
+++ b/tests/baselines/reference/yieldExpression1.types
@@ -0,0 +1,7 @@
+=== tests/cases/compiler/yieldExpression1.ts ===
+function* foo() {
+>foo : () => Iterator<any>
+
+    yield
+>yield : any
+}
diff --git a/tests/cases/compiler/underscoreTest1.ts b/tests/cases/compiler/underscoreTest1.ts
index 411bcc58d5f..4335b588e49 100644
--- a/tests/cases/compiler/underscoreTest1.ts
+++ b/tests/cases/compiler/underscoreTest1.ts
@@ -3,11 +3,11 @@ interface Dictionary<T> {
     [x: string]: T;
 }
 
-interface Iterator<T, U> {
+interface IteratorCallback<T, U> {
     (value: T, index: any, list: any): U;
 }
 
-interface Reducer<T, U> {
+interface ReducerCallback<T, U> {
     (accumulator: U, value: T, index: any, list: any): U;
 }
 
@@ -79,42 +79,42 @@ module Underscore {
     }
 
     export interface WrappedArray<T> extends WrappedObject<Array<T>> {
-        each(iterator: Iterator<T, void>, context?: any): void;
-        forEach(iterator: Iterator<T, void>, context?: any): void;
-        map<U>(iterator: Iterator<T, U>, context?: any): U[];
-        collect<U>(iterator: Iterator<T, U>, context?: any): U[];
-        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        find(iterator: Iterator<T, boolean>, context?: any): T;
-        detect(iterator: Iterator<T, boolean>, context?: any): T;
-        filter(iterator: Iterator<T, boolean>, context?: any): T[];
-        select(iterator: Iterator<T, boolean>, context?: any): T[];
+        each(iterator: IteratorCallback<T, void>, context?: any): void;
+        forEach(iterator: IteratorCallback<T, void>, context?: any): void;
+        map<U>(iterator: IteratorCallback<T, U>, context?: any): U[];
+        collect<U>(iterator: IteratorCallback<T, U>, context?: any): U[];
+        reduce(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        reduce<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        foldl(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        foldl<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        inject(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        inject<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        reduceRight(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        reduceRight<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        foldr(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        foldr<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        find(iterator: IteratorCallback<T, boolean>, context?: any): T;
+        detect(iterator: IteratorCallback<T, boolean>, context?: any): T;
+        filter(iterator: IteratorCallback<T, boolean>, context?: any): T[];
+        select(iterator: IteratorCallback<T, boolean>, context?: any): T[];
         where(properties: Object): T[];
         findWhere(properties: Object): T;
-        reject(iterator: Iterator<T, boolean>, context?: any): T[];
-        every(iterator?: Iterator<T, boolean>, context?: any): boolean;
-        all(iterator?: Iterator<T, boolean>, context?: any): boolean;
-        some(iterator?: Iterator<T, boolean>, context?: any): boolean;
-        any(iterator?: Iterator<T, boolean>, context?: any): boolean;
+        reject(iterator: IteratorCallback<T, boolean>, context?: any): T[];
+        every(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        all(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        some(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        any(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
         contains(value: T): boolean;
         include(value: T): boolean;
         invoke(methodName: string, ...args: any[]): any[];
         pluck(propertyName: string): any[];
-        max(iterator?: Iterator<T, any>, context?: any): T;
-        min(iterator?: Iterator<T, any>, context?: any): T;
-        sortBy(iterator: Iterator<T, any>, context?: any): T[];
+        max(iterator?: IteratorCallback<T, any>, context?: any): T;
+        min(iterator?: IteratorCallback<T, any>, context?: any): T;
+        sortBy(iterator: IteratorCallback<T, any>, context?: any): T[];
         sortBy(propertyName: string): T[];
-        groupBy(iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
+        groupBy(iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>;
         groupBy(propertyName: string): Dictionary<T[]>;
-        countBy(iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
+        countBy(iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>;
         countBy(propertyName: string): Dictionary<number>;
         shuffle(): T[];
         toArray(): T[];
@@ -137,16 +137,16 @@ module Underscore {
         intersection(...arrays: T[][]): T[];
         difference(...others: T[][]): T[];
         uniq(isSorted?: boolean): T[];
-        uniq<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
+        uniq<U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[];
         unique(isSorted?: boolean): T[];
-        unique<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
+        unique<U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[];
         zip(...arrays: any[][]): any[][];
         object(): any;
         object(values: any[]): any;
         indexOf(value: T, isSorted?: boolean): number;
         lastIndexOf(value: T, fromIndex?: number): number;
         sortedIndex(obj: T, propertyName: string): number;
-        sortedIndex(obj: T, iterator?: Iterator<T, any>, context?: any): number;
+        sortedIndex(obj: T, iterator?: IteratorCallback<T, any>, context?: any): number;
         // Methods from Array
         concat(...items: T[]): T[];
         join(separator?: string): string;
@@ -162,42 +162,42 @@ module Underscore {
     }
 
     export interface WrappedDictionary<T> extends WrappedObject<Dictionary<T>> {
-        each(iterator: Iterator<T, void>, context?: any): void;
-        forEach(iterator: Iterator<T, void>, context?: any): void;
-        map<U>(iterator: Iterator<T, U>, context?: any): U[];
-        collect<U>(iterator: Iterator<T, U>, context?: any): U[];
-        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        find(iterator: Iterator<T, boolean>, context?: any): T;
-        detect(iterator: Iterator<T, boolean>, context?: any): T;
-        filter(iterator: Iterator<T, boolean>, context?: any): T[];
-        select(iterator: Iterator<T, boolean>, context?: any): T[];
+        each(iterator: IteratorCallback<T, void>, context?: any): void;
+        forEach(iterator: IteratorCallback<T, void>, context?: any): void;
+        map<U>(iterator: IteratorCallback<T, U>, context?: any): U[];
+        collect<U>(iterator: IteratorCallback<T, U>, context?: any): U[];
+        reduce(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        reduce<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        foldl(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        foldl<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        inject(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        inject<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        reduceRight(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        reduceRight<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        foldr(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        foldr<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        find(iterator: IteratorCallback<T, boolean>, context?: any): T;
+        detect(iterator: IteratorCallback<T, boolean>, context?: any): T;
+        filter(iterator: IteratorCallback<T, boolean>, context?: any): T[];
+        select(iterator: IteratorCallback<T, boolean>, context?: any): T[];
         where(properties: Object): T[];
         findWhere(properties: Object): T;
-        reject(iterator: Iterator<T, boolean>, context?: any): T[];
-        every(iterator?: Iterator<T, boolean>, context?: any): boolean;
-        all(iterator?: Iterator<T, boolean>, context?: any): boolean;
-        some(iterator?: Iterator<T, boolean>, context?: any): boolean;
-        any(iterator?: Iterator<T, boolean>, context?: any): boolean;
+        reject(iterator: IteratorCallback<T, boolean>, context?: any): T[];
+        every(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        all(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        some(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        any(iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
         contains(value: T): boolean;
         include(value: T): boolean;
         invoke(methodName: string, ...args: any[]): any[];
         pluck(propertyName: string): any[];
-        max(iterator?: Iterator<T, any>, context?: any): T;
-        min(iterator?: Iterator<T, any>, context?: any): T;
-        sortBy(iterator: Iterator<T, any>, context?: any): T[];
+        max(iterator?: IteratorCallback<T, any>, context?: any): T;
+        min(iterator?: IteratorCallback<T, any>, context?: any): T;
+        sortBy(iterator: IteratorCallback<T, any>, context?: any): T[];
         sortBy(propertyName: string): T[];
-        groupBy(iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
+        groupBy(iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>;
         groupBy(propertyName: string): Dictionary<T[]>;
-        countBy(iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
+        countBy(iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>;
         countBy(propertyName: string): Dictionary<number>;
         shuffle(): T[];
         toArray(): T[];
@@ -238,43 +238,43 @@ module Underscore {
     }
 
     export interface ChainedArray<T> extends ChainedObject<Array<T>> {
-        each(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
-        forEach(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
-        map<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
-        collect<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
-        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        find(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
-        detect(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
-        filter(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
-        select(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
+        each(iterator: IteratorCallback<T, void>, context?: any): ChainedObject<void>;
+        forEach(iterator: IteratorCallback<T, void>, context?: any): ChainedObject<void>;
+        map<U>(iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
+        collect<U>(iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
+        reduce(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        reduce<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        foldl(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        foldl<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        inject(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        inject<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        reduceRight(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        reduceRight<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        foldr(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        foldr<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        find(iterator: IteratorCallback<T, boolean>, context?: any): ChainedObject<T>;
+        detect(iterator: IteratorCallback<T, boolean>, context?: any): ChainedObject<T>;
+        filter(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
+        select(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
         where(properties: Object): ChainedArray<T>;
         findWhere(properties: Object): ChainedObject<T>;
-        reject(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
-        every(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
-        all(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
-        some(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
-        any(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
+        reject(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
+        every(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+        all(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+        some(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+        any(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
         contains(value: T): ChainedObject<boolean>;
         include(value: T): ChainedObject<boolean>;
         invoke(methodName: string, ...args: any[]): ChainedArray<any>;
         pluck(propertyName: string): ChainedArray<any>;
-        max(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
-        min(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
-        sortBy(iterator: Iterator<T, any>, context?: any): ChainedArray<T>;
+        max(iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<T>;
+        min(iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<T>;
+        sortBy(iterator: IteratorCallback<T, any>, context?: any): ChainedArray<T>;
         sortBy(propertyName: string): ChainedArray<T>;
         // Should return ChainedDictionary<T[]>, but expansive recursion not allowed
-        groupBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<any[]>;
+        groupBy(iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<any[]>;
         groupBy(propertyName: string): ChainedDictionary<any[]>;
-        countBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<number>;
+        countBy(iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<number>;
         countBy(propertyName: string): ChainedDictionary<number>;
         shuffle(): ChainedArray<T>;
         toArray(): ChainedArray<T>;
@@ -297,16 +297,16 @@ module Underscore {
         intersection(...arrays: T[][]): ChainedArray<T>;
         difference(...others: T[][]): ChainedArray<T>;
         uniq(isSorted?: boolean): ChainedArray<T>;
-        uniq<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
+        uniq<U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
         unique(isSorted?: boolean): ChainedArray<T>;
-        unique<U>(isSorted: boolean, iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
+        unique<U>(isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
         zip(...arrays: any[][]): ChainedArray<any[]>;
         object(): ChainedObject<any>;
         object(values: any[]): ChainedObject<any>;
         indexOf(value: T, isSorted?: boolean): ChainedObject<number>;
         lastIndexOf(value: T, fromIndex?: number): ChainedObject<number>;
         sortedIndex(obj: T, propertyName: string): ChainedObject<number>;
-        sortedIndex(obj: T, iterator?: Iterator<T, any>, context?: any): ChainedObject<number>;
+        sortedIndex(obj: T, iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<number>;
         // Methods from Array
         concat(...items: T[]): ChainedArray<T>;
         join(separator?: string): ChainedObject<string>;
@@ -329,43 +329,43 @@ module Underscore {
     }
 
     export interface ChainedDictionary<T> extends ChainedObject<Dictionary<T>> {
-        each(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
-        forEach(iterator: Iterator<T, void>, context?: any): ChainedObject<void>;
-        map<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
-        collect<U>(iterator: Iterator<T, U>, context?: any): ChainedArray<U>;
-        reduce(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        reduce<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        foldl(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        foldl<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        inject(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        inject<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        reduceRight(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        reduceRight<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        foldr(iterator: Reducer<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
-        foldr<U>(iterator: Reducer<T, U>, initialValue: U, context?: any): ChainedObject<U>;
-        find(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
-        detect(iterator: Iterator<T, boolean>, context?: any): ChainedObject<T>;
-        filter(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
-        select(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
+        each(iterator: IteratorCallback<T, void>, context?: any): ChainedObject<void>;
+        forEach(iterator: IteratorCallback<T, void>, context?: any): ChainedObject<void>;
+        map<U>(iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
+        collect<U>(iterator: IteratorCallback<T, U>, context?: any): ChainedArray<U>;
+        reduce(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        reduce<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        foldl(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        foldl<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        inject(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        inject<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        reduceRight(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        reduceRight<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        foldr(iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): ChainedObject<T>;
+        foldr<U>(iterator: ReducerCallback<T, U>, initialValue: U, context?: any): ChainedObject<U>;
+        find(iterator: IteratorCallback<T, boolean>, context?: any): ChainedObject<T>;
+        detect(iterator: IteratorCallback<T, boolean>, context?: any): ChainedObject<T>;
+        filter(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
+        select(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
         where(properties: Object): ChainedArray<T>;
         findWhere(properties: Object): ChainedObject<T>;
-        reject(iterator: Iterator<T, boolean>, context?: any): ChainedArray<T>;
-        every(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
-        all(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
-        some(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
-        any(iterator?: Iterator<T, boolean>, context?: any): ChainedObject<boolean>;
+        reject(iterator: IteratorCallback<T, boolean>, context?: any): ChainedArray<T>;
+        every(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+        all(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+        some(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
+        any(iterator?: IteratorCallback<T, boolean>, context?: any): ChainedObject<boolean>;
         contains(value: T): ChainedObject<boolean>;
         include(value: T): ChainedObject<boolean>;
         invoke(methodName: string, ...args: any[]): ChainedArray<any>;
         pluck(propertyName: string): ChainedArray<any>;
-        max(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
-        min(iterator?: Iterator<T, any>, context?: any): ChainedObject<T>;
-        sortBy(iterator: Iterator<T, any>, context?: any): ChainedArray<T>;
+        max(iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<T>;
+        min(iterator?: IteratorCallback<T, any>, context?: any): ChainedObject<T>;
+        sortBy(iterator: IteratorCallback<T, any>, context?: any): ChainedArray<T>;
         sortBy(propertyName: string): ChainedArray<T>;
         // Should return ChainedDictionary<T[]>, but expansive recursion not allowed
-        groupBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<any[]>;
+        groupBy(iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<any[]>;
         groupBy(propertyName: string): ChainedDictionary<any[]>;
-        countBy(iterator?: Iterator<T, any>, context?: any): ChainedDictionary<number>;
+        countBy(iterator?: IteratorCallback<T, any>, context?: any): ChainedDictionary<number>;
         countBy(propertyName: string): ChainedDictionary<number>;
         shuffle(): ChainedArray<T>;
         toArray(): ChainedArray<T>;
@@ -396,47 +396,47 @@ module Underscore {
         chain<T>(list: Dictionary<T>): ChainedDictionary<T>;
         chain<T>(obj: T): ChainedObject<T>;
 
-        each<T>(list: T[], iterator: Iterator<T, void>, context?: any): void;
-        each<T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void;
-        forEach<T>(list: T[], iterator: Iterator<T, void>, context?: any): void;
-        forEach<T>(list: Dictionary<T>, iterator: Iterator<T, void>, context?: any): void;
+        each<T>(list: T[], iterator: IteratorCallback<T, void>, context?: any): void;
+        each<T>(list: Dictionary<T>, iterator: IteratorCallback<T, void>, context?: any): void;
+        forEach<T>(list: T[], iterator: IteratorCallback<T, void>, context?: any): void;
+        forEach<T>(list: Dictionary<T>, iterator: IteratorCallback<T, void>, context?: any): void;
 
-        map<T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[];
-        map<T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[];
-        collect<T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[];
-        collect<T, U>(list: Dictionary<T>, iterator: Iterator<T, U>, context?: any): U[];
+        map<T, U>(list: T[], iterator: IteratorCallback<T, U>, context?: any): U[];
+        map<T, U>(list: Dictionary<T>, iterator: IteratorCallback<T, U>, context?: any): U[];
+        collect<T, U>(list: T[], iterator: IteratorCallback<T, U>, context?: any): U[];
+        collect<T, U>(list: Dictionary<T>, iterator: IteratorCallback<T, U>, context?: any): U[];
 
-        reduce<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        reduce<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        reduce<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        reduce<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        foldl<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        foldl<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        foldl<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        foldl<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        inject<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        inject<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        inject<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        inject<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
+        reduce<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        reduce<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        reduce<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        reduce<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        foldl<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        foldl<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        foldl<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        foldl<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        inject<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        inject<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        inject<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        inject<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
 
-        reduceRight<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        reduceRight<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        reduceRight<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        reduceRight<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        foldr<T>(list: T[], iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        foldr<T, U>(list: T[], iterator: Reducer<T, U>, initialValue: U, context?: any): U;
-        foldr<T>(list: Dictionary<T>, iterator: Reducer<T, T>, initialValue?: T, context?: any): T;
-        foldr<T, U>(list: Dictionary<T>, iterator: Reducer<T, U>, initialValue: U, context?: any): U;
+        reduceRight<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        reduceRight<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        reduceRight<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        reduceRight<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        foldr<T>(list: T[], iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        foldr<T, U>(list: T[], iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
+        foldr<T>(list: Dictionary<T>, iterator: ReducerCallback<T, T>, initialValue?: T, context?: any): T;
+        foldr<T, U>(list: Dictionary<T>, iterator: ReducerCallback<T, U>, initialValue: U, context?: any): U;
 
-        find<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T;
-        find<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T;
-        detect<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T;
-        detect<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T;
+        find<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T;
+        find<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T;
+        detect<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T;
+        detect<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T;
 
-        filter<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[];
-        filter<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[];
-        select<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[];
-        select<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[];
+        filter<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[];
+        filter<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[];
+        select<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[];
+        select<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[];
 
         where<T>(list: T[], properties: Object): T[];
         where<T>(list: Dictionary<T>, properties: Object): T[];
@@ -444,18 +444,18 @@ module Underscore {
         findWhere<T>(list: T[], properties: Object): T;
         findWhere<T>(list: Dictionary<T>, properties: Object): T;
 
-        reject<T>(list: T[], iterator: Iterator<T, boolean>, context?: any): T[];
-        reject<T>(list: Dictionary<T>, iterator: Iterator<T, boolean>, context?: any): T[];
+        reject<T>(list: T[], iterator: IteratorCallback<T, boolean>, context?: any): T[];
+        reject<T>(list: Dictionary<T>, iterator: IteratorCallback<T, boolean>, context?: any): T[];
 
-        every<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
-        every<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
-        all<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
-        all<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
+        every<T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        every<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        all<T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        all<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
 
-        some<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
-        some<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
-        any<T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean;
-        any<T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean;
+        some<T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        some<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        any<T>(list: T[], iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
+        any<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, boolean>, context?: any): boolean;
 
         contains<T>(list: T[], value: T): boolean;
         contains<T>(list: Dictionary<T>, value: T): boolean;
@@ -468,24 +468,24 @@ module Underscore {
         pluck(list: any[], propertyName: string): any[];
         pluck(list: Dictionary<any>, propertyName: string): any[];
 
-        max<T>(list: T[], iterator?: Iterator<T, any>, context?: any): T;
-        max<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T;
+        max<T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): T;
+        max<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): T;
 
-        min<T>(list: T[], iterator?: Iterator<T, any>, context?: any): T;
-        min<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): T;
+        min<T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): T;
+        min<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): T;
 
-        sortBy<T>(list: T[], iterator: Iterator<T, any>, context?: any): T[];
-        sortBy<T>(list: Dictionary<T>, iterator: Iterator<T, any>, context?: any): T[];
+        sortBy<T>(list: T[], iterator: IteratorCallback<T, any>, context?: any): T[];
+        sortBy<T>(list: Dictionary<T>, iterator: IteratorCallback<T, any>, context?: any): T[];
         sortBy<T>(list: T[], propertyName: string): T[];
         sortBy<T>(list: Dictionary<T>, propertyName: string): T[];
 
-        groupBy<T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
-        groupBy<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<T[]>;
+        groupBy<T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>;
+        groupBy<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<T[]>;
         groupBy<T>(list: T[], propertyName: string): Dictionary<T[]>;
         groupBy<T>(list: Dictionary<T>, propertyName: string): Dictionary<T[]>;
 
-        countBy<T>(list: T[], iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
-        countBy<T>(list: Dictionary<T>, iterator?: Iterator<T, any>, context?: any): Dictionary<number>;
+        countBy<T>(list: T[], iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>;
+        countBy<T>(list: Dictionary<T>, iterator?: IteratorCallback<T, any>, context?: any): Dictionary<number>;
         countBy<T>(list: T[], propertyName: string): Dictionary<number>;
         countBy<T>(list: Dictionary<T>, propertyName: string): Dictionary<number>;
 
@@ -527,9 +527,9 @@ module Underscore {
         difference<T>(list: T[], ...others: T[][]): T[];
 
         uniq<T>(list: T[], isSorted?: boolean): T[];
-        uniq<T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
+        uniq<T, U>(list: T[], isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[];
         unique<T>(list: T[], isSorted?: boolean): T[];
-        unique<T, U>(list: T[], isSorted: boolean, iterator: Iterator<T, U>, context?: any): U[];
+        unique<T, U>(list: T[], isSorted: boolean, iterator: IteratorCallback<T, U>, context?: any): U[];
 
         zip<T0, T1>(a0: T0[], a1: T1[]): Tuple2<T0, T1>[];
         zip<T0, T1, T2>(a0: T0[], a1: T1[], a2: T2[]): Tuple3<T0, T1, T2>[];
@@ -544,7 +544,7 @@ module Underscore {
         lastIndexOf<T>(list: T[], value: T, fromIndex?: number): number;
 
         sortedIndex<T>(list: T[], obj: T, propertyName: string): number;
-        sortedIndex<T>(list: T[], obj: T, iterator?: Iterator<T, any>, context?: any): number;
+        sortedIndex<T>(list: T[], obj: T, iterator?: IteratorCallback<T, any>, context?: any): number;
 
         range(stop: number): number[];
         range(start: number, stop: number, step?: number): number[];
@@ -621,7 +621,7 @@ module Underscore {
 
         identity<T>(value: T): T;
 
-        times<U>(n: number, iterator: Iterator<number, U>, context?: any): U[];
+        times<U>(n: number, iterator: IteratorCallback<number, U>, context?: any): U[];
 
         random(max: number): number;
         random(min: number, max: number): number;
@@ -647,255 +647,255 @@ module Underscore {
 declare var _: Underscore.Static;
 
 // @Filename: underscoreTest1_underscoreTests.ts
-/// <reference path="underscoreTest1_underscore.ts" />
-
-declare var $;
-declare function alert(x: string): void;
-
-_.each([1, 2, 3], (num) => alert(num.toString()));
-_.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(value.toString()));
-
-_.map([1, 2, 3], (num) => num * 3);
-_.map({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => value * 3);
-
-var sum = _.reduce([1, 2, 3], (memo, num) => memo + num, 0);
-
-var list = [[0, 1], [2, 3], [4, 5]];
-var flat = _.reduceRight(list, (a, b) => a.concat(b), []);
-
-var even = _.find([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
-
-var evens = _.filter([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
-
-var listOfPlays = [{ title: "Cymbeline", author: "Shakespeare", year: 1611 }, { title: "The Tempest", author: "Shakespeare", year: 1611 }, { title: "Other", author: "Not Shakespeare", year: 2012 }];
-_.where(listOfPlays, { author: "Shakespeare", year: 1611 });
-
-var odds = _.reject([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
-
-_.all([true, 1, null, 'yes'], _.identity);
-
-_.any([null, 0, 'yes', false]);
-
-_.contains([1, 2, 3], 3);
-
-_.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
-
-var stooges = [{ name: 'moe', age: 40 }, { name: 'larry', age: 50 }, { name: 'curly', age: 60 }];
-_.pluck(stooges, 'name');
-
-_.max(stooges, (stooge) => stooge.age);
-
-var numbers = [10, 5, 100, 2, 1000];
-_.min(numbers);
-
-_.sortBy([1, 2, 3, 4, 5, 6], (num) => Math.sin(num));
-
-
-// not sure how this is typechecking at all.. Math.floor(e) is number not string..?
-_([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floor(e));
-_.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num));
-_.groupBy(['one', 'two', 'three'], 'length');
-
-_.countBy([1, 2, 3, 4, 5], (num) => num % 2 == 0 ? 'even' : 'odd');
-
-_.shuffle([1, 2, 3, 4, 5, 6]);
-
-// (function(){ return _.toArray(arguments).slice(1); })(1, 2, 3, 4);
-
-_.size({ one: 1, two: 2, three: 3 });
-
-///////////////////////////////////////////////////////////////////////////////////////
-
-_.first([5, 4, 3, 2, 1]);
-_.initial([5, 4, 3, 2, 1]);
-_.last([5, 4, 3, 2, 1]);
-_.rest([5, 4, 3, 2, 1]);
-_.compact([0, 1, false, 2, '', 3]);
-
-_.flatten([1, 2, 3, 4]);
-_.flatten([1, [2]]);
-
-// typescript doesn't like the elements being different
-_.flatten([1, [2], [3, [[4]]]]);
-_.flatten([1, [2], [3, [[4]]]], true);
-_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
-_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
-_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
-_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
-_.uniq([1, 2, 1, 3, 1, 4]);
-_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]);
-_.object(['moe', 'larry', 'curly'], [30, 40, 50]);
-_.object([['moe', 30], ['larry', 40], ['curly', 50]]);
-_.indexOf([1, 2, 3], 2);
-_.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
-_.sortedIndex([10, 20, 30, 40, 50], 35);
-_.range(10);
-_.range(1, 11);
-_.range(0, 30, 5);
-_.range(0, 30, 5);
-_.range(0);
-
-///////////////////////////////////////////////////////////////////////////////////////
-
-var func = function (greeting) { return greeting + ': ' + this.name };
-// need a second var otherwise typescript thinks func signature is the above func type,
-// instead of the newly returned _bind => func type.
-var func2 = _.bind(func, { name: 'moe' }, 'hi');
-func2();
-
-var buttonView = {
-    label: 'underscore',
-    onClick: function () { alert('clicked: ' + this.label); },
-    onHover: function () { alert('hovering: ' + this.label); }
-};
-_.bindAll(buttonView);
-$('#underscore_button').bind('click', buttonView.onClick);
-
-var fibonacci = _.memoize(function (n) {
-    return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
-});
-
-var log = _.bind((message?: string, ...rest: string[]) => { }, Date);
-_.delay(log, 1000, 'logged later');
-
-_.defer(function () { alert('deferred'); });
-
-var updatePosition = () => alert('updating position...');
-var throttled = _.throttle(updatePosition, 100);
-$(null).scroll(throttled);
-
-var calculateLayout = () => alert('calculating layout...');
-var lazyLayout = _.debounce(calculateLayout, 300);
-$(null).resize(lazyLayout);
-
-var createApplication = () => alert('creating application...');
-var initialize = _.once(createApplication);
-initialize();
-initialize();
-
-var notes: any[];
-var render = () => alert("rendering...");
-var renderNotes = _.after(notes.length, render);
-_.each(notes, (note) => note.asyncSave({ success: renderNotes }));
-
-var hello = function (name) { return "hello: " + name; };
-hello = _.wrap(hello, (func, arg) => { return "before, " + func(arg) + ", after"; });
-hello("moe");
-
-var greet = function (name) { return "hi: " + name; };
-var exclaim = function (statement) { return statement + "!"; };
-var welcome = _.compose(exclaim, greet);
-welcome('moe');
-
-///////////////////////////////////////////////////////////////////////////////////////
-
-_.keys({ one: 1, two: 2, three: 3 });
-_.values({ one: 1, two: 2, three: 3 });
-_.pairs({ one: 1, two: 2, three: 3 });
-_.invert({ Moe: "Moses", Larry: "Louis", Curly: "Jerome" });
-_.functions(_);
-_.extend({ name: 'moe' }, { age: 50 });
-_.pick({ name: 'moe', age: 50, userid: 'moe1' }, 'name', 'age');
-_.omit({ name: 'moe', age: 50, userid: 'moe1' }, 'userid');
-
-var iceCream = { flavor: "chocolate" };
-_.defaults(iceCream, { flavor: "vanilla", sprinkles: "lots" });
-
-_.clone({ name: 'moe' });
-
-_.chain([1, 2, 3, 200])
-    .filter(function (num) { return num % 2 == 0; })
-    .tap(<any>alert)
-    .map(function (num) { return num * num })
-    .value();
-
-_.has({ a: 1, b: 2, c: 3 }, "b");
-
-var moe = { name: 'moe', luckyNumbers: [13, 27, 34] };
-var clone = { name: 'moe', luckyNumbers: [13, 27, 34] };
-moe == clone;
-_.isEqual(moe, clone);
-
-_.isEmpty([1, 2, 3]);
-_.isEmpty({});
-
-_.isElement($('body')[0]);
-
-(function () { return _.isArray(arguments); })();
-_.isArray([1, 2, 3]);
-
-_.isObject({});
-_.isObject(1);
-
-
-// (() => { return _.isArguments(arguments); })(1, 2, 3);
-_.isArguments([1, 2, 3]);
-
-_.isFunction(alert);
-
-_.isString("moe");
-
-_.isNumber(8.4 * 5);
-
-_.isFinite(-101);
-
-_.isFinite(-Infinity);
-
-_.isBoolean(null);
-
-_.isDate(new Date());
-
-_.isRegExp(/moe/);
-
-_.isNaN(NaN);
-isNaN(undefined);
-_.isNaN(undefined);
-
-_.isNull(null);
-_.isNull(undefined);
-
-_.isUndefined((<any>null).missingVariable);
-
-///////////////////////////////////////////////////////////////////////////////////////
-
-var underscore = _.noConflict();
-
-var moe2 = { name: 'moe' };
-moe2 === _.identity(moe);
-
-var genie;
-
-_.times(3, function (n) { genie.grantWishNumber(n); });
-
-_.random(0, 100);
-
-_.mixin({
-    capitalize: function (string) {
-        return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();
-    }
-});
-(<any>_("fabio")).capitalize();
-
-_.uniqueId('contact_');
-
-_.escape('Curly, Larry & Moe');
-
-var object = { cheese: 'crumpets', stuff: function () { return 'nonsense'; } };
-_.result(object, 'cheese');
-
-_.result(object, 'stuff');
-
-var compiled = _.template("hello: <%= name %>");
-compiled({ name: 'moe' });
-var list2 = "<% _.each(people, function(name) { %> <li><%= name %></li> <% }); %>";
-_.template(list2, { people: ['moe', 'curly', 'larry'] });
-var template = _.template("<b><%- value %></b>");
-template({ value: '<script>' });
-var compiled2 = _.template("<% print('Hello ' + epithet); %>");
-compiled2({ epithet: "stooge" });
-_.templateSettings = {
-    interpolate: /\{\{(.+?)\}\}/g
-};
-var template2 = _.template("Hello {{ name }}!");
-template2({ name: "Mustache" });
+/// <reference path="underscoreTest1_underscore.ts" />
+
+declare var $;
+declare function alert(x: string): void;
+
+_.each([1, 2, 3], (num) => alert(num.toString()));
+_.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(value.toString()));
+
+_.map([1, 2, 3], (num) => num * 3);
+_.map({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => value * 3);
+
+var sum = _.reduce([1, 2, 3], (memo, num) => memo + num, 0);
+
+var list = [[0, 1], [2, 3], [4, 5]];
+var flat = _.reduceRight(list, (a, b) => a.concat(b), []);
+
+var even = _.find([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
+
+var evens = _.filter([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
+
+var listOfPlays = [{ title: "Cymbeline", author: "Shakespeare", year: 1611 }, { title: "The Tempest", author: "Shakespeare", year: 1611 }, { title: "Other", author: "Not Shakespeare", year: 2012 }];
+_.where(listOfPlays, { author: "Shakespeare", year: 1611 });
+
+var odds = _.reject([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
+
+_.all([true, 1, null, 'yes'], _.identity);
+
+_.any([null, 0, 'yes', false]);
+
+_.contains([1, 2, 3], 3);
+
+_.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
+
+var stooges = [{ name: 'moe', age: 40 }, { name: 'larry', age: 50 }, { name: 'curly', age: 60 }];
+_.pluck(stooges, 'name');
+
+_.max(stooges, (stooge) => stooge.age);
+
+var numbers = [10, 5, 100, 2, 1000];
+_.min(numbers);
+
+_.sortBy([1, 2, 3, 4, 5, 6], (num) => Math.sin(num));
+
+
+// not sure how this is typechecking at all.. Math.floor(e) is number not string..?
+_([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floor(e));
+_.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num));
+_.groupBy(['one', 'two', 'three'], 'length');
+
+_.countBy([1, 2, 3, 4, 5], (num) => num % 2 == 0 ? 'even' : 'odd');
+
+_.shuffle([1, 2, 3, 4, 5, 6]);
+
+// (function(){ return _.toArray(arguments).slice(1); })(1, 2, 3, 4);
+
+_.size({ one: 1, two: 2, three: 3 });
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+_.first([5, 4, 3, 2, 1]);
+_.initial([5, 4, 3, 2, 1]);
+_.last([5, 4, 3, 2, 1]);
+_.rest([5, 4, 3, 2, 1]);
+_.compact([0, 1, false, 2, '', 3]);
+
+_.flatten([1, 2, 3, 4]);
+_.flatten([1, [2]]);
+
+// typescript doesn't like the elements being different
+_.flatten([1, [2], [3, [[4]]]]);
+_.flatten([1, [2], [3, [[4]]]], true);
+_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
+_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
+_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
+_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
+_.uniq([1, 2, 1, 3, 1, 4]);
+_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]);
+_.object(['moe', 'larry', 'curly'], [30, 40, 50]);
+_.object([['moe', 30], ['larry', 40], ['curly', 50]]);
+_.indexOf([1, 2, 3], 2);
+_.lastIndexOf([1, 2, 3, 1, 2, 3], 2);
+_.sortedIndex([10, 20, 30, 40, 50], 35);
+_.range(10);
+_.range(1, 11);
+_.range(0, 30, 5);
+_.range(0, 30, 5);
+_.range(0);
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+var func = function (greeting) { return greeting + ': ' + this.name };
+// need a second var otherwise typescript thinks func signature is the above func type,
+// instead of the newly returned _bind => func type.
+var func2 = _.bind(func, { name: 'moe' }, 'hi');
+func2();
+
+var buttonView = {
+    label: 'underscore',
+    onClick: function () { alert('clicked: ' + this.label); },
+    onHover: function () { alert('hovering: ' + this.label); }
+};
+_.bindAll(buttonView);
+$('#underscore_button').bind('click', buttonView.onClick);
+
+var fibonacci = _.memoize(function (n) {
+    return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
+});
+
+var log = _.bind((message?: string, ...rest: string[]) => { }, Date);
+_.delay(log, 1000, 'logged later');
+
+_.defer(function () { alert('deferred'); });
+
+var updatePosition = () => alert('updating position...');
+var throttled = _.throttle(updatePosition, 100);
+$(null).scroll(throttled);
+
+var calculateLayout = () => alert('calculating layout...');
+var lazyLayout = _.debounce(calculateLayout, 300);
+$(null).resize(lazyLayout);
+
+var createApplication = () => alert('creating application...');
+var initialize = _.once(createApplication);
+initialize();
+initialize();
+
+var notes: any[];
+var render = () => alert("rendering...");
+var renderNotes = _.after(notes.length, render);
+_.each(notes, (note) => note.asyncSave({ success: renderNotes }));
+
+var hello = function (name) { return "hello: " + name; };
+hello = _.wrap(hello, (func, arg) => { return "before, " + func(arg) + ", after"; });
+hello("moe");
+
+var greet = function (name) { return "hi: " + name; };
+var exclaim = function (statement) { return statement + "!"; };
+var welcome = _.compose(exclaim, greet);
+welcome('moe');
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+_.keys({ one: 1, two: 2, three: 3 });
+_.values({ one: 1, two: 2, three: 3 });
+_.pairs({ one: 1, two: 2, three: 3 });
+_.invert({ Moe: "Moses", Larry: "Louis", Curly: "Jerome" });
+_.functions(_);
+_.extend({ name: 'moe' }, { age: 50 });
+_.pick({ name: 'moe', age: 50, userid: 'moe1' }, 'name', 'age');
+_.omit({ name: 'moe', age: 50, userid: 'moe1' }, 'userid');
+
+var iceCream = { flavor: "chocolate" };
+_.defaults(iceCream, { flavor: "vanilla", sprinkles: "lots" });
+
+_.clone({ name: 'moe' });
+
+_.chain([1, 2, 3, 200])
+    .filter(function (num) { return num % 2 == 0; })
+    .tap(<any>alert)
+    .map(function (num) { return num * num })
+    .value();
+
+_.has({ a: 1, b: 2, c: 3 }, "b");
+
+var moe = { name: 'moe', luckyNumbers: [13, 27, 34] };
+var clone = { name: 'moe', luckyNumbers: [13, 27, 34] };
+moe == clone;
+_.isEqual(moe, clone);
+
+_.isEmpty([1, 2, 3]);
+_.isEmpty({});
+
+_.isElement($('body')[0]);
+
+(function () { return _.isArray(arguments); })();
+_.isArray([1, 2, 3]);
+
+_.isObject({});
+_.isObject(1);
+
+
+// (() => { return _.isArguments(arguments); })(1, 2, 3);
+_.isArguments([1, 2, 3]);
+
+_.isFunction(alert);
+
+_.isString("moe");
+
+_.isNumber(8.4 * 5);
+
+_.isFinite(-101);
+
+_.isFinite(-Infinity);
+
+_.isBoolean(null);
+
+_.isDate(new Date());
+
+_.isRegExp(/moe/);
+
+_.isNaN(NaN);
+isNaN(undefined);
+_.isNaN(undefined);
+
+_.isNull(null);
+_.isNull(undefined);
+
+_.isUndefined((<any>null).missingVariable);
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+var underscore = _.noConflict();
+
+var moe2 = { name: 'moe' };
+moe2 === _.identity(moe);
+
+var genie;
+
+_.times(3, function (n) { genie.grantWishNumber(n); });
+
+_.random(0, 100);
+
+_.mixin({
+    capitalize: function (string) {
+        return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();
+    }
+});
+(<any>_("fabio")).capitalize();
+
+_.uniqueId('contact_');
+
+_.escape('Curly, Larry & Moe');
+
+var object = { cheese: 'crumpets', stuff: function () { return 'nonsense'; } };
+_.result(object, 'cheese');
+
+_.result(object, 'stuff');
+
+var compiled = _.template("hello: <%= name %>");
+compiled({ name: 'moe' });
+var list2 = "<% _.each(people, function(name) { %> <li><%= name %></li> <% }); %>";
+_.template(list2, { people: ['moe', 'curly', 'larry'] });
+var template = _.template("<b><%- value %></b>");
+template({ value: '<script>' });
+var compiled2 = _.template("<% print('Hello ' + epithet); %>");
+compiled2({ epithet: "stooge" });
+_.templateSettings = {
+    interpolate: /\{\{(.+?)\}\}/g
+};
+var template2 = _.template("Hello {{ name }}!");
+template2({ name: "Mustache" });
 _.template("Using 'with': <%= data.answer %>", { answer: 'no' }, { variable: 'data' });
\ No newline at end of file
diff --git a/tests/cases/fourslash/genericMapTyping1.ts b/tests/cases/fourslash/genericMapTyping1.ts
index ea60fe0e0d6..3587fa35477 100644
--- a/tests/cases/fourslash/genericMapTyping1.ts
+++ b/tests/cases/fourslash/genericMapTyping1.ts
@@ -1,14 +1,14 @@
 /// <reference path="fourslash.ts" />
 
-////interface Iterator<T, U> {
+////interface IteratorCallback<T, U> {
 ////    (value: T, index: any, list: any): U;
 ////}
 ////interface WrappedArray<T> {
-////    map<U>(iterator: Iterator<T, U>, context?: any): U[];
+////    map<U>(iterator: IteratorCallback<T, U>, context?: any): U[];
 ////}
 ////interface Underscore {
 ////    <T>(list: T[]): WrappedArray<T>;
-////    map<T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[];
+////    map<T, U>(list: T[], iterator: IteratorCallback<T, U>, context?: any): U[];
 ////}
 ////declare var _: Underscore;
 ////var aa: string[];
diff --git a/tests/cases/fourslash/underscoreTypings01.ts b/tests/cases/fourslash/underscoreTypings01.ts
index 6ad1c902b70..453d25906f2 100644
--- a/tests/cases/fourslash/underscoreTypings01.ts
+++ b/tests/cases/fourslash/underscoreTypings01.ts
@@ -1,16 +1,16 @@
 /// <reference path='fourslash.ts'/>
 
-////interface Iterator<T, U> {
+////interface IteratorCallback<T, U> {
 ////    (value: T, index: any, list: any): U;
 ////}
 ////
 ////interface WrappedArray<T> {
-////    map<U>(iterator: Iterator<T, U>, context?: any): U[];
+////    map<U>(iterator: IteratorCallback<T, U>, context?: any): U[];
 ////}
 ////
 ////interface Underscore {
 ////    <T>(list: T[]): WrappedArray<T>;
-////    map<T, U>(list: T[], iterator: Iterator<T, U>, context?: any): U[];
+////    map<T, U>(list: T[], iterator: IteratorCallback<T, U>, context?: any): U[];
 ////}
 ////
 ////declare var _: Underscore;
@@ -22,8 +22,8 @@
 ////
 ////var aa: any[];
 ////var /*7*/bb = _.map(aa, /*8*/x => x.length);
-////var /*9*/cc = _(aa).map(/*10*/x => x.length); 
-////var /*11*/dd = aa.map(/*12*/x => x.length);     
+////var /*9*/cc = _(aa).map(/*10*/x => x.length);
+////var /*11*/dd = aa.map(/*12*/x => x.length);
 ////
 ////var e = a.map(x => x./*13*/