Merge 1f25cb5 into 83e3651

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emonkak/enumerable",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Provides the individual methods of LINQ as a module",
   "main": "index.js",
   "scripts": {

src/distinct.ts

@@ -1,4 +1,5 @@
 export default function distinct<TSource>(this: Iterable<TSource>): Iterable<TSource>;
+export default function distinct<TSource, TKey>(this: Iterable<TSource>, keySelector: (element: TSource) => TKey): Iterable<TSource>;
 export default function* distinct<TSource, TKey>(this: Iterable<TSource>, keySelector?: (element: TSource) => TKey): Iterable<TSource> {
     if (keySelector == null) {
         keySelector = x => x as any;

src/distinctUntilChanged.ts

@@ -1,4 +1,5 @@
 export default function distinctUntilChanged<TSource>(this: Iterable<TSource>): Iterable<TSource>;
+export default function distinctUntilChanged<TSource, TKey>(this: Iterable<TSource>, keySelector: (element: TSource) => TKey): Iterable<TSource>;
 export default function* distinctUntilChanged<TSource, TKey>(this: Iterable<TSource>, keySelector?: (element: TSource) => TKey): Iterable<TSource> {
     if (keySelector == null) {
         keySelector = x => x as any;

src/extensions/count.ts

@@ -1,12 +1,12 @@
 import countFn from '../count';
 import { Enumerable } from '../internal/Enumerable';
 
-Enumerable.prototype.count = count;
-
 function count<TSource>(this: Enumerable<TSource>, predicate?: (item: TSource) => boolean): number {
     return countFn.call(this.source, predicate);
 }
 
+Enumerable.prototype.count = count;
+
 declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
         count(predicate?: (item: TSource) => boolean): number;

src/extensions/distinct.ts

@@ -2,6 +2,7 @@ import distinctFn from '../distinct';
 import { Enumerable } from '../internal/Enumerable';
 
 function distinct<TSource>(this: Enumerable<TSource>): Enumerable<TSource>;
+function distinct<TSource, TKey>(this: Enumerable<TSource>, keySelector: (element: TSource) => TKey): Enumerable<TSource>;
 function distinct<TSource, TKey>(this: Enumerable<TSource>, keySelector?: (element: TSource) => TKey): Enumerable<TSource> {
     return this.lift<TSource>(distinctFn.call(this.source, keySelector));
 }
@@ -11,6 +12,6 @@ Enumerable.prototype.distinct = distinct;
 declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
         distinct(): Enumerable<TSource>;
-        distinct<TKey>(keySelector?: (element: TSource) => TKey): Enumerable<TSource>;
+        distinct<TKey>(keySelector: (element: TSource) => TKey): Enumerable<TSource>;
     }
 }

src/extensions/distinctUntilChanged.ts

@@ -2,6 +2,7 @@ import distinctUntilChangedFn from '../distinctUntilChanged';
 import { Enumerable } from '../internal/Enumerable';
 
 function distinctUntilChanged<TSource>(this: Enumerable<TSource>): Enumerable<TSource>;
+function distinctUntilChanged<TSource, TKey>(this: Enumerable<TSource>, keySelector: (element: TSource) => TKey): Enumerable<TSource>;
 function distinctUntilChanged<TSource, TKey>(this: Enumerable<TSource>, keySelector?: (element: TSource) => TKey): Enumerable<TSource> {
     return this.lift<TSource>(distinctUntilChangedFn.call(this.source, keySelector));
 }
@@ -11,6 +12,6 @@ Enumerable.prototype.distinctUntilChanged = distinctUntilChanged;
 declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
         distinctUntilChanged(): Enumerable<TSource>;
-        distinctUntilChanged<TKey>(keySelector?: (element: TSource) => TKey): Enumerable<TSource>;
+        distinctUntilChanged<TKey>(keySelector: (element: TSource) => TKey): Enumerable<TSource>;
     }
 }

src/extensions/orderBy.ts

@@ -3,6 +3,7 @@ import orderByFn from '../orderBy';
 import { Enumerable } from '../internal/Enumerable';
 
 function orderBy<TSource>(this: Enumerable<TSource>): OrderedEnumerable<TSource, TSource>;
+function orderBy<TSource, TKey>(this: Enumerable<TSource>, keySelector: (value: TSource) => TKey): OrderedEnumerable<TSource, TKey>;
 function orderBy<TSource, TKey>(this: Enumerable<TSource>, keySelector?: (value: TSource) => TKey): OrderedEnumerable<TSource, TKey> {
     return orderByFn.call(this.source, keySelector);
 }
@@ -12,6 +13,6 @@ Enumerable.prototype.orderBy = orderBy;
 declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
         orderBy(): OrderedEnumerable<TSource, TSource>;
-        orderBy<TKey>(keySelector?: (value: TSource) => TKey): OrderedEnumerable<TSource, TKey>;
+        orderBy<TKey>(keySelector: (value: TSource) => TKey): OrderedEnumerable<TSource, TKey>;
     }
 }

