[refactor] Members instead of Closures

index.js

@@ -22,37 +22,38 @@ class InfiniteListItem {
 	 * @memberof InfiniteListItem
 	 */
 	constructor(list, value, index) {
+		this.__list__ = list;
 		this.value = value;
 		this.index = index;
-		this.next = z => (!z ? list.get(index + 1) : list.get(index + z));
-		this.previous = z => (!z ? list.get(index - 1) : list.get(index - z));
+		this.next = z => (!z ? this.__list__.get(index + 1) : this.__list__.get(index + z));
+		this.previous = z => (!z ? this.__list__.get(index - 1) : this.__list__.get(index - z));
+	}
+}
 
-		// Check if Symbol exists
-		if (typeof Symbol !== 'undefined' && Symbol.iterator) {
+// Check if environment supports Symbol
+if (typeof Symbol !== 'undefined' && Symbol.iterator) {
 	/**
 	 * ES6 Symbol.iterator
 	 * @returns {Iterable.<InfiniteListItem>}
 	 */
-			this[Symbol.iterator] = () => ({
+	InfiniteListItem.prototype[Symbol.iterator] = () => ({
 		next: () => ({
-					value: list.get(index + 1),
+			value: this.__list__.get(index + 1),
 			done: false
 		})
 	});
-		}
-	}
+}
 
-	/**
+/**
  * toString method for pretty printing InfiniteListItem instance.
  * @returns {String} Decycled and beautified string
  * @memberof InfiniteListItem
  */
-	toString() {
+InfiniteListItem.prototype.toString = function () {
 	return ('InfiniteListItem [ .. ' +
 			stringify(this.value) +
-			' .. ]')
-	}
-}
+			' .. ]');
+};
 
 class InfiniteList {
 	/**
@@ -68,17 +69,61 @@ class InfiniteList {
 	 */
 	constructor(start, next) {
 
-		// Closure magic!
-		let cache = [];
-		let j = 0;
+		this.__start__ = start;
+		this.__next__ = next;
+		this.__cache__ = [];
 
+		if(typeof Proxy !== 'undefined')
+			return new Proxy(this, {
+				get: (obj, key) => {
+					if(key in obj) return obj[key];
+					const index = (
+						typeof key === 'string' && /^\d*$/g.test(key)
+					) ? parseInt(key) : undefined;
+					if(index) return obj['get'](index);
+				},
+				has: (obj, key) => {
+					const index = (
+						typeof key === 'string' && /^\d*$/g.test(key)
+					) ? parseInt(key) : undefined;
+					return (
+						(key in obj) ||
+						(areNumbers(index) &&
+							(index % 1 === 0) &&
+							(index >= 0))
+					)
+				},
+				enumerate: obj => obj.keys(),
+				ownKeys: obj => obj.keys(),
+			})
+	}
+}
+
+// Check if Symbol exists
+if (typeof Symbol !== 'undefined' && Symbol.iterator) {
 	/**
+	 * ES6 Symbol.iterator
+	 * @returns {Iterable.<InfiniteListItem>}
+	 * @memberof InfiniteList
+	 */
+	InfiniteList.prototype[Symbol.iterator] = function () {
+		let j = 0;
+		return {
+			next: () => ({
+				value: this.get(j++),
+				done: false
+			})
+		};
+	};
+}
+
+/**
  * Get InfiniteListItem at index.
  * @param {Number} index A non-negative integer representing index
  * @returns {InfiniteListItem}
  * @memberof InfiniteList
  */
-		this.get = function (index) {
+InfiniteList.prototype.get = function (index) {
 
 	// Validation
 	if (
@@ -87,6 +132,10 @@ class InfiniteList {
 		|| !areNumbers(index)
 	) return;
 
+	const start = this.__start__;
+	const next = this.__next__;
+	const cache = this.__cache__;
+
 	//TODO: Cache limiting. (Removed for unexpected behaviour)
 
 	// Initializing first item if it doesn't exist
@@ -108,59 +157,18 @@ class InfiniteList {
 					);
 	}
 	return new InfiniteListItem(this, cache[index], index);
-		}
+}
 
-		/**
+/**
  * Clear cache manually.
  * Forces destroy reference to cache, and creates a new cache.
  * Old cache will be GC'd.
  * @returns {undefined}
  * @memberof InfiniteList
  */
-		this.clearCache = () => (cache = [], undefined);
-
-		// Check if Symbol exists
-		if (typeof Symbol !== 'undefined' && Symbol.iterator) {
-			/**
-			 * ES6 Symbol.iterator
-			 * @returns {Iterable.<InfiniteListItem>}
-			 * @memberof InfiniteList
-			 */
-			this[Symbol.iterator] = function () {
-				return {
-					next: () => ({
-						value: this.get(j++),
-						done: false
-					})
-				};
-			};
-		}
-
-		if(typeof Proxy !== 'undefined')
-			return new Proxy(this, {
-				get: (obj, key) => {
-					if(key in obj) return obj[key];
-					const index = (
-						typeof key === 'string' && /^\d*$/g.test(key)
-					) ? parseInt(key) : undefined;
-					if(index) return obj['get'](index);
-				},
-				has: (obj, key) => {
-					const index = (
-						typeof key === 'string' && /^\d*$/g.test(key)
-					) ? parseInt(key) : undefined;
-					return (
-						(key in obj) ||
-						(areNumbers(index) &&
-							(index % 1 === 0) &&
-							(index >= 0))
-					)
-				},
-				enumerate: obj => obj.keys(),
-				ownKeys: obj => obj.keys(),
-			})
-	}
-}
+InfiniteList.prototype.clearCache = function () {
+	this.__cache__ = [];
+};
 
 /**
  * Takes a given number of elements from the InfiniteList.

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@codefeathers/infinity",
-  "version": "0.3.0",
+	"version": "0.4.0",
 	"description": "Infinitely generating linked list with memoisation (or an n-generator)",
 	"main": "es5/infinity.min.js",
 	"scripts": {