diff --git a/.travis.yml b/.travis.yml
index bf1485d..77c5717 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,8 +1,6 @@
 language: node_js
 node_js:
   - '6'
-  - '5'
-  - '4'
 before_script:
   - $(npm bin)/tsc --version
 script:
diff --git a/src/count.ts b/src/count.ts
index 42a5a71..9fc4b63 100644
--- a/src/count.ts
+++ b/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;
diff --git a/src/internal/IComparer.ts b/src/internal/IComparer.ts
deleted file mode 100644
index a6bb4c3..0000000
--- a/src/internal/IComparer.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-type IComparer<T> = (first: T, second: T) => number;
-
-export default IComparer;
diff --git a/src/internal/OrderedEnumerable.ts b/src/internal/OrderedEnumerable.ts
index 87e31d2..94a45e5 100644
--- a/src/internal/OrderedEnumerable.ts
+++ b/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);
diff --git a/src/internal/OrderedPartition.ts b/src/internal/OrderedPartition.ts
index cdc4e13..55003d5 100644
--- a/src/internal/OrderedPartition.ts
+++ b/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> {
diff --git a/src/internal/partialQuickSort.ts b/src/internal/partialQuickSort.ts
index 8585982..257b499 100644
--- a/src/internal/partialQuickSort.ts
+++ b/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);
diff --git a/src/internal/pivotPosition.ts b/src/internal/pivotPosition.ts
index d368f4e..9fe5944 100644
--- a/src/internal/pivotPosition.ts
+++ b/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);
diff --git a/src/internal/quickSelect.ts b/src/internal/quickSelect.ts
index 9ecdcec..9996075 100644
--- a/src/internal/quickSelect.ts
+++ b/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];
 
diff --git a/test/aggregateTest.ts b/test/aggregateTest.ts
index 55cc0bb..748c9d0 100644
--- a/test/aggregateTest.ts
+++ b/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', () => {
diff --git a/test/allTest.ts b/test/allTest.ts
index b73955d..f25cad3 100644
--- a/test/allTest.ts
+++ b/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', () => {
diff --git a/test/anyTest.ts b/test/anyTest.ts
index ec5b41e..785eec7 100644
--- a/test/anyTest.ts
+++ b/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', () => {
diff --git a/test/averageTest.ts b/test/averageTest.ts
index e70f87e..9e14c76 100644
--- a/test/averageTest.ts
+++ b/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', () => {
diff --git a/test/bufferTest.ts b/test/bufferTest.ts
index 8c282c7..395703e 100644
--- a/test/bufferTest.ts
+++ b/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);
     });
 });
diff --git a/test/catchTest.ts b/test/catchTest.ts
index 78bf2cc..4a13b5d 100644
--- a/test/catchTest.ts
+++ b/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', () => {
diff --git a/test/concatTest.ts b/test/concatTest.ts
index 667e7e5..eb4896c 100644
--- a/test/concatTest.ts
+++ b/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]);
     });
 });
diff --git a/test/countTest.ts b/test/countTest.ts
index bc105f4..c4420fa 100644
--- a/test/countTest.ts
+++ b/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', () => {
diff --git a/test/defaultIfEmptyTest.ts b/test/defaultIfEmptyTest.ts
index 8a48982..6575d33 100644
--- a/test/defaultIfEmptyTest.ts
+++ b/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]);
     });
 });
diff --git a/test/distinctTest.ts b/test/distinctTest.ts
index 8fb7ad0..02a95f7 100644
--- a/test/distinctTest.ts
+++ b/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', () => {
diff --git a/test/distinctUntilChangedTest.ts b/test/distinctUntilChangedTest.ts
index e6327b2..dd3ca1d 100644
--- a/test/distinctUntilChangedTest.ts
+++ b/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', () => {
diff --git a/test/doTest.ts b/test/doTest.ts
index d3e81f0..7e18116 100644
--- a/test/doTest.ts
+++ b/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', () => {
diff --git a/test/doWhileTest.ts b/test/doWhileTest.ts
index 10881e3..bc41236 100644
--- a/test/doWhileTest.ts
+++ b/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', () => {
diff --git a/test/elementAtOrDefaultTest.ts b/test/elementAtOrDefaultTest.ts
index bd0b291..8120758 100644
--- a/test/elementAtOrDefaultTest.ts
+++ b/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);
     });
 });