src/extensions/orderByDescending.ts

@@ -3,6 +3,7 @@ import orderByDescendingFn from '../orderByDescending';
 import { Enumerable } from '../internal/Enumerable';
 
 function orderByDescending<TSource>(this: Enumerable<TSource>): OrderedEnumerable<TSource, TSource>;
+function orderByDescending<TSource, TKey>(this: Enumerable<TSource>, keySelector: (value: TSource) => TKey): OrderedEnumerable<TSource, TKey>;
 function orderByDescending<TSource, TKey>(this: Enumerable<TSource>, keySelector?: (value: TSource) => TKey): OrderedEnumerable<TSource, TKey> {
     return orderByDescendingFn.call(this.source, keySelector);
 }
@@ -12,6 +13,6 @@ Enumerable.prototype.orderByDescending = orderByDescending;
 declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
         orderByDescending(): OrderedEnumerable<TSource, TSource>;
-        orderByDescending<TKey>(keySelector?: (value: TSource) => TKey): OrderedEnumerable<TSource, TKey>;
+        orderByDescending<TKey>(keySelector: (value: TSource) => TKey): OrderedEnumerable<TSource, TKey>;
     }
 }

src/extensions/toDictionary.ts

@@ -2,6 +2,7 @@ import toDictionaryFn from '../toDictionary';
 import { Enumerable } from '../internal/Enumerable';
 
 function toDictionary<TSource, TKey>(this: Enumerable<TSource>, keySelector: (element: TSource) => TKey): Map<TKey, TSource>;
+function toDictionary<TSource, TKey, TElement>(this: Enumerable<TSource>, keySelector: (element: TSource) => TKey, elementSelector: (element: TSource) => TElement): Map<TKey, TElement>;
 function toDictionary<TSource, TKey, TElement>(this: Enumerable<TSource>, keySelector: (element: TSource) => TKey, elementSelector?: (element: TSource) => TElement): Map<TKey, TElement> {
     return toDictionaryFn.call(this.source, keySelector, elementSelector);
 }
@@ -11,6 +12,6 @@ Enumerable.prototype.toDictionary = toDictionary;
 declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
         toDictionary<TKey>(keySelector: (element: TSource) => TKey): Map<TKey, TSource>;
-        toDictionary<TKey, TElement>(keySelector: (element: TSource) => TKey, elementSelector?: (element: TSource) => TElement): Map<TKey, TElement>;
+        toDictionary<TKey, TElement>(keySelector: (element: TSource) => TKey, elementSelector: (element: TSource) => TElement): Map<TKey, TElement>;
     }
 }

src/extensions/toLookup.ts

@@ -2,6 +2,7 @@ import toLookupFn from '../toLookup';
 import { Enumerable } from '../internal/Enumerable';
 
 function toLookup<TSource, TKey>(this: Enumerable<TSource>, keySelector: (element: TSource) => TKey): Map<TKey, TSource[]>;
+function toLookup<TSource, TKey, TElement>(this: Enumerable<TSource>, keySelector: (element: TSource) => TKey, elementSelector: (element: TSource) => TElement): Map<TKey, TElement[]>;
 function toLookup<TSource, TKey, TElement>(this: Enumerable<TSource>, keySelector: (element: TSource) => TKey, elementSelector?: (element: TSource) => TElement): Map<TKey, TElement[]> {
     return toLookupFn.call(this.source, keySelector, elementSelector);
 }
