From 52038eca8702b6d3b1c1a75dd08c1a6d784b7b89 Mon Sep 17 00:00:00 2001 From: Bence Eros Date: Fri, 12 Jun 2015 19:00:56 +0200 Subject: [PATCH 01/17] adding Stream class with static factory methods --- streamjs/streamjs-tests.ts | 11 +++++++++++ streamjs/streamjs.d.ts | 12 ++++++++++++ 2 files changed, 23 insertions(+) create mode 100644 streamjs/streamjs-tests.ts create mode 100644 streamjs/streamjs.d.ts diff --git a/streamjs/streamjs-tests.ts b/streamjs/streamjs-tests.ts new file mode 100644 index 0000000000..e5d9338515 --- /dev/null +++ b/streamjs/streamjs-tests.ts @@ -0,0 +1,11 @@ +// + +var numStream = Stream.make(10, 20); +numStream = Stream.make([10, 20]); +numStream = Stream.range(1, 5); +numStream = Stream.rangeClosed(1, 5); + +Stream.generate(function() { + return 1; +}); +Stream.generate(() => 1); diff --git a/streamjs/streamjs.d.ts b/streamjs/streamjs.d.ts new file mode 100644 index 0000000000..e1fe425366 --- /dev/null +++ b/streamjs/streamjs.d.ts @@ -0,0 +1,12 @@ +// Type definitions for streamjs 1.4.0 +// Project: http://streamjs.org/ +// Definitions by: Bence Eros +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare class Stream { + static make (...elems: T[]): Stream; + static make(elems: T[]): Stream; + static range(startInclusive: number, endExclusive: number): Stream; + static rangeClosed(startInclusive: number, endInclusive: number): Stream; + static generate(supplier: () => T): Stream; +} From a90baa3446ca61e406957a6bbde40d438c462231 Mon Sep 17 00:00:00 2001 From: Bence Eros Date: Fri, 12 Jun 2015 22:36:12 +0200 Subject: [PATCH 02/17] streamjs nonterminal operation definitions --- streamjs/streamjs-tests.ts | 36 +++++++++++++++++++++++++++++++++++- streamjs/streamjs.d.ts | 30 +++++++++++++++++++++++++----- 2 files changed, 60 insertions(+), 6 deletions(-) diff --git a/streamjs/streamjs-tests.ts b/streamjs/streamjs-tests.ts index e5d9338515..55bad2bd5f 100644 --- a/streamjs/streamjs-tests.ts +++ b/streamjs/streamjs-tests.ts @@ -1,6 +1,7 @@ // -var numStream = Stream.make(10, 20); +var numStream: Stream; +// 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(); diff --git a/streamjs/streamjs.d.ts b/streamjs/streamjs.d.ts index e1fe425366..1ac6c534c8 100644 --- a/streamjs/streamjs.d.ts +++ b/streamjs/streamjs.d.ts @@ -4,9 +4,29 @@ // Definitions: https://github.com/borisyankov/DefinitelyTyped declare class Stream { - static make (...elems: T[]): Stream; - static make(elems: T[]): Stream; - static range(startInclusive: number, endExclusive: number): Stream; - static rangeClosed(startInclusive: number, endInclusive: number): Stream; - static generate(supplier: () => T): Stream; + // static make (...elems: T[]): Stream; + static make (elems: T[]): Stream; + static range (startInclusive: number, endExclusive: number): Stream; + static rangeClosed (startInclusive: number, endInclusive: number): Stream; + static generate (supplier: () => T): Stream; + + distinct(): Stream; + dropWhile(predicate: (elem: T) => boolean): Stream; + dropWhile(regexp: RegExp): Stream; + filter(predicate: (T) => boolean): Stream; + map (mapper: (T) => U): Stream; + flatMap (mapper: (T) => U[]): Stream; + limit(limit: number): Stream; + peek(consumer: (elem: T) => void ): Stream; + reverse(): Stream; + sorted(): Stream; + sorted(comparator: (e1: T, e2: T) => number): Stream; + sort(): Stream; + sort(comparator: (e1: T, e2: T) => number): Stream; + shuffle(): Stream; + skip(n: number): Stream; + slice(begin, end): Stream; + takeWhile(predicate: (elem: T) => boolean): Stream; + takeWhile(regexp: RegExp): Stream; + toArray(): T[]; } From 57e6fd59b6e022b7ead2acc5811dc27363971a03 Mon Sep 17 00:00:00 2001 From: Bence Eros Date: Fri, 12 Jun 2015 23:19:26 +0200 Subject: [PATCH 03/17] streamjs nonterminal operation definitions --- streamjs/streamjs-tests.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/streamjs/streamjs-tests.ts b/streamjs/streamjs-tests.ts index 55bad2bd5f..b1fba365cd 100644 --- a/streamjs/streamjs-tests.ts +++ b/streamjs/streamjs-tests.ts @@ -31,6 +31,7 @@ var strStream = numStream .takeWhile(s => s.length < 5) .takeWhile(/^aa.*$/) .slice(5, 2) + .forEach(s => console.log(s)) ; var strArray = strStream.toArray(); From b68684ddb562dbda02a4c10608e2f32e0b95f636 Mon Sep 17 00:00:00 2001 From: Bence Eros Date: Sat, 13 Jun 2015 01:55:29 +0200 Subject: [PATCH 04/17] adding most is the terminal operations - partitioning, joining, and iterator ops are missing yet --- streamjs/streamjs-tests.ts | 50 ++++++++++++++++++++++++++++++++++++-- streamjs/streamjs.d.ts | 42 ++++++++++++++++++++++++++++++++ 2 files changed, 90 insertions(+), 2 deletions(-) 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 = 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 { static rangeClosed (startInclusive: number, endInclusive: number): Stream; static generate (supplier: () => T): Stream; + 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; + count(): number; distinct(): Stream; dropWhile(predicate: (elem: T) => boolean): Stream; dropWhile(regexp: RegExp): Stream; filter(predicate: (T) => boolean): Stream; + findAny(): Stream.Optional; + findFirst(): Stream.Optional; + forEach(consumer: (elem: T) => void): void; + + groupBy(mapper: (elem: T) => string): Stream.GroupingResult; + groupingBy(mapper: (elem: T) => string): Stream.GroupingResult; + toMap(keyMapper: (elem: T) => string, mergeFunction?: (elem1: T, elem2: T) => T): T[]; + map (mapper: (T) => U): Stream; + max(): Stream.Optional; + max(comparator: (e1: T, e2: T) => number): Stream.Optional; + min(): Stream.Optional; + min(comparator: (elem1: T, elem2: T) => number): Stream.Optional; + noneMatch(predicate: (elem: T) => boolean): boolean; + noneMatch(regexp: RegExp): boolean; flatMap (mapper: (T) => U[]): Stream; limit(limit: number): Stream; peek(consumer: (elem: T) => void ): Stream; + reduce(identity: T, accumulator: (e1: T, e2: T) => T): T; + reduce(accumulator: (e1: T, e2: T) => T): Stream.Optional; reverse(): Stream; + size(): number; sorted(): Stream; sorted(comparator: (e1: T, e2: T) => number): Stream; sort(): Stream; @@ -26,7 +51,24 @@ declare class Stream { shuffle(): Stream; skip(n: number): Stream; slice(begin, end): Stream; + sum(): T; takeWhile(predicate: (elem: T) => boolean): Stream; takeWhile(regexp: RegExp): Stream; toArray(): T[]; } + +declare module Stream { + export interface GroupingResult { + [index: string]: T + } + + export interface Collector { + supplier(): T; + accumulator(e1: T, e2: T): T; + finisher(result: T): T + } + + export class Optional { + + } +} From bcbadfe78abb6c0ed3979cafd9994c04e48648e0 Mon Sep 17 00:00:00 2001 From: Bence Eros Date: Sun, 14 Jun 2015 00:05:19 +0200 Subject: [PATCH 05/17] adding partitioning and joining operators to Stream, and the nonterminals of Optional --- streamjs/streamjs-tests.ts | 32 ++++++++++++++++++++++++++++++++ streamjs/streamjs.d.ts | 38 +++++++++++++++++++++++++++++++++++--- 2 files changed, 67 insertions(+), 3 deletions(-) diff --git a/streamjs/streamjs-tests.ts b/streamjs/streamjs-tests.ts index 50a398418d..e59af31ae1 100644 --- a/streamjs/streamjs-tests.ts +++ b/streamjs/streamjs-tests.ts @@ -5,6 +5,7 @@ var numStream: Stream; numStream = Stream.make([10, 20]); numStream = Stream.range(1, 5); numStream = Stream.rangeClosed(1, 5); +// numStream = Stream.empty(); Stream.generate(function() { return 1; @@ -90,3 +91,34 @@ var mappingResult = myStream.toMap(lst => lst.name, (e1, e2) => e2); console.log(mappingResult["a"]); myStream.toMap(lst => lst.name); + +mappingResult = myStream.indexBy(lst => lst.name, (e1, e2) => e2); + +var partitionedNums: number[][] = numStream.partitioningBy(n => n % 2 == 0); +partitionedNums = numStream.partitionBy(n => n % 2 == 0); + +var partitionedStrings : string[][] = strStream.partitionBy(/^a$/); +partitionedStrings = strStream.partitioningBy(/^a$/); +partitionedStrings = strStream.partitioningBy(5); +partitionedStrings = strStream.partitionBy(5); + +var s: string = numStream.joining(); +s = numStream.join(); +s = numStream.joining(", "); +s = numStream.join(", "); +s = numStream.joining({prefix: "{", delimiter: ", ", suffix: "}"}); +s = numStream.join({prefix: "{", delimiter: ", ", suffix: "}"}); + + +var iter = numStream.iterator(); +var n: number = iter.next(); +var done: boolean = iter.done; + +var optNum: Stream.Optional = Stream.Optional.of(2); +optNum = Stream.Optional.ofNullable(null); +optNum = Stream.Optional.empty(); + +var optStr: Stream.Optional = optNum.filter(n => n % 2 == 0) + .map(n => "number" + n) + .flatMap(n => Stream.Optional.of(n + 2)) + ; diff --git a/streamjs/streamjs.d.ts b/streamjs/streamjs.d.ts index 1478d7a68d..6d13346a98 100644 --- a/streamjs/streamjs.d.ts +++ b/streamjs/streamjs.d.ts @@ -9,6 +9,7 @@ declare class Stream { static range (startInclusive: number, endExclusive: number): Stream; static rangeClosed (startInclusive: number, endInclusive: number): Stream; static generate (supplier: () => T): Stream; + // static empty(): Stream; anyMatch(predicate: (elem: T) => boolean): boolean; anyMatch(regexp: RegExp): boolean; @@ -28,8 +29,7 @@ declare class Stream { groupBy(mapper: (elem: T) => string): Stream.GroupingResult; groupingBy(mapper: (elem: T) => string): Stream.GroupingResult; - toMap(keyMapper: (elem: T) => string, mergeFunction?: (elem1: T, elem2: T) => T): T[]; - + indexBy(keyMapper: (elem: T) => string, mergeFunction?: (elem1: T, elem2: T) => T): T[]; map (mapper: (T) => U): Stream; max(): Stream.Optional; max(comparator: (e1: T, e2: T) => number): Stream.Optional; @@ -38,7 +38,20 @@ declare class Stream { noneMatch(predicate: (elem: T) => boolean): boolean; noneMatch(regexp: RegExp): boolean; flatMap (mapper: (T) => U[]): Stream; + iterator(): Stream.Iterator; + joining(): string; + joining(delimiter: string): string; + joining(options: Stream.JoinOptions): string; + join(): string; + join(delimiter: string): string; + join(options: Stream.JoinOptions): string; limit(limit: number): Stream; + partitioningBy(predicate: (elem: T) => boolean): T[][]; + partitionBy(predicate: (elem: T) => boolean): T[][]; + partitioningBy(regexp: RegExp): T[][]; + partitionBy(regexp: RegExp): T[][]; + partitioningBy(size: number): T[][]; + partitionBy(size: number): T[][]; peek(consumer: (elem: T) => void ): Stream; reduce(identity: T, accumulator: (e1: T, e2: T) => T): T; reduce(accumulator: (e1: T, e2: T) => T): Stream.Optional; @@ -55,9 +68,22 @@ declare class Stream { takeWhile(predicate: (elem: T) => boolean): Stream; takeWhile(regexp: RegExp): Stream; toArray(): T[]; + toMap(keyMapper: (elem: T) => string, mergeFunction?: (elem1: T, elem2: T) => T): T[]; } declare module Stream { + + export interface Iterator { + next(): T; + done: boolean; + } + + export interface JoinOptions { + prefix: string; + delimiter: string; + suffix: string; + } + export interface GroupingResult { [index: string]: T } @@ -69,6 +95,12 @@ declare module Stream { } export class Optional { - + static of(elem: T): Optional; + static ofNullable(elem: T): Optional; + static empty(): Optional; + + filter(predicate: (elem: T) => boolean): Optional; + map(mapper: (elem: T) => U): Optional; + flatMap(mapper: (elem: T) => Stream.Optional): Optional; } } From 09899c1ffa639cb80a835dcde5afc93d1f987af7 Mon Sep 17 00:00:00 2001 From: Bence Eros Date: Sun, 14 Jun 2015 00:38:59 +0200 Subject: [PATCH 06/17] added termial operations of Optional --- streamjs/streamjs-tests.ts | 9 ++++++++- streamjs/streamjs.d.ts | 6 ++++++ 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/streamjs/streamjs-tests.ts b/streamjs/streamjs-tests.ts index e59af31ae1..3d836b56f1 100644 --- a/streamjs/streamjs-tests.ts +++ b/streamjs/streamjs-tests.ts @@ -116,9 +116,16 @@ var done: boolean = iter.done; var optNum: Stream.Optional = Stream.Optional.of(2); optNum = Stream.Optional.ofNullable(null); -optNum = Stream.Optional.empty(); +//optNum = Stream.Optional.empty(); var optStr: Stream.Optional = optNum.filter(n => n % 2 == 0) .map(n => "number" + n) .flatMap(n => Stream.Optional.of(n + 2)) ; + +var isPresent: boolean = optNum.isPresent(); +var num: number = optNum.get(); +optNum.ifPresent(n => console.log(n)); +var def: number = optNum.orElse(2); +def = optNum.orElseGet(() => 3); +def = optNum.orElseThrow("something went wrong"); diff --git a/streamjs/streamjs.d.ts b/streamjs/streamjs.d.ts index 6d13346a98..5a0ea94a4d 100644 --- a/streamjs/streamjs.d.ts +++ b/streamjs/streamjs.d.ts @@ -102,5 +102,11 @@ declare module Stream { filter(predicate: (elem: T) => boolean): Optional; map(mapper: (elem: T) => U): Optional; flatMap(mapper: (elem: T) => Stream.Optional): Optional; + isPresent(): boolean; + get(): T; + ifPresent(consumer: (elem: T) => void): void; + orElse(other: T): T; + orElseGet(supplier: () => T): T; + orElseThrow(error: any): T; } } From aad6b603afa58007377fdc65649d9fdcdad4fc1e Mon Sep 17 00:00:00 2001 From: Bence Eros Date: Sun, 14 Jun 2015 00:39:46 +0200 Subject: [PATCH 07/17] added termial operations of Optional --- streamjs/streamjs.d.ts | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/streamjs/streamjs.d.ts b/streamjs/streamjs.d.ts index 5a0ea94a4d..8ac67d583c 100644 --- a/streamjs/streamjs.d.ts +++ b/streamjs/streamjs.d.ts @@ -11,7 +11,7 @@ declare class Stream { static generate (supplier: () => T): Stream; // static empty(): Stream; - anyMatch(predicate: (elem: T) => boolean): boolean; + anyMatch(predicate: Stream.Predicate): boolean; anyMatch(regexp: RegExp): boolean; allMatch(predicate: (elem: T) => boolean): boolean; allMatch(regexp: RegExp): boolean; @@ -73,6 +73,10 @@ declare class Stream { declare module Stream { + export interface Predicate { + (elem: T): boolean; + } + export interface Iterator { next(): T; done: boolean; From c5432f4533707047327ee32618e0dbde55621c40 Mon Sep 17 00:00:00 2001 From: Bence Eros Date: Sun, 14 Jun 2015 00:57:48 +0200 Subject: [PATCH 08/17] added some functional interfaces to reduce the number of inline anonymous types --- streamjs/streamjs.d.ts | 86 ++++++++++++++++++++++++++---------------- 1 file changed, 53 insertions(+), 33 deletions(-) diff --git a/streamjs/streamjs.d.ts b/streamjs/streamjs.d.ts index 8ac67d583c..464a449ca4 100644 --- a/streamjs/streamjs.d.ts +++ b/streamjs/streamjs.d.ts @@ -8,36 +8,36 @@ declare class Stream { static make (elems: T[]): Stream; static range (startInclusive: number, endExclusive: number): Stream; static rangeClosed (startInclusive: number, endInclusive: number): Stream; - static generate (supplier: () => T): Stream; + static generate (supplier: Stream.Supplier): Stream; // static empty(): Stream; - anyMatch(predicate: Stream.Predicate): boolean; + anyMatch(predicate: Stream.Predicate): boolean; anyMatch(regexp: RegExp): boolean; - allMatch(predicate: (elem: T) => boolean): boolean; + allMatch(predicate: Stream.Predicate): boolean; allMatch(regexp: RegExp): boolean; average(): number; avg(): number; collect(collector: Stream.Collector): T; count(): number; distinct(): Stream; - dropWhile(predicate: (elem: T) => boolean): Stream; + dropWhile(predicate: Stream.Predicate): Stream; dropWhile(regexp: RegExp): Stream; - filter(predicate: (T) => boolean): Stream; + filter(predicate: Stream.Predicate): Stream; findAny(): Stream.Optional; findFirst(): Stream.Optional; - forEach(consumer: (elem: T) => void): void; + forEach(consumer: Stream.Consumer): void; - groupBy(mapper: (elem: T) => string): Stream.GroupingResult; - groupingBy(mapper: (elem: T) => string): Stream.GroupingResult; - indexBy(keyMapper: (elem: T) => string, mergeFunction?: (elem1: T, elem2: T) => T): T[]; - map (mapper: (T) => U): Stream; + groupBy(mapper: Stream.Function): Stream.GroupingResult; + groupingBy(mapper: Stream.Function): Stream.GroupingResult; + indexBy(keyMapper: Stream.Function, mergeFunction?: Stream.Accumulator): T[]; + map (mapper: Stream.Function): Stream; max(): Stream.Optional; - max(comparator: (e1: T, e2: T) => number): Stream.Optional; + max(comparator: Stream.Comparator): Stream.Optional; min(): Stream.Optional; - min(comparator: (elem1: T, elem2: T) => number): Stream.Optional; + min(comparator: Stream.Comparator): Stream.Optional; noneMatch(predicate: (elem: T) => boolean): boolean; noneMatch(regexp: RegExp): boolean; - flatMap (mapper: (T) => U[]): Stream; + flatMap (mapper: Stream.Function): Stream; iterator(): Stream.Iterator; joining(): string; joining(delimiter: string): string; @@ -46,56 +46,76 @@ declare class Stream { join(delimiter: string): string; join(options: Stream.JoinOptions): string; limit(limit: number): Stream; - partitioningBy(predicate: (elem: T) => boolean): T[][]; - partitionBy(predicate: (elem: T) => boolean): T[][]; + partitioningBy(predicate: Stream.Predicate): T[][]; + partitionBy(predicate: Stream.Predicate): T[][]; partitioningBy(regexp: RegExp): T[][]; partitionBy(regexp: RegExp): T[][]; partitioningBy(size: number): T[][]; partitionBy(size: number): T[][]; - peek(consumer: (elem: T) => void ): Stream; - reduce(identity: T, accumulator: (e1: T, e2: T) => T): T; - reduce(accumulator: (e1: T, e2: T) => T): Stream.Optional; + peek(consumer: Stream.Consumer): Stream; + reduce(identity: T, accumulator: Stream.Accumulator): T; + reduce(accumulator: Stream.Accumulator): Stream.Optional; reverse(): Stream; size(): number; sorted(): Stream; - sorted(comparator: (e1: T, e2: T) => number): Stream; + sorted(comparator: Stream.Comparator): Stream; sort(): Stream; - sort(comparator: (e1: T, e2: T) => number): Stream; + sort(comparator: Stream.Comparator): Stream; shuffle(): Stream; skip(n: number): Stream; slice(begin, end): Stream; sum(): T; - takeWhile(predicate: (elem: T) => boolean): Stream; + takeWhile(predicate: Stream.Predicate): Stream; takeWhile(regexp: RegExp): Stream; toArray(): T[]; - toMap(keyMapper: (elem: T) => string, mergeFunction?: (elem1: T, elem2: T) => T): T[]; + toMap(keyMapper: Stream.Function, mergeFunction?: Stream.Accumulator): T[]; } declare module Stream { - export interface Predicate { - (elem: T): boolean; + export interface Accumulator { + (e1: T, e2: T): T; + } + + export interface Collector { + supplier: Supplier; + accumulator: Stream.Accumulator; + finisher: Function; } + export interface Comparator { + (e1: T, e2: T): number + } + + export interface Consumer { + (elem: T): void; + } + + export interface Function { + (elem: T): U; + } + + export interface GroupingResult { + [index: string]: T + } + export interface Iterator { next(): T; done: boolean; } - + export interface JoinOptions { prefix: string; delimiter: string; suffix: string; } - export interface GroupingResult { - [index: string]: T + export interface Predicate { + (elem: T): boolean; } - - export interface Collector { - supplier(): T; - accumulator(e1: T, e2: T): T; - finisher(result: T): T + + export interface Supplier { + (): T } export class Optional { @@ -110,7 +130,7 @@ declare module Stream { get(): T; ifPresent(consumer: (elem: T) => void): void; orElse(other: T): T; - orElseGet(supplier: () => T): T; + orElseGet(supplier: Stream.Supplier): T; orElseThrow(error: any): T; } } From a8871c9dfaccaed9df047617c5a7bcee8d6f92cf Mon Sep 17 00:00:00 2001 From: Bence Eros Date: Sun, 14 Jun 2015 01:17:49 +0200 Subject: [PATCH 09/17] adding Stream.iterate() constructor --- streamjs/streamjs-tests.ts | 2 ++ streamjs/streamjs.d.ts | 1 + 2 files changed, 3 insertions(+) diff --git a/streamjs/streamjs-tests.ts b/streamjs/streamjs-tests.ts index 3d836b56f1..083940311d 100644 --- a/streamjs/streamjs-tests.ts +++ b/streamjs/streamjs-tests.ts @@ -12,6 +12,8 @@ Stream.generate(function() { }); Stream.generate(() => 1); +numStream = Stream.iterate(1, (n) => n * 2); + var comparator = (s1, s2) => 0; numStream = numStream.filter(n => n % 2 == 0); diff --git a/streamjs/streamjs.d.ts b/streamjs/streamjs.d.ts index 464a449ca4..3b82680dfd 100644 --- a/streamjs/streamjs.d.ts +++ b/streamjs/streamjs.d.ts @@ -9,6 +9,7 @@ declare class Stream { static range (startInclusive: number, endExclusive: number): Stream; static rangeClosed (startInclusive: number, endInclusive: number): Stream; static generate (supplier: Stream.Supplier): Stream; + static iterate(seed: T, fn: Stream.Function): Stream; // static empty(): Stream; anyMatch(predicate: Stream.Predicate): boolean; From b9dab01b68ad9b959cb3e057bed6b861e9de33f6 Mon Sep 17 00:00:00 2001 From: Bence Eros Date: Sun, 14 Jun 2015 02:05:27 +0200 Subject: [PATCH 10/17] adding some missing methods, adding README with unsupported method list --- streamjs/README.md | 22 ++++++++++++++++++++++ streamjs/streamjs-tests.ts | 8 ++++---- streamjs/streamjs.d.ts | 4 ++++ 3 files changed, 30 insertions(+), 4 deletions(-) create mode 100644 streamjs/README.md diff --git a/streamjs/README.md b/streamjs/README.md new file mode 100644 index 0000000000..ae3fcfc97a --- /dev/null +++ b/streamjs/README.md @@ -0,0 +1,22 @@ +# StreamJS Type Definitions + +Unsupported StreamJS function / method signatures: + * Stream(collection) + * Stream(string) + * Stream.empty() + * filter(sample) + * map(path) + * flatMap(path) + * sorted(path) + * takeWhile(sample) + * dropWhile(sample) + * min(path) + * max(path) + * sum(path) + * average(path) + * allMatch(sample) + * anyMatch(sample) + * groupingBy(path) + * toMap(path, mergeFunction) + * partitioningBy(sample); + * Optional.empty() diff --git a/streamjs/streamjs-tests.ts b/streamjs/streamjs-tests.ts index 083940311d..c5f1ea8624 100644 --- a/streamjs/streamjs-tests.ts +++ b/streamjs/streamjs-tests.ts @@ -1,11 +1,9 @@ // var numStream: Stream; -// numStream = Stream.make(10, 20); -numStream = Stream.make([10, 20]); +numStream = Stream.of(1, 2, 3); numStream = Stream.range(1, 5); numStream = Stream.rangeClosed(1, 5); -// numStream = Stream.empty(); Stream.generate(function() { return 1; @@ -37,7 +35,9 @@ var strStream = numStream ; var strArray = strStream.toArray(); - +strArray = strStream.toList(); +strStream.each(s => console.log(s)); +strStream.filter(/^$/); strStream.forEach(s => console.log(s)); var opt: Stream.Optional = strStream.findFirst(); opt = strStream.findAny(); diff --git a/streamjs/streamjs.d.ts b/streamjs/streamjs.d.ts index 3b82680dfd..17889ff2fc 100644 --- a/streamjs/streamjs.d.ts +++ b/streamjs/streamjs.d.ts @@ -6,6 +6,7 @@ declare class Stream { // static make (...elems: T[]): Stream; static make (elems: T[]): Stream; + static of(...elems: T[]): Stream; static range (startInclusive: number, endExclusive: number): Stream; static rangeClosed (startInclusive: number, endInclusive: number): Stream; static generate (supplier: Stream.Supplier): Stream; @@ -23,7 +24,9 @@ declare class Stream { distinct(): Stream; dropWhile(predicate: Stream.Predicate): Stream; dropWhile(regexp: RegExp): Stream; + each(consumer: Stream.Consumer): void; filter(predicate: Stream.Predicate): Stream; + filter(regexp: RegExp): Stream; findAny(): Stream.Optional; findFirst(): Stream.Optional; forEach(consumer: Stream.Consumer): void; @@ -69,6 +72,7 @@ declare class Stream { takeWhile(predicate: Stream.Predicate): Stream; takeWhile(regexp: RegExp): Stream; toArray(): T[]; + toList(): T[]; toMap(keyMapper: Stream.Function, mergeFunction?: Stream.Accumulator): T[]; } From f4fd84bb109efaf4c1e62dc65b543180ea90fd70 Mon Sep 17 00:00:00 2001 From: Bence Eros Date: Sun, 14 Jun 2015 02:13:48 +0200 Subject: [PATCH 11/17] commenting out Optional.empty() since it does not work as expected --- streamjs/streamjs.d.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/streamjs/streamjs.d.ts b/streamjs/streamjs.d.ts index 17889ff2fc..aa2a82e61f 100644 --- a/streamjs/streamjs.d.ts +++ b/streamjs/streamjs.d.ts @@ -126,7 +126,7 @@ declare module Stream { export class Optional { static of(elem: T): Optional; static ofNullable(elem: T): Optional; - static empty(): Optional; + // static empty(): Optional; filter(predicate: (elem: T) => boolean): Optional; map(mapper: (elem: T) => U): Optional; From bd123fb8824cc1a554ed1fa4abc2f4331ceaff17 Mon Sep 17 00:00:00 2001 From: Bence Eros Date: Sun, 14 Jun 2015 13:57:39 +0200 Subject: [PATCH 12/17] adding support for most of the methods receiving sample or path as parameter --- streamjs/README.md | 13 ------------- streamjs/streamjs-tests.ts | 23 ++++++++++++++++++++++- streamjs/streamjs.d.ts | 25 +++++++++++++++++++++++-- 3 files changed, 45 insertions(+), 16 deletions(-) diff --git a/streamjs/README.md b/streamjs/README.md index ae3fcfc97a..9428177672 100644 --- a/streamjs/README.md +++ b/streamjs/README.md @@ -4,19 +4,6 @@ Unsupported StreamJS function / method signatures: * Stream(collection) * Stream(string) * Stream.empty() - * filter(sample) * map(path) * flatMap(path) - * sorted(path) - * takeWhile(sample) - * dropWhile(sample) - * min(path) - * max(path) - * sum(path) - * average(path) - * allMatch(sample) - * anyMatch(sample) - * groupingBy(path) - * toMap(path, mergeFunction) - * partitioningBy(sample); * Optional.empty() diff --git a/streamjs/streamjs-tests.ts b/streamjs/streamjs-tests.ts index c5f1ea8624..f83ec69e82 100644 --- a/streamjs/streamjs-tests.ts +++ b/streamjs/streamjs-tests.ts @@ -22,8 +22,10 @@ var strStream = numStream .limit(100) .sorted() .sort() + .sort("propName") .sorted(comparator) .sort(comparator) + .sorted("propName") .shuffle() .reverse() .distinct() @@ -47,8 +49,11 @@ opt = strStream.min(); opt = strStream.min((s1, s2) => 0); var sum = numStream.sum(); +sum = numStream.sum("foo"); var avg = numStream.average(); +avg = numStream.average("foo"); avg = numStream.avg(); +avg = numStream.avg("foo"); var count = numStream.count(); count = numStream.size(); @@ -78,6 +83,13 @@ elems = myStream .toArray(); //.forEach(s => console.log(s)); +myStream = myStream.takeWhile({name: "foo"}); +myStream = myStream.dropWhile({name: "foo"}); +myStream = myStream.filter({name: "foo"}); +var myResult = myStream.min("name"); +myResult = myStream.max("name"); +var match: boolean = myStream.allMatch({name: "foo"}); +match = myStream.anyMatch({name: "foo"}); numStream.collect({ supplier: () => 0, @@ -88,9 +100,13 @@ numStream.collect({ var groupingResult = myStream.groupBy(lst => lst.name); var elems = groupingResult["hello"].elems; groupingResult = myStream.groupingBy(lst => lst.name); +groupingResult = myStream.groupBy("name"); +groupingResult = myStream.groupingBy("name"); var mappingResult = myStream.toMap(lst => lst.name, (e1, e2) => e2); -console.log(mappingResult["a"]); +var aMappingResult: MyList = mappingResult["a"]; + +mappingResult = myStream.toMap("a"); myStream.toMap(lst => lst.name); @@ -104,6 +120,9 @@ partitionedStrings = strStream.partitioningBy(/^a$/); partitionedStrings = strStream.partitioningBy(5); partitionedStrings = strStream.partitionBy(5); +var partitionedList: MyList[][] = myStream.partitionBy({name : "foo"}); +partitionedList = myStream.partitioningBy({name : "foo"}); + var s: string = numStream.joining(); s = numStream.join(); s = numStream.joining(", "); @@ -131,3 +150,5 @@ optNum.ifPresent(n => console.log(n)); var def: number = optNum.orElse(2); def = optNum.orElseGet(() => 3); def = optNum.orElseThrow("something went wrong"); + + diff --git a/streamjs/streamjs.d.ts b/streamjs/streamjs.d.ts index aa2a82e61f..81ed58a82f 100644 --- a/streamjs/streamjs.d.ts +++ b/streamjs/streamjs.d.ts @@ -1,5 +1,5 @@ // Type definitions for streamjs 1.4.0 -// Project: http://streamjs.org/ +// Project: https://github.com/winterbe/streamjs // Definitions by: Bence Eros // Definitions: https://github.com/borisyankov/DefinitelyTyped @@ -15,30 +15,40 @@ declare class Stream { anyMatch(predicate: Stream.Predicate): boolean; anyMatch(regexp: RegExp): boolean; + anyMatch(sample: Stream.Sample): boolean; allMatch(predicate: Stream.Predicate): boolean; allMatch(regexp: RegExp): boolean; + allMatch(sample: Stream.Sample): boolean; average(): number; + average(path: string): number; avg(): number; + avg(path: string): number; collect(collector: Stream.Collector): T; count(): number; distinct(): Stream; dropWhile(predicate: Stream.Predicate): Stream; dropWhile(regexp: RegExp): Stream; + dropWhile(sample: Stream.Sample): Stream; each(consumer: Stream.Consumer): void; filter(predicate: Stream.Predicate): Stream; filter(regexp: RegExp): Stream; + filter(sample: Stream.Sample): Stream; findAny(): Stream.Optional; findFirst(): Stream.Optional; forEach(consumer: Stream.Consumer): void; groupBy(mapper: Stream.Function): Stream.GroupingResult; + groupBy(path: string): Stream.GroupingResult; groupingBy(mapper: Stream.Function): Stream.GroupingResult; + groupingBy(path: string): Stream.GroupingResult; indexBy(keyMapper: Stream.Function, mergeFunction?: Stream.Accumulator): T[]; map (mapper: Stream.Function): Stream; max(): Stream.Optional; max(comparator: Stream.Comparator): Stream.Optional; + max(path: string): Stream.Optional; min(): Stream.Optional; min(comparator: Stream.Comparator): Stream.Optional; + min(path: string): Stream.Optional; noneMatch(predicate: (elem: T) => boolean): boolean; noneMatch(regexp: RegExp): boolean; flatMap (mapper: Stream.Function): Stream; @@ -52,10 +62,12 @@ declare class Stream { limit(limit: number): Stream; partitioningBy(predicate: Stream.Predicate): T[][]; partitionBy(predicate: Stream.Predicate): T[][]; + partitionBy(sample: Stream.Sample): T[][]; partitioningBy(regexp: RegExp): T[][]; partitionBy(regexp: RegExp): T[][]; partitioningBy(size: number): T[][]; partitionBy(size: number): T[][]; + partitioningBy(sample: Stream.Sample): T[][]; peek(consumer: Stream.Consumer): Stream; reduce(identity: T, accumulator: Stream.Accumulator): T; reduce(accumulator: Stream.Accumulator): Stream.Optional; @@ -63,21 +75,30 @@ declare class Stream { size(): number; sorted(): Stream; sorted(comparator: Stream.Comparator): Stream; + sorted(path: string): Stream; sort(): Stream; sort(comparator: Stream.Comparator): Stream; + sort(path: string): Stream; shuffle(): Stream; skip(n: number): Stream; slice(begin, end): Stream; - sum(): T; + sum(): number; + sum(path: string): number; takeWhile(predicate: Stream.Predicate): Stream; takeWhile(regexp: RegExp): Stream; + takeWhile(sample: Stream.Sample): Stream; toArray(): T[]; toList(): T[]; toMap(keyMapper: Stream.Function, mergeFunction?: Stream.Accumulator): T[]; + toMap(path: string, mergeFunction?: Stream.Accumulator): T[]; } declare module Stream { + export interface Sample { + [index: string]: any + } + export interface Accumulator { (e1: T, e2: T): T; } From b116936ea52a2f437a44098718f7e64f4d60746d Mon Sep 17 00:00:00 2001 From: Bence Eros Date: Mon, 15 Jun 2015 12:32:10 +0200 Subject: [PATCH 13/17] updates for streamjs 1.5.0 --- streamjs/README.md | 3 +++ streamjs/streamjs-tests.ts | 6 +++--- streamjs/streamjs.d.ts | 7 ++++--- 3 files changed, 10 insertions(+), 6 deletions(-) diff --git a/streamjs/README.md b/streamjs/README.md index 9428177672..36f8ec46c9 100644 --- a/streamjs/README.md +++ b/streamjs/README.md @@ -1,5 +1,8 @@ # StreamJS Type Definitions +Note: this definition file is not for the StreamJS library available at http://streamjs.org but the one at +http://winterbe.github.io/streamjs/ . + Unsupported StreamJS function / method signatures: * Stream(collection) * Stream(string) diff --git a/streamjs/streamjs-tests.ts b/streamjs/streamjs-tests.ts index f83ec69e82..ca9d65183c 100644 --- a/streamjs/streamjs-tests.ts +++ b/streamjs/streamjs-tests.ts @@ -4,7 +4,7 @@ var numStream: Stream; numStream = Stream.of(1, 2, 3); numStream = Stream.range(1, 5); numStream = Stream.rangeClosed(1, 5); - +numStream = Stream.from([1, 2, 3]); Stream.generate(function() { return 1; }); @@ -35,7 +35,7 @@ var strStream = numStream .takeWhile(/^aa.*$/) .slice(5, 2) ; - +strStream = Stream.from("foobar"); var strArray = strStream.toArray(); strArray = strStream.toList(); strStream.each(s => console.log(s)); @@ -77,7 +77,7 @@ class MyList { var elems: any[]; -var myStream = Stream.make([new MyList, new MyList]); +var myStream = Stream.from([new MyList, new MyList]); elems = myStream .flatMap(list => list.elems) .toArray(); diff --git a/streamjs/streamjs.d.ts b/streamjs/streamjs.d.ts index 81ed58a82f..0db7cff727 100644 --- a/streamjs/streamjs.d.ts +++ b/streamjs/streamjs.d.ts @@ -1,11 +1,12 @@ -// Type definitions for streamjs 1.4.0 -// Project: https://github.com/winterbe/streamjs +// Type definitions for streamjs 1.5.0 +// Project: http://winterbe.github.io/streamjs/ // Definitions by: Bence Eros // Definitions: https://github.com/borisyankov/DefinitelyTyped declare class Stream { // static make (...elems: T[]): Stream; - static make (elems: T[]): Stream; + static from (elems: T[]): Stream; + static from(str: string): Stream; static of(...elems: T[]): Stream; static range (startInclusive: number, endExclusive: number): Stream; static rangeClosed (startInclusive: number, endInclusive: number): Stream; From a29d577f810ea05786bb9b9eaa9f06c58e4d4003 Mon Sep 17 00:00:00 2001 From: Bence Eros Date: Mon, 15 Jun 2015 12:33:38 +0200 Subject: [PATCH 14/17] removing some comments --- streamjs/streamjs-tests.ts | 2 -- streamjs/streamjs.d.ts | 3 --- 2 files changed, 5 deletions(-) diff --git a/streamjs/streamjs-tests.ts b/streamjs/streamjs-tests.ts index ca9d65183c..ba989f4474 100644 --- a/streamjs/streamjs-tests.ts +++ b/streamjs/streamjs-tests.ts @@ -81,7 +81,6 @@ var myStream = Stream.from([new MyList, new MyList]); elems = myStream .flatMap(list => list.elems) .toArray(); - //.forEach(s => console.log(s)); myStream = myStream.takeWhile({name: "foo"}); myStream = myStream.dropWhile({name: "foo"}); @@ -137,7 +136,6 @@ var done: boolean = iter.done; var optNum: Stream.Optional = Stream.Optional.of(2); optNum = Stream.Optional.ofNullable(null); -//optNum = Stream.Optional.empty(); var optStr: Stream.Optional = optNum.filter(n => n % 2 == 0) .map(n => "number" + n) diff --git a/streamjs/streamjs.d.ts b/streamjs/streamjs.d.ts index 0db7cff727..e36dcca239 100644 --- a/streamjs/streamjs.d.ts +++ b/streamjs/streamjs.d.ts @@ -4,7 +4,6 @@ // Definitions: https://github.com/borisyankov/DefinitelyTyped declare class Stream { - // static make (...elems: T[]): Stream; static from (elems: T[]): Stream; static from(str: string): Stream; static of(...elems: T[]): Stream; @@ -12,7 +11,6 @@ declare class Stream { static rangeClosed (startInclusive: number, endInclusive: number): Stream; static generate (supplier: Stream.Supplier): Stream; static iterate(seed: T, fn: Stream.Function): Stream; - // static empty(): Stream; anyMatch(predicate: Stream.Predicate): boolean; anyMatch(regexp: RegExp): boolean; @@ -148,7 +146,6 @@ declare module Stream { export class Optional { static of(elem: T): Optional; static ofNullable(elem: T): Optional; - // static empty(): Optional; filter(predicate: (elem: T) => boolean): Optional; map(mapper: (elem: T) => U): Optional; From f20634f5fc012b94acdc5624955dc8fa460ea4a1 Mon Sep 17 00:00:00 2001 From: Bence Eros Date: Mon, 15 Jun 2015 12:35:47 +0200 Subject: [PATCH 15/17] readme cleanup --- streamjs/README.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/streamjs/README.md b/streamjs/README.md index 36f8ec46c9..ba28f14426 100644 --- a/streamjs/README.md +++ b/streamjs/README.md @@ -4,9 +4,9 @@ Note: this definition file is not for the StreamJS library available at http://s http://winterbe.github.io/streamjs/ . Unsupported StreamJS function / method signatures: - * Stream(collection) - * Stream(string) - * Stream.empty() - * map(path) - * flatMap(path) - * Optional.empty() + * `Stream(collection)` (but `Stream.from(collection)` works) + * `Stream(string) (but `Stream.from(string)` works) + * `Stream.empty()` + * `map(path)` + * `flatMap(path)` + * `Optional.empty()` From d307a6399b0a22d24e24fc7ac1c1da98fa700ab8 Mon Sep 17 00:00:00 2001 From: Bence Eros Date: Mon, 15 Jun 2015 12:36:21 +0200 Subject: [PATCH 16/17] readme cleanup --- streamjs/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/streamjs/README.md b/streamjs/README.md index ba28f14426..400e3bc412 100644 --- a/streamjs/README.md +++ b/streamjs/README.md @@ -5,7 +5,7 @@ http://winterbe.github.io/streamjs/ . Unsupported StreamJS function / method signatures: * `Stream(collection)` (but `Stream.from(collection)` works) - * `Stream(string) (but `Stream.from(string)` works) + * `Stream(string)` (but `Stream.from(string)` works) * `Stream.empty()` * `map(path)` * `flatMap(path)` From 7ff6577114c2c9e3354b302684dc87abc583c308 Mon Sep 17 00:00:00 2001 From: Bence Eros Date: Tue, 16 Jun 2015 19:38:51 +0200 Subject: [PATCH 17/17] created new Stream.Map interface, fixing build failures --- streamjs/streamjs-tests.ts | 10 +++++----- streamjs/streamjs.d.ts | 13 +++++++++---- 2 files changed, 14 insertions(+), 9 deletions(-) diff --git a/streamjs/streamjs-tests.ts b/streamjs/streamjs-tests.ts index ba989f4474..f911c8f522 100644 --- a/streamjs/streamjs-tests.ts +++ b/streamjs/streamjs-tests.ts @@ -1,4 +1,4 @@ -// +/// var numStream: Stream; numStream = Stream.of(1, 2, 3); @@ -12,11 +12,11 @@ Stream.generate(() => 1); numStream = Stream.iterate(1, (n) => n * 2); -var comparator = (s1, s2) => 0; +var comparator = (s1: string, s2: string) => 0; numStream = numStream.filter(n => n % 2 == 0); var strStream = numStream - .dropWhile((n) => n % 2 == 0) + .dropWhile((n: number) => n % 2 == 0) .map(n => "number " + n) .dropWhile(/^$/) .limit(100) @@ -77,7 +77,7 @@ class MyList { var elems: any[]; -var myStream = Stream.from([new MyList, new MyList]); +var myStream: Stream = Stream.from([new MyList, new MyList]); elems = myStream .flatMap(list => list.elems) .toArray(); @@ -102,7 +102,7 @@ groupingResult = myStream.groupingBy(lst => lst.name); groupingResult = myStream.groupBy("name"); groupingResult = myStream.groupingBy("name"); -var mappingResult = myStream.toMap(lst => lst.name, (e1, e2) => e2); +var mappingResult = myStream.toMap((lst) => lst.name, (e1: MyList, e2: MyList) => e2); var aMappingResult: MyList = mappingResult["a"]; mappingResult = myStream.toMap("a"); diff --git a/streamjs/streamjs.d.ts b/streamjs/streamjs.d.ts index e36dcca239..59d8019f39 100644 --- a/streamjs/streamjs.d.ts +++ b/streamjs/streamjs.d.ts @@ -40,7 +40,7 @@ declare class Stream { groupBy(path: string): Stream.GroupingResult; groupingBy(mapper: Stream.Function): Stream.GroupingResult; groupingBy(path: string): Stream.GroupingResult; - indexBy(keyMapper: Stream.Function, mergeFunction?: Stream.Accumulator): T[]; + indexBy(keyMapper: Stream.Function, mergeFunction?: Stream.Accumulator): Stream.Map; map (mapper: Stream.Function): Stream; max(): Stream.Optional; max(comparator: Stream.Comparator): Stream.Optional; @@ -80,7 +80,7 @@ declare class Stream { sort(path: string): Stream; shuffle(): Stream; skip(n: number): Stream; - slice(begin, end): Stream; + slice(begin: number, end: number): Stream; sum(): number; sum(path: string): number; takeWhile(predicate: Stream.Predicate): Stream; @@ -88,12 +88,17 @@ declare class Stream { takeWhile(sample: Stream.Sample): Stream; toArray(): T[]; toList(): T[]; - toMap(keyMapper: Stream.Function, mergeFunction?: Stream.Accumulator): T[]; - toMap(path: string, mergeFunction?: Stream.Accumulator): T[]; + toMap(keyMapper: Stream.Function, mergeFunction?: Stream.Accumulator): Stream.Map; + toMap(path: string, mergeFunction?: Stream.Accumulator): Stream.Map; } declare module Stream { + export interface Map { + [index: string]: T + } + + export interface Sample { [index: string]: any }