diff --git a/test/elementAtTest.ts b/test/elementAtTest.ts
index 923bdb5..3c64140 100644
--- a/test/elementAtTest.ts
+++ b/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));
     });
 });
diff --git a/test/exceptTest.ts b/test/exceptTest.ts
index 5258a46..1a961a4 100644
--- a/test/exceptTest.ts
+++ b/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(), []);
     });
 });
diff --git a/test/finallyTest.ts b/test/finallyTest.ts
index cc874e0..8009e82 100644
--- a/test/finallyTest.ts
+++ b/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);
     });
 });
diff --git a/test/firstOrDefaultTest.ts b/test/firstOrDefaultTest.ts
index ab2ff2e..923fc30 100644
--- a/test/firstOrDefaultTest.ts
+++ b/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', () => {
diff --git a/test/firstTest.ts b/test/firstTest.ts
index 50581d5..4e64501 100644
--- a/test/firstTest.ts
+++ b/test/firstTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('first()', () => {
     it('should returns the first element of a sequence', () => {
diff --git a/test/forEachTest.ts b/test/forEachTest.ts
index 8b825e5..8bac435 100644
--- a/test/forEachTest.ts
+++ b/test/forEachTest.ts
@@ -1,5 +1,5 @@
 import * as sinon from 'sinon';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('forEach()', () => {
     it('should enumerates the sequence and invokes the given action for each value in the sequence', () => {
diff --git a/test/groupByTest.ts b/test/groupByTest.ts
index b4936bc..0d298df 100644
--- a/test/groupByTest.ts
+++ b/test/groupByTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('groupBy()', () => {
     it('should groups the elements of a sequence according to a specified key selector function', () => {
diff --git a/test/groupJoinTest.ts b/test/groupJoinTest.ts
index ccd016c..9355229 100644
--- a/test/groupJoinTest.ts
+++ b/test/groupJoinTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('groupJoin()', () => {
     it('should correlates the elements of two sequences based on equality of keys and groups the results', () => {
diff --git a/test/ignoreElementsTest.ts b/test/ignoreElementsTest.ts
index 0eab654..13b946b 100644
--- a/test/ignoreElementsTest.ts
+++ b/test/ignoreElementsTest.ts
@@ -1,6 +1,6 @@
 import * as assert from 'assert';
 import * as sinon from 'sinon';
-import ignoreElements from '../src/ignoreElements';
+import Enumerable from '../src/';
 
 describe('ignoreElements()', () => {
     it('should ignores all elements in the source sequence', () => {
@@ -12,7 +12,7 @@ describe('ignoreElements()', () => {
         const source = {
             [Symbol.iterator]: iterator
         };
-        assert.deepEqual(Array.from(ignoreElements.call(source)), []);
+        assert.deepEqual(new Enumerable(source).ignoreElements().toArray(), []);
         sinon.assert.notCalled(iterator);
     });
 });
diff --git a/test/intersectTest.ts b/test/intersectTest.ts
index 09b585c..db22348 100644
--- a/test/intersectTest.ts
+++ b/test/intersectTest.ts
@@ -1,12 +1,10 @@
 import * as assert from 'assert';
-import intersect from '../src/intersect';
+import Enumerable from '../src/';
 
 describe('intersect()', () => {
     it('should Produces the set intersection of two sequences by using the default equality comparer to compare values', () => {
         const xs = [44, 26, 92, 30, 71, 38];
         const ys = [39, 59, 83, 47, 26, 4, 30];
-        const result = intersect.call(xs, ys);
-
-        assert.deepEqual(Array.from(result), [26, 30]);
+        assert.deepEqual(new Enumerable(xs).intersect(ys).toArray(), [26, 30]);
     });
 });
diff --git a/test/isEmptyTest.ts b/test/isEmptyTest.ts
index dde87a5..edac95a 100644
--- a/test/isEmptyTest.ts
+++ b/test/isEmptyTest.ts
@@ -1,9 +1,9 @@
 import * as assert from 'assert';
-import isEmpty from '../src/isEmpty';
+import Enumerable from '../src/';
 
 describe('isEmpty()', () => {
     it('should determines whether an enumerable sequence is empty', () => {
-        assert.strictEqual(isEmpty.call([]), true);
-        assert.strictEqual(isEmpty.call([1, 2, 3]), false);
+        assert.strictEqual(new Enumerable([]).isEmpty(), true);
+        assert.strictEqual(new Enumerable([1, 2, 3]).isEmpty(), false);
     });
 });
diff --git a/test/joinTest.ts b/test/joinTest.ts
index d800805..e7e38e7 100644
--- a/test/joinTest.ts
+++ b/test/joinTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('join()', () => {
     it('should correlates the elements of two sequences based on matching keys', () => {
diff --git a/test/lastOrDefaultTest.ts b/test/lastOrDefaultTest.ts
index 46d7610..d4b161c 100644
--- a/test/lastOrDefaultTest.ts
+++ b/test/lastOrDefaultTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('lastOrDefault()', () => {
     it('should returns the last element of a sequence', () => {
diff --git a/test/lastTest.ts b/test/lastTest.ts
index 69bcefe..702daf2 100644
--- a/test/lastTest.ts
+++ b/test/lastTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src'
+import Enumerable from '../src/';
 
 describe('last()', () => {
     it('should returns the last element of a sequence', () => {
diff --git a/test/maxByTest.ts b/test/maxByTest.ts
index fbbb2c3..4df83a1 100644
--- a/test/maxByTest.ts
+++ b/test/maxByTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('maxBy()', () => {
     it('should returns the elements with the minimum key value by using the default comparer to compare key values', () => {
diff --git a/test/maxTest.ts b/test/maxTest.ts
index bf7b895..313ede3 100644
--- a/test/maxTest.ts
+++ b/test/maxTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('max()', () => {
     it('should returns the maximum value in a sequence of values', () => {
diff --git a/test/memoizeTest.ts b/test/memoizeTest.ts
index 98d7d96..60212b9 100644
--- a/test/memoizeTest.ts
+++ b/test/memoizeTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('memoize()', () => {
     it('should creates a buffer with a view over the source sequence', () => {
diff --git a/test/minByTest.ts b/test/minByTest.ts
index 8bd78b9..1681f2d 100644
--- a/test/minByTest.ts
+++ b/test/minByTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('minBy()', () => {
     it('should returns the elements with the maximum key value by using the default comparer to compare key values', () => {
diff --git a/test/minTest.ts b/test/minTest.ts
index 87bdf96..bc0bf57 100644
--- a/test/minTest.ts
+++ b/test/minTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('min()', () => {
     it('should returns the minimum value in a sequence of values', () => {
diff --git a/test/onErrorResumeNextTest.ts b/test/onErrorResumeNextTest.ts
index 6cc2e68..7acb534 100644
--- a/test/onErrorResumeNextTest.ts
+++ b/test/onErrorResumeNextTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import onErrorResumeNext from '../src/onErrorResumeNext';
+import Enumerable from '../src/';
 
 describe('onErrorResumeNext()', () => {
     it('should creates a sequence that concatenates both given sequences', () => {
@@ -11,6 +11,6 @@ describe('onErrorResumeNext()', () => {
             }
         };
         const ys = [3, 4];
-        assert.deepEqual(Array.from(onErrorResumeNext.call(xs, ys)), [1, 2, 3, 4]);
+        assert.deepEqual(new Enumerable(xs).onErrorResumeNext(ys).toArray(), [1, 2, 3, 4]);
     });
 });
diff --git a/test/orderByDescendingTest.ts b/test/orderByDescendingTest.ts
index 6b651c8..2a4d9eb 100644
--- a/test/orderByDescendingTest.ts
+++ b/test/orderByDescendingTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('orderByDescending()', () => {
     it('should sorts the elements of a sequence in ascending order according to a key', () => {
diff --git a/test/orderByTest.ts b/test/orderByTest.ts
index 52dc9af..109551d 100644
--- a/test/orderByTest.ts
+++ b/test/orderByTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('orderBy()', () => {
     it('should sorts the elements of a sequence in ascending order according to a key', () => {
diff --git a/test/repeatTest.ts b/test/repeatTest.ts
index f4aaaee..3aa779a 100644
--- a/test/repeatTest.ts
+++ b/test/repeatTest.ts
@@ -1,9 +1,9 @@
 import * as assert from 'assert';
-import repeat from '../src/repeat';
+import Enumerable from '../src/';
 
 describe('repeat()', () => {
     it('should generates a sequence by repeating the given value.', () => {
-        const iterator1 = repeat.call([1, 2, 3])[Symbol.iterator]();
+        const iterator1 = new Enumerable([1, 2, 3]).repeat()[Symbol.iterator]();
         assert.deepEqual(iterator1.next(), { done: false, value: 1 });
         assert.deepEqual(iterator1.next(), { done: false, value: 2 });
         assert.deepEqual(iterator1.next(), { done: false, value: 3 });
@@ -12,7 +12,7 @@ describe('repeat()', () => {
         assert.deepEqual(iterator1.next(), { done: false, value: 3 });
         assert.deepEqual(iterator1.next(), { done: false, value: 1 });
 
-        const iterator2 = repeat.call([1, 2, 3], 2)[Symbol.iterator]();
+        const iterator2 = new Enumerable([1, 2, 3]).repeat(2)[Symbol.iterator]();
         assert.deepEqual(iterator2.next(), { done: false, value: 1 });
         assert.deepEqual(iterator2.next(), { done: false, value: 2 });
         assert.deepEqual(iterator2.next(), { done: false, value: 3 });
diff --git a/test/retryTest.ts b/test/retryTest.ts
index f0406e3..605d12c 100644
--- a/test/retryTest.ts
+++ b/test/retryTest.ts
@@ -1,10 +1,10 @@
 import * as assert from 'assert';
-import retry from '../src/retry';
+import Enumerable from '../src/';
 
 describe('retry()', () => {
     it('should creates a sequence that retries enumerating the source sequence as long as an error occurs.', () => {
-        assert.deepEqual(Array.from(retry.call([1, 2, 3])), [1, 2, 3]);
-        assert.deepEqual(Array.from(retry.call([1, 2, 3], 2)), [1, 2, 3]);
+        assert.deepEqual(new Enumerable([1, 2, 3]).retry().toArray(), [1, 2, 3]);
+        assert.deepEqual(new Enumerable([1, 2, 3]).retry(2).toArray(), [1, 2, 3]);
 
         const xs = {
             [Symbol.iterator]: function*() {
@@ -14,7 +14,7 @@ describe('retry()', () => {
                 throw new Error()
             }
         };
-        const iterator = retry.call(xs, 2)[Symbol.iterator]();
+        const iterator = new Enumerable(xs).retry(2)[Symbol.iterator]();
         assert.deepEqual(iterator.next(), { done: false, value: 1 });
         assert.deepEqual(iterator.next(), { done: false, value: 2 });
         assert.deepEqual(iterator.next(), { done: false, value: 3 });
diff --git a/test/reverseTest.ts b/test/reverseTest.ts
index 6052205..46e37f1 100644
--- a/test/reverseTest.ts
+++ b/test/reverseTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('reverse()', () => {
     it('should inverts the order of the elements in a sequence', () => {
diff --git a/test/scanTest.ts b/test/scanTest.ts
index 6085212..7fae4a4 100644
--- a/test/scanTest.ts
+++ b/test/scanTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src/Enumerable';
+import Enumerable from '../src/';
 
 describe('scan()', () => {
     it('should generates a sequence of accumulated values', () => {
diff --git a/test/selectManyTest.ts b/test/selectManyTest.ts
index ca1b57e..20706cc 100644
--- a/test/selectManyTest.ts
+++ b/test/selectManyTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('selectMany()', () => {
     it('should projects each element of a sequence to a Iterable<T>', () => {
diff --git a/test/selectTest.ts b/test/selectTest.ts
index aa97138..a780aa0 100644
--- a/test/selectTest.ts
+++ b/test/selectTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('select()', () => {
     it('should projects each element of a sequence', () => {
diff --git a/test/singleOrDefaultTest.ts b/test/singleOrDefaultTest.ts
index b6b5612..d1471c6 100644
--- a/test/singleOrDefaultTest.ts
+++ b/test/singleOrDefaultTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('singleOrDefault()', () => {
     it('should returns the only element of a sequence', () => {
diff --git a/test/singleTest.ts b/test/singleTest.ts
index 2a1a4d4..4bea3be 100644
--- a/test/singleTest.ts
+++ b/test/singleTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('single()', () => {
     it('should returns the only element of a sequence', () => {
diff --git a/test/skipLastTest.ts b/test/skipLastTest.ts
index cb1e815..c300866 100644
--- a/test/skipLastTest.ts
+++ b/test/skipLastTest.ts
@@ -1,10 +1,10 @@
 import * as assert from 'assert';
-import skipLast from '../src/skipLast';
+import Enumerable from '../src/';
 
 describe('skipLast()', () => {
     it('should bypasses a specified number of contiguous elements from the end of the sequence', () => {
-        assert.deepEqual(Array.from(skipLast.call([], 1)), []);
-        assert.deepEqual(Array.from(skipLast.call([0, 1, 2, 3, 4], 0)), [0, 1, 2, 3, 4]);
-        assert.deepEqual(Array.from(skipLast.call([0, 1, 2, 3, 4], 3)), [0, 1]);
+        assert.deepEqual(new Enumerable([]).skipLast(1).toArray(), []);
+        assert.deepEqual(new Enumerable([0, 1, 2, 3, 4]).skipLast(0).toArray(), [0, 1, 2, 3, 4]);
+        assert.deepEqual(new Enumerable([0, 1, 2, 3, 4]).skipLast(3).toArray(), [0, 1]);
     });
 });
diff --git a/test/skipTest.ts b/test/skipTest.ts
index 7c55af0..18b170e 100644
--- a/test/skipTest.ts
+++ b/test/skipTest.ts
@@ -1,11 +1,11 @@
 import * as assert from 'assert';
-import skip from '../src/skip';
+import Enumerable from '../src/';
 
 describe('skip()', () => {
     it('should bypasses a specified number of elements in a sequence and then returns the remaining elements', () => {
-        assert.deepEqual(Array.from(skip.call([], 1)), []);
-        assert.deepEqual(Array.from(skip.call([0, 1, 2, 3, 4], 0)), [0, 1, 2, 3, 4]);
-        assert.deepEqual(Array.from(skip.call([0, 1, 2, 3, 4], 3)), [3, 4]);
-        assert.deepEqual(Array.from(skip.call([0, 1, 2, 3, 4][Symbol.iterator](), 3)), [3, 4]);
+        assert.deepEqual(new Enumerable([]).skip(1).toArray(), []);
+        assert.deepEqual(new Enumerable([0, 1, 2, 3, 4]).skip(0).toArray(), [0, 1, 2, 3, 4]);
+        assert.deepEqual(new Enumerable([0, 1, 2, 3, 4]).skip(3).toArray(), [3, 4]);
+        assert.deepEqual(new Enumerable([0, 1, 2, 3, 4][Symbol.iterator]()).skip(3).toArray(), [3, 4]);
     });
 });
diff --git a/test/skipWhileTest.ts b/test/skipWhileTest.ts
index d2d5a51..f36fd2e 100644
--- a/test/skipWhileTest.ts
+++ b/test/skipWhileTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('skipWhile()', () => {
     it('should skip elements in a sequence while a condition is true', () => {
diff --git a/test/startWithTest.ts b/test/startWithTest.ts
index e72bdd9..f39327c 100644
--- a/test/startWithTest.ts
+++ b/test/startWithTest.ts
@@ -1,8 +1,8 @@
 import * as assert from 'assert';
-import startWith from '../src/startWith';
+import Enumerable from '../src/';
 
 describe('startWith()', () => {
     it('should returns the source sequence prefixed with the specified value', () => {
-        assert.deepEqual(Array.from(startWith.call([0, 1, 2, 3, 4], 0)), [0, 0, 1, 2, 3, 4]);
+        assert.deepEqual(new Enumerable([0, 1, 2, 3, 4]).startWith(0).toArray(), [0, 0, 1, 2, 3, 4]);
     });
 });
diff --git a/test/static/catchTest.ts b/test/static/catchTest.ts
index 930ee2e..55abed7 100644
--- a/test/static/catchTest.ts
+++ b/test/static/catchTest.ts
@@ -1,5 +1,5 @@
-import Enumerable from '../../src';
 import * as assert from 'assert';
+import Enumerable from '../../src/';
 
 describe('catch()', () => {
     it('should creates a sequence by concatenating source sequences until a source sequence completes successfully', () => {
diff --git a/test/static/concatTest.ts b/test/static/concatTest.ts
index 2b92af0..91fa9dc 100644
--- a/test/static/concatTest.ts
+++ b/test/static/concatTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../../src';
+import Enumerable from '../../src/';
 
 describe('concat()', () => {
     it('should concatenates two sequences', () => {
diff --git a/test/static/deferTest.ts b/test/static/deferTest.ts
index bd93c0a..fcbcf17 100644
--- a/test/static/deferTest.ts
+++ b/test/static/deferTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../../src';
+import Enumerable from '../../src/';
 
 describe('defer()', () => {
     it('should creates an enumerable sequence based on an enumerable factory function', () => {
diff --git a/test/static/generateTest.ts b/test/static/generateTest.ts
index 1deeaf5..05b4ddc 100644
--- a/test/static/generateTest.ts
+++ b/test/static/generateTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../../src';
+import Enumerable from '../../src/';
 
 describe('generate()', () => {
     it('should generates a sequence by mimicking a for loop', () => {
diff --git a/test/static/ifTest.ts b/test/static/ifTest.ts
index 7ab48c4..f263011 100644
--- a/test/static/ifTest.ts
+++ b/test/static/ifTest.ts
@@ -1,5 +1,5 @@
-import Enumerable from '../../src';
 import * as assert from 'assert';
+import Enumerable from '../../src/';
 
 describe('if()', () => {
     it('should returns an enumerable sequence based on the evaluation result of the given condition', () => {
diff --git a/test/static/rangeTest.ts b/test/static/rangeTest.ts
index e78bd3a..ece291b 100644
--- a/test/static/rangeTest.ts
+++ b/test/static/rangeTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../../src';
+import Enumerable from '../../src/';
 
 describe('range()', () => {
     it('should generates a sequence of integral numbers within a specified range', () => {
diff --git a/test/static/repeatTest.ts b/test/static/repeatTest.ts
index d6b8518..889aa30 100644
--- a/test/static/repeatTest.ts
+++ b/test/static/repeatTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../../src';
+import Enumerable from '../../src/';
 
 describe('repeat()', () => {
     it('should generates a sequence by repeating the given value', () => {
diff --git a/test/static/returnTest.ts b/test/static/returnTest.ts
index b3c6b2c..c1bfa4f 100644
--- a/test/static/returnTest.ts
+++ b/test/static/returnTest.ts
@@ -1,5 +1,5 @@
-import Enumerable from '../../src';
 import * as assert from 'assert';
+import Enumerable from '../../src/';
 
 describe('return()', () => {
     it('should returns a sequence with a single element.', () => {
diff --git a/test/static/zipTest.ts b/test/static/zipTest.ts
index 0861feb..a36da92 100644
--- a/test/static/zipTest.ts
+++ b/test/static/zipTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../../src';
+import Enumerable from '../../src/';
 
 describe('zip()', () => {
     it('should applies a specified function to the corresponding elements of two sequences', () => {
diff --git a/test/sumTest.ts b/test/sumTest.ts
index b775d35..bd25f79 100644
--- a/test/sumTest.ts
+++ b/test/sumTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('sum()', () => {
     it('should computes the sum of a sequence of numeric values', () => {
diff --git a/test/takeLastTest.ts b/test/takeLastTest.ts
index f3fe704..fc5f4df 100644
--- a/test/takeLastTest.ts
+++ b/test/takeLastTest.ts
@@ -1,10 +1,11 @@
 import * as assert from 'assert';
-import takeLast from '../src/takeLast';
+import Enumerable from '../src/';
 
 describe('takeLast()', () => {
     it('should returns a specified number of contiguous elements from the end of the sequence', () => {
-        assert.deepEqual(Array.from(takeLast.call([1, 2, 3, 4, 5], 0)), []);
-        assert.deepEqual(Array.from(takeLast.call([1, 2, 3, 4, 5], 5)), [1, 2, 3, 4, 5]);
-        assert.deepEqual(Array.from(takeLast.call([1, 2, 3, 4, 5], 3)), [3, 4, 5]);
+        const xs = [1, 2, 3, 4, 5];
+        assert.deepEqual(new Enumerable(xs).takeLast(0).toArray(), []);
+        assert.deepEqual(new Enumerable(xs).takeLast(5).toArray(), [1, 2, 3, 4, 5]);
+        assert.deepEqual(new Enumerable(xs).takeLast(3).toArray(), [3, 4, 5]);
     });
 });
diff --git a/test/takeTest.ts b/test/takeTest.ts
index d6497d7..4e224cf 100644
--- a/test/takeTest.ts
+++ b/test/takeTest.ts
@@ -1,16 +1,14 @@
 import * as assert from 'assert';
-import orderBy from '../src/orderBy';
-import skip from '../src/skip';
-import take from '../src/take';
+import Enumerable from '../src/';
 
 describe('take()', () => {
     it('should returns a specified number of contiguous elements from the start of a sequence', () => {
-        assert.deepEqual(Array.from(take.call([1, 2, 3, 4], 2)), [1, 2]);
-        assert.deepEqual(Array.from(take.call([1, 2, 3, 4], 0)), []);
+        assert.deepEqual(new Enumerable([1, 2, 3, 4]).take(2).toArray(), [1, 2]);
+        assert.deepEqual(new Enumerable([1, 2, 3, 4]).take(0).toArray(), []);
     });
 
     it('should works with orderBy()', () => {
-        assert.deepEqual(Array.from(take.call(orderBy.call([3, 2, 4, 1]), 2)), [1, 2]);
-        assert.deepEqual(Array.from(take.call(orderBy.call([]), 2)), []);
+        assert.deepEqual(new Enumerable([3, 2, 4, 1]).orderBy().take(2).toArray(), [1, 2]);
+        assert.deepEqual(new Enumerable([]).orderBy().take(2).toArray(), []);
     });
 });
diff --git a/test/takeWhileTest.ts b/test/takeWhileTest.ts
index 1580608..478eb78 100644
--- a/test/takeWhileTest.ts
+++ b/test/takeWhileTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('takeWhile()', () => {
     it('should yield elements from a sequence while a condition is true', () => {
diff --git a/test/toArrayTest.ts b/test/toArrayTest.ts
index fae0280..cb75cc8 100644
--- a/test/toArrayTest.ts
+++ b/test/toArrayTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('toArray()', () => {
     it('should creates a Array<T> from Iterable<T>', () => {
diff --git a/test/toDictionaryTest.ts b/test/toDictionaryTest.ts
index 6b36928..a9f36cb 100644
--- a/test/toDictionaryTest.ts
+++ b/test/toDictionaryTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('toDictionary()', () => {
     it('should creates a Map<T> from Iterable<T>', () => {
diff --git a/test/toLookupTest.ts b/test/toLookupTest.ts
index 97bb13d..48d8d5d 100644
--- a/test/toLookupTest.ts
+++ b/test/toLookupTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('toLookup()', () => {
     it('should creates a generic Map<TKey, TElement> from an Iterable<T>', () => {
diff --git a/test/unionTest.ts b/test/unionTest.ts
index aa90655..2e09238 100644
--- a/test/unionTest.ts
+++ b/test/unionTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('union()', () => {
     it('should produces the set union of two sequences', () => {
diff --git a/test/whereTest.ts b/test/whereTest.ts
index 4cd867b..cd3b49e 100644
--- a/test/whereTest.ts
+++ b/test/whereTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('where()', () => {
     it('should filters a sequence of values based on a predicate', () => {
diff --git a/test/whileTest.ts b/test/whileTest.ts
index b2e74e0..b11deb1 100644
--- a/test/whileTest.ts
+++ b/test/whileTest.ts
@@ -1,5 +1,5 @@
-import Enumerable from '../src';
 import * as assert from 'assert';
+import Enumerable from '../src/';
 
 describe('while()', () => {
     it('should generates an enumerable sequence by repeating a source sequence as long as the given loop condition holds', () => {
diff --git a/test/zipTest.ts b/test/zipTest.ts
index 0970b23..f6869b5 100644
--- a/test/zipTest.ts
+++ b/test/zipTest.ts
@@ -1,5 +1,5 @@
 import * as assert from 'assert';
-import Enumerable from '../src';
+import Enumerable from '../src/';
 
 describe('zip()', () => {
     it('should applies a specified function to the corresponding elements of two sequences', () => {
diff --git a/tsconfig.json b/tsconfig.json
index d4a728d..cd50d0e 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -5,6 +5,7 @@
     "noImplicitAny": true,
     "noImplicitReturns": true,
     "noImplicitThis": true,
+    "noUnusedLocals": true,
     "outDir": "dist",
     "sourceMap": true,
     "target": "es2015"