@@ -11,6 +12,6 @@ Enumerable.prototype.toLookup = toLookup;
 declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
         toLookup<TKey>(keySelector: (element: TSource) => TKey): Map<TKey, TSource[]>;
-        toLookup<TKey, TElement>(keySelector: (element: TSource) => TKey, elementSelector?: (element: TSource) => TElement): Map<TKey, TElement[]>;
+        toLookup<TKey, TElement>(keySelector: (element: TSource) => TKey, elementSelector: (element: TSource) => TElement): Map<TKey, TElement[]>;
     }
 }

src/extensions/toObject.ts

@@ -2,6 +2,7 @@ import toObjectFn from '../toObject';
 import { Enumerable } from '../internal/Enumerable';
 
 function toObject<TSource>(this: Enumerable<TSource>, keySelector: (element: TSource) => string): { [key: string]: TSource };
+function toObject<TSource, TElement>(this: Enumerable<TSource>, keySelector: (element: TSource) => string, elementSelector: (element: TSource) => TElement): { [key: string]: TElement };
 function toObject<TSource, TElement>(this: Enumerable<TSource>, keySelector: (element: TSource) => string, elementSelector?: (element: TSource) => TElement): { [key: string]: TElement } {
     return toObjectFn.call(this.source, keySelector, elementSelector);
 }
@@ -11,7 +12,6 @@ Enumerable.prototype.toObject = toObject;
 declare module '../internal/Enumerable' {
     interface Enumerable<TSource> {
         toObject(keySelector: (element: TSource) => string): { [key: string]: TSource };
-        toObject<TElement>(keySelector: (element: TSource) => string, elementSelector?: (element: TSource) => TElement): { [key: string]: TElement };
+        toObject<TElement>(keySelector: (element: TSource) => string, elementSelector: (element: TSource) => TElement): { [key: string]: TElement };
     }
 }
-

src/hof/aggregate.ts

@@ -0,0 +1,6 @@
+import aggregateFn from '../aggregate';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function aggregate<TSource, TAccumulate>(seed: TAccumulate, func: (result: TAccumulate, element: TSource) => TAccumulate): (source: Enumerable<TSource>) => TAccumulate {
+    return (source) => aggregateFn.call(source, seed, func);
+}

src/hof/all.ts

@@ -0,0 +1,6 @@
+import allFn from '../all';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function all<TSource>(predicate?: (element: TSource) => boolean): (source: Enumerable<TSource>) => boolean {
+    return (source) => allFn.call(source, predicate);
+}

src/hof/any.ts

@@ -0,0 +1,6 @@
+import anyFn from '../any';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function any<TSource>(predicate?: (element: TSource) => boolean): (source: Enumerable<TSource>) => boolean {
+    return (source) => anyFn.call(source, predicate);
+}

src/hof/average.ts

@@ -0,0 +1,6 @@
+import averageFn from '../average';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function average<TSource>(selector?: (element: TSource) => number): (source: Enumerable<TSource>) => number {
+    return (source) => averageFn.call(source, selector);
+}

src/hof/buffer.ts

@@ -0,0 +1,6 @@
+import bufferFn from '../buffer';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function buffer<TSource>(count: number, skip?: number): (source: Enumerable<TSource>) => Enumerable<TSource[]> {
+    return (source) => source.lift<TSource[]>(bufferFn.call(source.source, count, skip));
+}

src/hof/catch.ts

@@ -0,0 +1,6 @@
+import catchFn from '../catch';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function _catch<TSource, TException>(handler: (exception: TException) => Iterable<TSource>): (source: Enumerable<TSource>) => Enumerable<TSource> {
+    return (source) => source.lift<TSource>(catchFn.call(source.source, handler));
+}

src/hof/concat.ts

@@ -0,0 +1,6 @@
+import concatFn from '../concat';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function concat<TSource>(second: Iterable<TSource>): (source: Enumerable<TSource>) => Enumerable<TSource> {
+    return (source) => source.lift<TSource>(concatFn.call(source.source, second));
+}

src/hof/count.ts

@@ -0,0 +1,6 @@
+import countFn from '../count';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function count<TSource>(predicate?: (item: TSource) => boolean): (source: Enumerable<TSource>) => number {
+    return (source) => countFn.call(source, predicate);
+}

src/hof/defaultIfEmpty.ts

