Refactor

.travis.yml

@@ -1,8 +1,6 @@
 language: node_js
 node_js:
   - '6'
-  - '5'
-  - '4'
 before_script:
   - $(npm bin)/tsc --version
 script:

src/count.ts

@@ -7,8 +7,9 @@ export default function count<TSource>(this: Iterable<TSource>, predicate?: (ite
         return count;
     } else {
         if (Array.isArray(this)) return (this as Array<TSource>).length;
+        const iterator = this[Symbol.iterator]();
         let count = 0;
-        for (const element of this) {
+        for (let result = iterator.next(); !result.done; result = iterator.next()) {
             count++;
         }
         return count;

src/internal/OrderedEnumerable.ts

@@ -1,6 +1,4 @@
-import IComparer from './IComparer';
 import OrderedPartition from './OrderedPartition';
-import Partition from './Partition';
 import partialQuickSort from './partialQuickSort';
 import quickSelect from './quickSelect';
 import { Enumerable } from './Enumerable';
@@ -306,7 +304,7 @@ export default class OrderedEnumerable<TElement, TKey> extends Enumerable<TEleme
         return array.sort(comparer);
     }
 
-    toArrayPartition(minIndex: number, maxIndex: number): TElement[] {
+    toArrayInPartition(minIndex: number, maxIndex: number): TElement[] {
         const array = Array.from(this._source);
         const count = array.length;
 
@@ -325,7 +323,7 @@ export default class OrderedEnumerable<TElement, TKey> extends Enumerable<TEleme
         return [];
     }
 
-    private _getComparer(next?: IComparer<TElement>): IComparer<TElement> {
+    private _getComparer(next?: (first: TElement, second: TElement) => number): (first: TElement, second: TElement) => number {
         if (!next) next = () => 0;
         const comparer = (first: TElement, second: TElement): number => {
             const firstKey = this._keySelector(first);

src/internal/OrderedPartition.ts

@@ -11,7 +11,7 @@ export default class OrderedPartition<TElement> extends Partition<TElement> {
     }
 
     [Symbol.iterator](): Iterator<TElement> {
-        return this._source.toArrayPartition(this._minIndex, this._maxIndex)[Symbol.iterator]();
+        return this._source.toArrayInPartition(this._minIndex, this._maxIndex)[Symbol.iterator]();
     }
 
     skip(count: number): Partition<TElement> {

src/internal/partialQuickSort.ts

@@ -1,7 +1,6 @@
-import IComparer from './IComparer';
 import pivotPosition from './pivotPosition';
 
-export default function partialQuickSort<T>(array: Array<T>, comparer: IComparer<T>, left: number, right: number, minIndex: number, maxIndex: number): void {
+export default function partialQuickSort<T>(array: Array<T>, comparer: (first: T, second: T) => number, left: number, right: number, minIndex: number, maxIndex: number): void {
     if (left < right) {
         const pivotIndex = left + ((right - left) >> 1);
         const pivotNewIndex = pivotPosition(array, comparer, left, right, pivotIndex);

src/internal/pivotPosition.ts

@@ -1,6 +1,4 @@
-import IComparer from './IComparer';
-
-export default function pivotPosition<T>(array: Array<T>, comparer: IComparer<T>, left: number, right: number, pivotIndex: number): number {
+export default function pivotPosition<T>(array: Array<T>, comparer: (first: T, second: T) => number, left: number, right: number, pivotIndex: number): number {
     const pivotValue = array[pivotIndex];
 
     swap(array, right, pivotIndex);

src/internal/quickSelect.ts

@@ -1,7 +1,6 @@
-import IComparer from './IComparer';
 import pivotPosition from './pivotPosition';
 
-export default function quickSelect<T>(array: Array<T>, comparer: IComparer<T>, left: number, right: number, n: number): T {
+export default function quickSelect<T>(array: Array<T>, comparer: (first: T, second: T) => number, left: number, right: number, n: number): T {
     while (true) {
         if (left === right) return array[left];
 

test/aggregateTest.ts

@@ -1,5 +1,5 @@
-import Enumerable from '../src';
 import * as assert from 'assert';
+import Enumerable from '../src/';
 
 describe('aggregate()', () => {
     it('should applies an accumulator function over a sequence', () => {

test/allTest.ts

@@ -1,5 +1,5 @@
-import Enumerable from '../src';
 import * as assert from 'assert';
+import Enumerable from '../src/';
 
 describe('all()', () => {
     it('should determines whether all elements of a sequence satisfy a condition', () => {

test/anyTest.ts

@@ -1,5 +1,5 @@
-import Enumerable from '../src';
 import * as assert from 'assert';
+import Enumerable from '../src/';
 
 describe('any()', () => {
     it('should determines whether a sequence contains any elements', () => {

test/averageTest.ts

@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('average()', () => {
     it('should computes the average of a sequence of numbers', () => {

test/bufferTest.ts

@@ -1,20 +1,20 @@
 import * as assert from 'assert';
-import buffer from '../src/buffer';
+import Enumerable from '../src/';
 
 describe('buffer()', () => {
     it('should generates a sequence of non-overlapping adjacent buffers over the source sequence', () => {
         const xs = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-        assert.deepEqual(Array.from(buffer.call(xs, 3)), [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]);
-        assert.deepEqual(Array.from(buffer.call(xs, 5)), [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]);
-        assert.deepEqual(Array.from(buffer.call([], 5)), []);
-        assert.deepEqual(Array.from(buffer.call(xs, 3, 2)), [[0, 1, 2], [2, 3, 4], [4, 5, 6], [6, 7, 8], [8, 9]]);
-        assert.deepEqual(Array.from(buffer.call(xs, 3, 4)), [[0, 1, 2], [4, 5, 6], [8, 9]]);
+        assert.deepEqual(new Enumerable(xs).buffer(3).toArray(), [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]);
+        assert.deepEqual(new Enumerable(xs).buffer(5).toArray(), [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]]);
+        assert.deepEqual(new Enumerable([]).buffer(5).toArray(), []);
+        assert.deepEqual(new Enumerable(xs).buffer(3, 2).toArray(), [[0, 1, 2], [2, 3, 4], [4, 5, 6], [6, 7, 8], [8, 9]]);
+        assert.deepEqual(new Enumerable(xs).buffer(3, 4).toArray(), [[0, 1, 2], [4, 5, 6], [8, 9]]);
     });
 
     it('should throws the exception if "count" or "skip" arguments is less than or equal to 0', () => {
-        assert.throws(() => Array.from(buffer.call([], 0)), RangeError);
-        assert.throws(() => Array.from(buffer.call([], 1, 0)), RangeError);
-        assert.throws(() => Array.from(buffer.call([], 0, 1)), RangeError);
-        assert.throws(() => Array.from(buffer.call([], 0, 0)), RangeError);
+        assert.throws(() => new Enumerable([]).buffer(0).toArray(), RangeError);
+        assert.throws(() => new Enumerable([]).buffer(1, 0).toArray(), RangeError);
+        assert.throws(() => new Enumerable([]).buffer(0, 1).toArray(), RangeError);
+        assert.throws(() => new Enumerable([]).buffer(0, 0).toArray(), RangeError);
     });
 });

test/catchTest.ts

@@ -1,6 +1,6 @@
 import * as assert from 'assert';
 import * as sinon from 'sinon';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('catch()', () => {
     it('should creates a sequence that corresponds to the source sequence', () => {

test/concatTest.ts

@@ -1,10 +1,10 @@
 import * as assert from 'assert';
-import concat from '../src/concat';
+import Enumerable from '../src/';
 
 describe('concat()', () => {
     it('should concatenates two sequences', () => {
-        assert.deepEqual(Array.from(concat.call([], [])), []);
-        assert.deepEqual(Array.from(concat.call([1, 2, 3], [4, 5, 6])), [1, 2, 3, 4, 5, 6]);
-        assert.deepEqual(Array.from(concat.call([1, 2, 3], [4, 5, 6], [7, 8, 9])), [1, 2, 3, 4, 5, 6, 7, 8, 9]);
+        assert.deepEqual(new Enumerable([]).concat([]).toArray(), []);
+        assert.deepEqual(new Enumerable([1, 2, 3]).concat([4, 5, 6]).toArray(), [1, 2, 3, 4, 5, 6]);
+        assert.deepEqual(new Enumerable([1, 2, 3]).concat([4, 5, 6], [7, 8, 9]).toArray(), [1, 2, 3, 4, 5, 6, 7, 8, 9]);
     });
 });

test/countTest.ts

@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('count()', () => {
     it('should returns the number of elements in a sequence', () => {

test/defaultIfEmptyTest.ts

@@ -1,12 +1,12 @@
 import * as assert from 'assert';
-import defaultIfEmpty from '../src/defaultIfEmpty';
+import Enumerable from '../src/';
 
 describe('defaultIfEmpty()', () => {
     it('should returns the elements of the specified sequence', () => {
-        assert.deepEqual(Array.from(defaultIfEmpty.call([1, 2, 3], 123)), [1, 2, 3]);
+        assert.deepEqual(new Enumerable([1, 2, 3]).defaultIfEmpty(123).toArray(), [1, 2, 3]);
     });
 
     it('should returns the specified value in a singleton collection if the sequence is empty', () => {
-        assert.deepEqual(Array.from(defaultIfEmpty.call([], 123)), [123]);
+        assert.deepEqual(new Enumerable([]).defaultIfEmpty(123).toArray(), [123]);
     });
 });

test/distinctTest.ts

@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('distinct()', () => {
     it('should returns distinct elements from a sequence', () => {

test/distinctUntilChangedTest.ts

@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('distinctUntilChanged()', () => {
     it('should returns consecutive distinct elements', () => {

test/doTest.ts

@@ -1,6 +1,6 @@
 import * as assert from 'assert';
 import * as sinon from 'sinon';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('do()', () => {
     it('should lazily invokes an action for each value in the sequence, and executes an action upon exceptional termination', () => {

test/doWhileTest.ts

@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('doWhile()', () => {
     it('should generates an enumerable sequence by repeating a source sequence as long as the given loop postcondition holds', () => {

test/elementAtOrDefaultTest.ts

@@ -1,43 +1,40 @@
 import * as assert from 'assert';
-import elementAtOrDefault from '../src/elementAtOrDefault';
-import orderBy from '../src/orderBy';
-import skip from '../src/skip';
-import take from '../src/take';
+import Enumerable from '../src/';
 
 describe('elementAtOrDefault()', () => {
     it('should returns the element at a specified index in a sequence', () => {
         const xs = [1, 2, 3, 4];
 
-        assert.strictEqual(elementAtOrDefault.call(xs, 0), 1);
-        assert.strictEqual(elementAtOrDefault.call(xs, 1), 2);
-        assert.strictEqual(elementAtOrDefault.call(xs, 2), 3);
-        assert.strictEqual(elementAtOrDefault.call(xs, 3), 4);
+        assert.strictEqual(new Enumerable(xs).elementAtOrDefault(0), 1);
+        assert.strictEqual(new Enumerable(xs).elementAtOrDefault(1), 2);
+        assert.strictEqual(new Enumerable(xs).elementAtOrDefault(2), 3);
+        assert.strictEqual(new Enumerable(xs).elementAtOrDefault(3), 4);
     });
 
     it('should returns a default value if the index is out of range', () => {
         const xs = [1, 2, 3, 4];
 
-        assert.strictEqual(elementAtOrDefault.call(xs, 4, 123), 123);
-        assert.strictEqual(elementAtOrDefault.call(xs, 4), null);
+        assert.strictEqual(new Enumerable(xs).elementAtOrDefault(4, 123), 123);
+        assert.strictEqual(new Enumerable(xs).elementAtOrDefault(4), null);
     });
 
     it('should works with orderBy()', () => {
         const xs = [3, 2, 4, 1];
 
-        assert.strictEqual(elementAtOrDefault.call(orderBy.call(xs), 0), 1);
-        assert.strictEqual(elementAtOrDefault.call(orderBy.call(xs), 1), 2);
-        assert.strictEqual(elementAtOrDefault.call(orderBy.call(xs), 2), 3);
-        assert.strictEqual(elementAtOrDefault.call(orderBy.call(xs), 3), 4);
-        assert.strictEqual(elementAtOrDefault.call(take.call(orderBy.call(xs), 2), 0), 1);
-        assert.strictEqual(elementAtOrDefault.call(take.call(orderBy.call(xs), 2), 1), 2);
-        assert.strictEqual(elementAtOrDefault.call(skip.call(orderBy.call(xs), 2), 0), 3);
-        assert.strictEqual(elementAtOrDefault.call(skip.call(orderBy.call(xs), 2), 1), 4);
-        assert.strictEqual(elementAtOrDefault.call(skip.call(take.call(orderBy.call(xs), 2), 1), 0), 2);
-        assert.strictEqual(elementAtOrDefault.call(take.call(skip.call(orderBy.call(xs), 2), 1), 0), 3);
+        assert.strictEqual(new Enumerable(xs).orderBy().elementAtOrDefault(0), 1);
+        assert.strictEqual(new Enumerable(xs).orderBy().elementAtOrDefault(1), 2);
+        assert.strictEqual(new Enumerable(xs).orderBy().elementAtOrDefault(2), 3);
+        assert.strictEqual(new Enumerable(xs).orderBy().elementAtOrDefault(3), 4);
+        assert.strictEqual(new Enumerable(xs).orderBy().take(2).elementAtOrDefault(0), 1);
+        assert.strictEqual(new Enumerable(xs).orderBy().take(2).elementAtOrDefault(1), 2);
+        assert.strictEqual(new Enumerable(xs).orderBy().skip(2).elementAtOrDefault(0), 3);
+        assert.strictEqual(new Enumerable(xs).orderBy().skip(2).elementAtOrDefault(1), 4);
+        assert.strictEqual(new Enumerable(xs).orderBy().take(2).skip(1).elementAtOrDefault(0), 2);
+        assert.strictEqual(new Enumerable(xs).orderBy().skip(2).take(1).elementAtOrDefault(0), 3);
 
-        assert.strictEqual(elementAtOrDefault.call(orderBy.call(xs), 4, 123), 123);
-        assert.strictEqual(elementAtOrDefault.call(take.call(orderBy.call(xs), 2), 3, 123), 123);
-        assert.strictEqual(elementAtOrDefault.call(skip.call(take.call(orderBy.call(xs), 2), 1), 1, 123), 123);
-        assert.strictEqual(elementAtOrDefault.call(take.call(skip.call(orderBy.call(xs), 2), 1), 1, 123), 123);
+        assert.strictEqual(new Enumerable(xs).orderBy().elementAtOrDefault(4, 123), 123);
+        assert.strictEqual(new Enumerable(xs).orderBy().take(2).elementAtOrDefault(3, 123), 123);
+        assert.strictEqual(new Enumerable(xs).orderBy().take(2).skip(1).elementAtOrDefault(1, 123), 123);
+        assert.strictEqual(new Enumerable(xs).orderBy().skip(2).take(1).elementAtOrDefault(1, 123), 123);
     });
 });

test/elementAtTest.ts

@@ -1,42 +1,39 @@
 import * as assert from 'assert';
-import elementAt from '../src/elementAt';
-import orderBy from '../src/orderBy';
-import skip from '../src/skip';
-import take from '../src/take';
+import Enumerable from '../src/';
 
 describe('elementAt()', () => {
     it('should returns the element at a specified index in a sequence', () => {
         const xs = [1, 2, 3, 4];
 
-        assert.strictEqual(elementAt.call(xs, 0), 1);
-        assert.strictEqual(elementAt.call(xs, 1), 2);
-        assert.strictEqual(elementAt.call(xs, 2), 3);
-        assert.strictEqual(elementAt.call(xs, 3), 4);
+        assert.strictEqual(new Enumerable(xs).elementAt(0), 1);
+        assert.strictEqual(new Enumerable(xs).elementAt(1), 2);
+        assert.strictEqual(new Enumerable(xs).elementAt(2), 3);
+        assert.strictEqual(new Enumerable(xs).elementAt(3), 4);
     });
 
     it('should throws the exception if index is out of range', () => {
         const xs = [1, 2, 3, 4];
 
-        assert.throws(() => elementAt.call(xs, 4));
+        assert.throws(() => new Enumerable(xs).elementAt(4));
     });
 
     it('should works with orderBy()', () => {
         const xs = [3, 2, 4, 1];
 
-        assert.strictEqual(elementAt.call(orderBy.call(xs), 0), 1);
-        assert.strictEqual(elementAt.call(orderBy.call(xs), 1), 2);
-        assert.strictEqual(elementAt.call(orderBy.call(xs), 2), 3);
-        assert.strictEqual(elementAt.call(orderBy.call(xs), 3), 4);
-        assert.strictEqual(elementAt.call(take.call(orderBy.call(xs), 2), 0), 1);
-        assert.strictEqual(elementAt.call(take.call(orderBy.call(xs), 2), 1), 2);
-        assert.strictEqual(elementAt.call(skip.call(orderBy.call(xs), 2), 0), 3);
-        assert.strictEqual(elementAt.call(skip.call(orderBy.call(xs), 2), 1), 4);
-        assert.strictEqual(elementAt.call(skip.call(take.call(orderBy.call(xs), 2), 1), 0), 2);
-        assert.strictEqual(elementAt.call(take.call(skip.call(orderBy.call(xs), 2), 1), 0), 3);
+        assert.strictEqual(new Enumerable(xs).orderBy().elementAt(0), 1);
+        assert.strictEqual(new Enumerable(xs).orderBy().elementAt(1), 2);
+        assert.strictEqual(new Enumerable(xs).orderBy().elementAt(2), 3);
+        assert.strictEqual(new Enumerable(xs).orderBy().elementAt(3), 4);
+        assert.strictEqual(new Enumerable(xs).orderBy().take(2).elementAt(0), 1);
+        assert.strictEqual(new Enumerable(xs).orderBy().take(2).elementAt(1), 2);
+        assert.strictEqual(new Enumerable(xs).orderBy().skip(2).elementAt(0), 3);
+        assert.strictEqual(new Enumerable(xs).orderBy().skip(2).elementAt(1), 4);
+        assert.strictEqual(new Enumerable(xs).orderBy().take(2).skip(1).elementAt(0), 2);
+        assert.strictEqual(new Enumerable(xs).orderBy().skip(2).take(1).elementAt(0), 3);
 
-        assert.throws(() => elementAt.call(orderBy.call(xs), 4));
-        assert.throws(() => elementAt.call(take.call(orderBy.call(xs), 2), 3));
-        assert.throws(() => elementAt.call(skip.call(take.call(orderBy.call(xs), 2), 1), 1));
-        assert.throws(() => elementAt.call(take.call(skip.call(orderBy.call(xs), 2), 1), 1));
+        assert.throws(() => new Enumerable(xs).orderBy().elementAt(4));
+        assert.throws(() => new Enumerable(xs).orderBy().take(2).elementAt(3));
+        assert.throws(() => new Enumerable(xs).orderBy().take(2).skip(1).elementAt(1));
+        assert.throws(() => new Enumerable(xs).orderBy().skip(2).take(1).elementAt(1));
     });
 });

test/exceptTest.ts

@@ -1,11 +1,11 @@
 import * as assert from 'assert';
-import except from '../src/except';
+import Enumerable from '../src/';
 
 describe('except()', () => {
     it('should produces the set difference of two sequences', () => {
-        assert.deepEqual(Array.from(except.call([], [])), []);
-        assert.deepEqual(Array.from(except.call([1, 2, 3, 4, 5, 6], [2, 3, 4])), [1, 5, 6]);
-        assert.deepEqual(Array.from(except.call([1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6], [2, 3, 4])), [1, 5, 6]);
-        assert.deepEqual(Array.from(except.call([2, 3, 4], [1, 2, 3, 4, 5, 6])), []);
+        assert.deepEqual(new Enumerable([]).except([]).toArray(), []);
+        assert.deepEqual(new Enumerable([1, 2, 3, 4, 5, 6]).except([2, 3, 4]).toArray(), [1, 5, 6]);
+        assert.deepEqual(new Enumerable([1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]).except([2, 3, 4]).toArray(), [1, 5, 6]);
+        assert.deepEqual(new Enumerable([2, 3, 4]).except([1, 2, 3, 4, 5, 6]).toArray(), []);
     });
 });

test/finallyTest.ts

@@ -1,12 +1,12 @@
 import * as assert from 'assert';
 import * as sinon from 'sinon';
-import _finally from '../src/finally';
+import Enumerable from '../src/';
 
 describe('finally()', () => {
     it('should creates a sequence whose termination or disposal of an enumerator causes a finally action to be executed', () => {
         const source1 = [1, 2, 3];
         const finallyAction1 = sinon.spy();
-        assert.deepEqual(Array.from(_finally.call(source1, finallyAction1)), [1, 2, 3]);
+        assert.deepEqual(new Enumerable(source1).finally(finallyAction1).toArray(), [1, 2, 3]);
         sinon.assert.called(finallyAction1);
 
         const source2 = {
@@ -18,7 +18,7 @@ describe('finally()', () => {
             }
         };
         const finallyAction2 = sinon.spy();
-        assert.throws(() => Array.from(_finally.call(source2, finallyAction2)));
+        assert.throws(() => new Enumerable(source2).finally(finallyAction2).toArray());
         sinon.assert.called(finallyAction2);
     });
 });

test/firstOrDefaultTest.ts

@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('firstOrDefault()', () => {
     it('should returns the first element of a sequence', () => {