diff --git a/streamjs/streamjs-tests.ts b/streamjs/streamjs-tests.ts
index b1fba365cd..50a398418d 100644
--- a/streamjs/streamjs-tests.ts
+++ b/streamjs/streamjs-tests.ts
@@ -31,16 +31,62 @@ var strStream = numStream
 					.takeWhile(s => s.length < 5)
 					.takeWhile(/^aa.*$/)
 					.slice(5, 2)
-					.forEach(s => console.log(s))
 					;
 					
 var strArray = strStream.toArray();
 
+strStream.forEach(s => console.log(s));
+var opt: Stream.Optional<string> = strStream.findFirst();
+opt = strStream.findAny();
+opt = strStream.max();
+opt = strStream.max((s1, s2) => 0);
+opt = strStream.min();
+opt = strStream.min((s1, s2) => 0);
+
+var sum = numStream.sum();
+var avg = numStream.average();
+avg = numStream.avg();
+
+var count = numStream.count();
+count = numStream.size();
+
+var allMatch: boolean = numStream.allMatch(n => true);
+allMatch = strStream.allMatch(/^$/);
+
+var anyMatch: boolean = numStream.anyMatch(n => false);
+anyMatch = strStream.anyMatch(/^$/);
+
+var noneMatch: boolean = numStream.noneMatch(n => false);
+noneMatch = strStream.noneMatch(/^$/);
+
+sum = numStream.reduce(0, (n1, n2) => n1 + n2);
+opt = strStream.reduce((s1, s2) => s1 + s2);
+
 class MyList {
 	elems: any[];
+	name: string
 }
 
 var elems: any[];
-elems = Stream.make([new MyList, new MyList])
+
+var myStream = Stream.make([new MyList, new MyList]);
+elems = myStream
 	.flatMap(list => list.elems)
 	.toArray();
+	//.forEach(s => console.log(s));
+
+
+numStream.collect({
+	supplier: () => 0,
+	accumulator: (n1, n2) => n1 + n2,
+	finisher: n => n
+});
+
+var groupingResult = myStream.groupBy(lst => lst.name);
+var elems = groupingResult["hello"].elems;
+groupingResult = myStream.groupingBy(lst => lst.name);
+
+var mappingResult = myStream.toMap(lst => lst.name, (e1, e2) => e2);
+console.log(mappingResult["a"]);
+
+myStream.toMap(lst => lst.name);
diff --git a/streamjs/streamjs.d.ts b/streamjs/streamjs.d.ts
index 1ac6c534c8..1478d7a68d 100644
--- a/streamjs/streamjs.d.ts
+++ b/streamjs/streamjs.d.ts
@@ -10,15 +10,40 @@ declare class Stream<T> {
 	static rangeClosed (startInclusive: number, endInclusive: number): Stream<number>;
 	static generate <T> (supplier: () => T): Stream<T>;
 	
+	anyMatch(predicate: (elem: T) => boolean): boolean;
+	anyMatch(regexp: RegExp): boolean;
+	allMatch(predicate: (elem: T) => boolean): boolean;
+	allMatch(regexp: RegExp): boolean;
+	average(): number;
+	avg(): number;
+	collect(collector: Stream.Collector<T>): T;
+	count(): number;
 	distinct(): Stream<T>;
 	dropWhile(predicate: (elem: T) => boolean): Stream<T>;
 	dropWhile(regexp: RegExp): Stream<string>;
 	filter(predicate: (T) => boolean): Stream<T>;
+	findAny(): Stream.Optional<T>;
+	findFirst(): Stream.Optional<T>;
+	forEach(consumer: (elem: T) => void): void;
+	
+	groupBy(mapper: (elem: T) => string): Stream.GroupingResult<T>;
+	groupingBy(mapper: (elem: T) => string): Stream.GroupingResult<T>;
+	toMap(keyMapper: (elem: T) => string, mergeFunction?: (elem1: T, elem2: T) => T): T[];
+	
 	map <U> (mapper: (T) => U): Stream<U>;
+	max(): Stream.Optional<T>;
+	max(comparator: (e1: T, e2: T) => number): Stream.Optional<T>;
+	min(): Stream.Optional<T>;
+	min(comparator: (elem1: T, elem2: T) => number): Stream.Optional<T>;
+	noneMatch(predicate: (elem: T) => boolean): boolean;
+	noneMatch(regexp: RegExp): boolean;
 	flatMap <U> (mapper: (T) => U[]): Stream<U>;
 	limit(limit: number): Stream<T>;
 	peek(consumer: (elem: T) => void ): Stream<T>;
+	reduce(identity: T, accumulator: (e1: T, e2: T) => T): T;
+	reduce(accumulator: (e1: T, e2: T) => T): Stream.Optional<T>;
 	reverse(): Stream<T>;
+	size(): number;
 	sorted(): Stream<T>;
 	sorted(comparator: (e1: T, e2: T) => number): Stream<T>;
 	sort(): Stream<T>;
@@ -26,7 +51,24 @@ declare class Stream<T> {
 	shuffle(): Stream<T>;
 	skip(n: number): Stream<T>;
 	slice(begin, end): Stream<T>;
+	sum(): T;
 	takeWhile(predicate: (elem: T) => boolean): Stream<T>;
 	takeWhile(regexp: RegExp): Stream<string>;
 	toArray(): T[];
 }
+
+declare module Stream {
+	export interface GroupingResult<T> {
+		[index: string]: T
+	}
+
+	export interface Collector<T> {
+		supplier(): T;
+		accumulator(e1: T, e2: T): T;
+		finisher(result: T): T
+	}
+
+	export class Optional<T> {
+
+	}
+}