@@ -0,0 +1,6 @@
+import defaultIfEmptyFn from '../defaultIfEmpty';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function defaultIfEmpty<TSource>(defaultValue: TSource): (source: Enumerable<TSource>) => Enumerable<TSource> {
+    return (source) => source.lift<TSource>(defaultIfEmptyFn.call(source.source, defaultValue));
+}

src/hof/distinct.ts

@@ -0,0 +1,8 @@
+import distinctFn from '../distinct';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function distinct<TSource>(): (source: Enumerable<TSource>) => Enumerable<TSource>;
+export default function distinct<TSource, TKey>(keySelector: (element: TSource) => TKey): (source: Enumerable<TSource>) => Enumerable<TSource>;
+export default function distinct<TSource, TKey>(keySelector?: (element: TSource) => TKey): (source: Enumerable<TSource>) => Enumerable<TSource> {
+    return (source) => source.lift<TSource>(distinctFn.call(source.source, keySelector));
+}

src/hof/distinctUntilChanged.ts

@@ -0,0 +1,8 @@
+import distinctUntilChangedFn from '../distinctUntilChanged';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function distinctUntilChanged<TSource>(): (source: Enumerable<TSource>) => Enumerable<TSource>;
+export default function distinctUntilChanged<TSource, TKey>(keySelector: (element: TSource) => TKey): (source: Enumerable<TSource>) => Enumerable<TSource>;
+export default function distinctUntilChanged<TSource, TKey>(keySelector?: (element: TSource) => TKey): (source: Enumerable<TSource>) => Enumerable<TSource> {
+    return (source) => source.lift<TSource>(distinctUntilChangedFn.call(source.source, keySelector));
+}

src/hof/do.ts

@@ -0,0 +1,6 @@
+import doFn from '../do';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function _do<TSource>(action: (element: TSource) => void): (source: Enumerable<TSource>) => Enumerable<TSource> {
+    return (source) => source.lift<TSource>(doFn.call(source.source, action));
+}

src/hof/doWhile.ts

@@ -0,0 +1,6 @@
+import doWhileFn from '../doWhile';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function doWhile<TSource>(condition: () => boolean): (source: Enumerable<TSource>) => Enumerable<TSource> {
+    return (source) => source.lift<TSource>(doWhileFn.call(source.source, condition));
+}

src/hof/elementAt.ts

@@ -0,0 +1,6 @@
+import elementAtFn from '../elementAt';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function elementAt<TSource>(index: number): (source: Enumerable<TSource>) => TSource {
+    return (source) => elementAtFn.call(source, index);
+}

src/hof/elementAtOrDefault.ts

@@ -0,0 +1,8 @@
+import elementAtOrDefaultFn from '../elementAtOrDefault';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function elementAtOrDefault<TSource>(index: number): (source: Enumerable<TSource>) => TSource | null;
+export default function elementAtOrDefault<TSource>(index: number, defaultValue: TSource): (source: Enumerable<TSource>) => TSource;
+export default function elementAtOrDefault<TSource>(index: number, defaultValue: TSource | null = null): (source: Enumerable<TSource>) => TSource | null {
+    return (source) => elementAtOrDefaultFn.call(source, index, defaultValue);
+}

src/hof/except.ts

@@ -0,0 +1,6 @@
+import exceptFn from '../except';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function except<TSource>(second: Iterable<TSource>): (source: Enumerable<TSource>) => Enumerable<TSource> {
+    return (source) => source.lift<TSource>(exceptFn.call(source.source, second));
+}

src/hof/finally.ts

@@ -0,0 +1,6 @@
+import finallyFn from '../finally';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function _finally<TSource>(finallyAction: () => void): (source: Enumerable<TSource>) => Enumerable<TSource> {
+    return (source) => source.lift<TSource>(finallyFn.call(source.source, finallyAction));
+}

src/hof/first.ts

@@ -0,0 +1,6 @@
+import firstFn from '../first';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function first<TSource>(predicate?: (element: TSource) => boolean): (source: Enumerable<TSource>) => TSource {
+    return (source) => firstFn.call(source, predicate);
+}

src/hof/firstOrDefault.ts

