streamjs nonterminal operation definitions

streamjs/streamjs-tests.ts

@@ -1,6 +1,7 @@
 // <reference file="streamjs.d.ts" />
 
-var numStream = Stream.make(10, 20);
+var numStream: Stream<number>;
+// numStream = Stream.make(10, 20);
 numStream = Stream.make([10, 20]);
 numStream = Stream.range(1, 5);
 numStream = Stream.rangeClosed(1, 5);
@@ -9,3 +10,36 @@ Stream.generate(function() {
 	return 1;
 });
 Stream.generate(() => 1);
+
+var comparator = (s1, s2) => 0;
+
+numStream = numStream.filter(n => n % 2 == 0);
+var strStream = numStream
+					.dropWhile((n) => n % 2 == 0)
+					.map(n => "number " + n)
+					.dropWhile(/^$/)
+					.limit(100)
+					.sorted()
+					.sort()
+					.sorted(comparator)
+					.sort(comparator)
+					.shuffle()
+					.reverse()
+					.distinct()
+					.skip(5)
+					.peek(s => console.log(s))
+					.takeWhile(s => s.length < 5)
+					.takeWhile(/^aa.*$/)
+					.slice(5, 2)
+					;
+					
+var strArray = strStream.toArray();
+
+class MyList {
+	elems: any[];
+}
+
+var elems: any[];
+elems = Stream.make([new MyList, new MyList])
+	.flatMap(list => list.elems)
+	.toArray();

streamjs/streamjs.d.ts

@@ -4,9 +4,29 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 declare class Stream<T> {
-	static make<T> (...elems: T[]): Stream<T>;
-	static make<T>(elems: T[]): Stream<T>;
-	static range<T>(startInclusive: number, endExclusive: number): Stream<T>;
-	static rangeClosed<T>(startInclusive: number, endInclusive: number): Stream<T>;
-	static generate<T>(supplier: () => T): Stream<T>;
+	// static make <T> (...elems: T[]): Stream<T>;
+	static make <T> (elems: T[]): Stream<T>;
+	static range (startInclusive: number, endExclusive: number): Stream<number>;
+	static rangeClosed (startInclusive: number, endInclusive: number): Stream<number>;
+	static generate <T> (supplier: () => T): Stream<T>;
+	
+	distinct(): Stream<T>;
+	dropWhile(predicate: (elem: T) => boolean): Stream<T>;
+	dropWhile(regexp: RegExp): Stream<string>;
+	filter(predicate: (T) => boolean): Stream<T>;
+	map <U> (mapper: (T) => U): Stream<U>;
+	flatMap <U> (mapper: (T) => U[]): Stream<U>;
+	limit(limit: number): Stream<T>;
+	peek(consumer: (elem: T) => void ): Stream<T>;
+	reverse(): Stream<T>;
+	sorted(): Stream<T>;
+	sorted(comparator: (e1: T, e2: T) => number): Stream<T>;
+	sort(): Stream<T>;
+	sort(comparator: (e1: T, e2: T) => number): Stream<T>;
+	shuffle(): Stream<T>;
+	skip(n: number): Stream<T>;
+	slice(begin, end): Stream<T>;
+	takeWhile(predicate: (elem: T) => boolean): Stream<T>;
+	takeWhile(regexp: RegExp): Stream<string>;
+	toArray(): T[];
 }