Merge 63d1900 into b3ec243

README.md

@@ -30,7 +30,7 @@ But This-Binding Syntax is still in a proposal yet.
 So you can not use this without transpiring.
 
 You can use the extension modules instead of this.
-The extension modules add methods to `Enumerable` class.
+The extension modules add the method to `Enumerable` class.
 
 ```javascript
 import Enumerable from '@emonkak/enumerable';
@@ -45,6 +45,26 @@ new Enumerable([1, 2, 3])
     .toArray();  // => [4]
 ```
 
+You can also use the HOF(higher-order function) modules.
+
+The HOF modules provides the function that returns the function that receives the `Enumerable` and returns the result.
+This function can uses by `pipe()` and `let()` method of `Enumerable`.
+
+```
+import Enumerable from '@emonkak/enumerable';
+
+import select from '@emonkak/enumerable/hof/select';
+import where from '@emonkak/enumerable/hof/where';
+import toArray from '@emonkak/enumerable/hof/toArray';
+
+new Enumerable([1, 2, 3])
+    .pipe(
+        where((x) => x % 2 === 0),
+        select((x) => x * 2)
+    )
+    .let(toArray());  // => [4]
+```
+
 ## API
 
 - `aggregate<TSource, TAccumulate>(this: Iterable<TSource>, seed: TAccumulate, func: (result: TAccumulate, element: TSource) => TAccumulate): TAccumulate`

package.json

@@ -1,10 +1,10 @@
 {
   "name": "@emonkak/enumerable",
-  "version": "2.1.0",
-  "description": "LINQ to Object for JavaScript that provides the individual methods as a module.",
+  "version": "2.2.0",
+  "description": "Provides the individual methods of LINQ as a module",
   "main": "index.js",
   "scripts": {
-    "build": "tsc --declaration && cp LICENSE README.md package.json dist/src/",
+    "build": "tsc --declaration && cp LICENSE README.md package.json dist/",
     "cover": "nyc npm test",
     "lint": "tslint 'src/**/*.ts' 'test/**/*.ts'",
     "prebuild": "rm -f -r dist",
@@ -20,18 +20,18 @@
   },
   "homepage": "https://github.com/emonkak/js-enumerable",
   "devDependencies": {
-    "@types/mocha": "^2.2.43",
-    "@types/node": "^8.0.31",
-    "@types/sinon": "^2.3.5",
+    "@types/mocha": "^2.2.41",
+    "@types/node": "^7.0.31",
+    "@types/sinon": "^2.3.1",
     "cash-cp": "^0.2.0",
     "cash-rm": "^0.2.0",
-    "coveralls": "^3.0.0",
-    "mocha": "^3.5.3",
-    "nyc": "^11.2.1",
-    "sinon": "^4.0.0",
-    "ts-node": "^3.3.0",
-    "tslint": "^5.7.0",
-    "typescript": "^2.5.3"
+    "coveralls": "^2.13.1",
+    "mocha": "^3.4.2",
+    "nyc": "^11.0.2",
+    "sinon": "^2.3.4",
+    "ts-node": "^3.0.6",
+    "tslint": "^5.4.3",
+    "typescript": "^2.3.4"
   },
   "nyc": {
     "extension": [

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,5 @@
+import aggregateFn from '../aggregate';
+
+export default function aggregate<TSource, TAccumulate>(seed: TAccumulate, func: (result: TAccumulate, element: TSource) => TAccumulate): (source: Iterable<TSource>) => TAccumulate {
+    return (source) => aggregateFn.call(source, seed, func);
+}

src/hof/all.ts

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

src/hof/any.ts

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

src/hof/average.ts

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

src/hof/buffer.ts

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

src/hof/catch.ts

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

src/hof/concat.ts

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

src/hof/count.ts

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

src/hof/defaultIfEmpty.ts

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

src/hof/distinct.ts

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

src/hof/distinctUntilChanged.ts

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

src/hof/do.ts

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

src/hof/doWhile.ts

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

src/hof/elementAt.ts

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

src/hof/elementAtOrDefault.ts

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

src/hof/except.ts

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

src/hof/finally.ts

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

src/hof/first.ts

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

src/hof/firstOrDefault.ts

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

src/hof/forEach.ts

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

src/hof/groupBy.ts

@@ -0,0 +1,7 @@
+import groupByFn from '../groupBy';
+
+export default function groupBy<TSource, TKey>(keySelector: (element: TSource) => TKey): (source: Iterable<TSource>) => Iterable<[TKey, TSource]>;
+export default function groupBy<TSource, TKey, TElement>(keySelector: (element: TSource) => TKey, elementSelector: (element: TSource) => TElement): (source: Iterable<TSource>) => Iterable<[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: Iterable<TSource>) => Iterable<TResult> {
+    return (source) => groupByFn.call(source, keySelector, elementSelector, resultSelector);
+}

src/hof/groupJoin.ts

@@ -0,0 +1,5 @@
+import groupJoinFn from '../groupJoin';
+
+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: Iterable<TOuter>) => Iterable<TResult> {
+    return (source) => groupJoinFn.call(source, inner, outerKeySelector, innerKeySelector, resultSelector);
+}

src/hof/ignoreElements.ts

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

src/hof/intersect.ts

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

src/hof/isEmpty.ts

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

src/hof/join.ts

@@ -0,0 +1,5 @@
+import joinFn from '../join';
+
+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: Iterable<TOuter>) => Iterable<TResult> {
+    return (source) => joinFn.call(source, inner, outerKeySelector, innerKeySelector, resultSelector);
+}

src/hof/last.ts

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