@@ -0,0 +1,9 @@
+import firstOrDefaultFn from '../firstOrDefault';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function firstOrDefault<TSource>(): (source: Enumerable<TSource>) => TSource | null;
+export default function firstOrDefault<TSource>(predicate: (element: TSource) => boolean): (source: Enumerable<TSource>) => TSource | null;
+export default function firstOrDefault<TSource>(predicate: ((element: TSource) => boolean) | null, defaultValue: TSource): (source: Enumerable<TSource>) => TSource;
+export default function firstOrDefault<TSource>(predicate?: ((element: TSource) => boolean) | null, defaultValue: TSource | null = null): (source: Enumerable<TSource>) => TSource | null {
+    return (source) => firstOrDefaultFn.call(source, predicate, defaultValue);
+}

src/hof/forEach.ts

@@ -0,0 +1,6 @@
+import forEachFn from '../forEach';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function forEach<TSource>(action: (element: TSource) => void): (source: Enumerable<TSource>) => void {
+    return (source) => forEachFn.call(source, action);
+}

src/hof/groupBy.ts

@@ -0,0 +1,8 @@
+import groupByFn from '../groupBy';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function groupBy<TSource, TKey>(keySelector: (element: TSource) => TKey): (source: Enumerable<TSource>) => Enumerable<[TKey, TSource]>;
+export default function groupBy<TSource, TKey, TElement>(keySelector: (element: TSource) => TKey, elementSelector: (element: TSource) => TElement): (source: Enumerable<TSource>) => Enumerable<[TKey, TElement]>;
+export default function groupBy<TSource, TKey, TElement, TResult>(keySelector: (element: TSource) => TKey, elementSelector?: (element: TSource) => TElement, resultSelector?: (key: TKey, elements: TElement[]) => TResult): (source: Enumerable<TSource>) => Enumerable<TResult> {
+    return (source) => source.lift<TResult>(groupByFn.call(source.source, keySelector, elementSelector, resultSelector));
+}

src/hof/groupJoin.ts

@@ -0,0 +1,6 @@
+import groupJoinFn from '../groupJoin';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function groupJoin<TOuter, TInner, TKey, TResult>(inner: Iterable<TInner>, outerKeySelector: (element: TOuter) => TKey, innerKeySelector: (element: TInner) => TKey, resultSelector: (outer: TOuter, inner: TInner[]) => TResult): (source: Enumerable<TOuter>) => Enumerable<TResult> {
+    return (source) => source.lift<TResult>(groupJoinFn.call(source.source, inner, outerKeySelector, innerKeySelector, resultSelector));
+}

src/hof/ignoreElements.ts

@@ -0,0 +1,6 @@
+import ignoreElementsFn from '../ignoreElements';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function ignoreElements<TSource>(): (source: Enumerable<TSource>) => Enumerable<TSource> {
+    return (source) => source.lift<TSource>(ignoreElementsFn.call(source.source));
+}

src/hof/intersect.ts

@@ -0,0 +1,6 @@
+import intersectFn from '../intersect';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function intersect<TSource>(second: Iterable<TSource>): (source: Enumerable<TSource>) => Enumerable<TSource> {
+    return (source) => source.lift<TSource>(intersectFn.call(source.source, second));
+}

src/hof/isEmpty.ts

@@ -0,0 +1,6 @@
+import isEmptyFn from '../isEmpty';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function isEmpty<TSource>(): (source: Enumerable<TSource>) => boolean {
+    return (source) => isEmptyFn.call(source);
+}

src/hof/join.ts

@@ -0,0 +1,6 @@
+import joinFn from '../join';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function join<TOuter, TInner, TKey, TResult>(inner: Iterable<TInner>, outerKeySelector: (element: TOuter) => TKey, innerKeySelector: (element: TInner) => TKey, resultSelector: (outer: TOuter, inner: TInner) => TResult): (source: Enumerable<TOuter>) => Enumerable<TResult> {
+    return (source) => source.lift<TResult>(joinFn.call(source.source, inner, outerKeySelector, innerKeySelector, resultSelector));
+}

src/hof/last.ts

@@ -0,0 +1,6 @@
+import lastFn from '../last';
+import { Enumerable } from '../internal/Enumerable';
+
+export default function last<TSource>(predicate?: (value: TSource) => boolean): (source: Enumerable<TSource>) => TSource {
+    return (source) => lastFn.call(source, predicate);
+}