rename to stream and add bind method and empty stream

Author: waksana

README.md

@@ -1,10 +1,10 @@
-# list8
-a js data structure for infinity lazy list and some method to control the list. 8 indicates infinity
+# Stream
+a js data structure for stream processing.
 
 ## Usage
 
 ```javascript
-const {cons} = require('list8');
+const {cons} = require('.');
 
 // you can put tail in () => ... to reference self
 const N = cons(1, () => N.map(n => n + 1));

index.js

@@ -1,4 +1,4 @@
-module.exports = class LazyList {
+module.exports = class Stream {
   constructor(fn) {
     this.visited = false;
     this.fn = fn;
@@ -16,26 +16,39 @@ module.exports = class LazyList {
   get tail() {
     return this.value[1];
   }
+  get isEmpty() {
+    return this.value === Stream.EmptySymbol;
+  }
+
+  static EmptySymbol = Symbol('Empty');
+
+  static Empty = new Stream(() => Stream.EmptySymbol);
 
   static cons(head, tail) {
-    if(tail instanceof LazyList)
-      return new LazyList(() => [head, tail]);
+    if(tail instanceof Stream)
+      return new Stream(() => [head, tail]);
     else
-      return new LazyList(() => [head, tail()]);
+      return new Stream(() => [head, tail()]);
   }
 
-  drop(num) {
-    return new LazyList(() => {
-      return num === 0 ? this.value : this.tail.drop(num - 1).value;
-    });
+  static list(x, ...xs) {
+    if(x === undefined)
+      return Stream.Empty;
+    return Stream.cons(x, Stream.list(...xs));
   }
 
   map(fn) {
-    return new LazyList(() => [fn(this.head), this.tail.map(fn)]);
+    return new Stream(() => {
+      if(this.isEmpty)
+        return this.value;
+      return [fn(this.head), this.tail.map(fn)];
+    });
   }
 
   filter(fn) {
-    return new LazyList(() => {
+    return new Stream(() => {
+      if(this.isEmpty)
+        return this.value;
       if(fn(this.head))
         return [this.head, this.tail.filter(fn)];
       else
@@ -44,13 +57,51 @@ module.exports = class LazyList {
   }
 
   zipWith(otherList, fn) {
-    return new LazyList(() => {
+    return new Stream(() => {
+      if(this.isEmpty || otherList.isEmpty)
+        return Stream.Empty.value;
       return [fn(this.head, otherList.head), this.tail.zipWith(otherList.tail, fn)];
     });
   }
 
+  concat(otherList) {
+    return new Stream(() => {
+      if(this.isEmpty)
+        return otherList.value;
+      return [this.head, this.tail.concat(otherList)];
+    });
+  }
+
+  flatten() {
+    return new Stream(() => {
+      if(this.isEmpty)
+        return this.value;
+      return this.head.concat(this.tail.flatten()).value;
+    });
+  }
+
+  bind(fn) {
+    return this.map(fn).flatten();
+  }
+
+  drop(num) {
+    return new Stream(() => {
+      if(this.isEmpty && num !== 0)
+        throw new Error('No more element to drop');
+      return num === 0 ? this.value: this.tail.drop(num - 1).value
+    });
+  }
+
   take(num) {
     if(num === 0) return [];
-    else return [this.head].concat(this.tail.take(num - 1));
+    if(this.isEmpty)
+      throw new Error('No more element to take');
+    return [this.head].concat(this.tail.take(num - 1));
+  }
+
+  takeAll() {
+    if(this.isEmpty)
+      return [];
+    return [this.head].concat(this.tail.takeAll());
   }
 }

package.json

@@ -1,14 +1,14 @@
 {
-  "name": "list8",
+  "name": "stream",
   "version": "0.0.2",
-  "description": "a js structure for infinite lazy list and some method to control the list Edit",
+  "description": "a js data structure for stream processing.",
   "main": "index.js",
   "scripts": {
     "test": "node test.js"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/waksana/infinite-list.git"
+    "url": "git+https://github.com/waksana/stream.git"
   },
   "keywords": [
     "list",
@@ -17,7 +17,7 @@
   "author": "[email protected]",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/waksana/infinite-list/issues"
+    "url": "https://github.com/waksana/stream/issues"
   },
-  "homepage": "https://github.com/waksana/infinite-list#readme"
+  "homepage": "https://github.com/waksana/stream#readme"
 }

test.js

@@ -1,6 +1,9 @@
-var {cons} = require('.');
+var {cons, list, Empty} = require('.');
 var assert = require('assert');
 
+cons(n => [1, n.map()]);
+(ones) => cons(1, ones);
+
 var N = cons(1, () => N.map(n => n + 1)); //nature number list
 var ones = cons(1, () => ones);
 
@@ -22,3 +25,16 @@ assert.deepEqual(prime.take(5), [2, 3, 5, 7, 11]);
 var fibs = cons(0, cons(1, () => fibs.zipWith(fibs.tail, (a, b) => a + b)));
 
 assert.deepEqual(fibs.take(6), [0, 1, 1, 2, 3, 5]);
+
+//flatten
+assert.deepEqual(ones.map(o => list(1,2,3)).flatten().take(5), [1, 2, 3, 1, 2]);
+
+//bind
+assert.deepEqual(list(1, 2, 3).bind(x => list(9, 8, 7).bind(y => x + y > 9 ? list({x, y}) : Empty)).takeAll(), [
+  { x: 1, y: 9 },
+  { x: 2, y: 9 },
+  { x: 2, y: 8 },
+  { x: 3, y: 9 },
+  { x: 3, y: 8 },
+  { x: 3, y: 7 }
+]);