mirror of
https://github.com/zhigang1992/DefinitelyTyped.git
synced 2026-05-22 20:37:58 +08:00
Masahiro Wakame
12
streamjs/README.md
Normal file
12
streamjs/README.md
Normal file
@@ -0,0 +1,12 @@
|
||||
# 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)` (but `Stream.from(collection)` works)
|
||||
* `Stream(string)` (but `Stream.from(string)` works)
|
||||
* `Stream.empty()`
|
||||
* `map(path)`
|
||||
* `flatMap(path)`
|
||||
* `Optional.empty()`
|
||||
152
streamjs/streamjs-tests.ts
Normal file
152
streamjs/streamjs-tests.ts
Normal file
@@ -0,0 +1,152 @@
|
||||
/// <reference path="streamjs.d.ts" />
|
||||
|
||||
var numStream: Stream<number>;
|
||||
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;
|
||||
});
|
||||
Stream.generate(() => 1);
|
||||
|
||||
numStream = Stream.iterate(1, (n) => n * 2);
|
||||
|
||||
var comparator = (s1: string, s2: string) => 0;
|
||||
|
||||
numStream = numStream.filter(n => n % 2 == 0);
|
||||
var strStream = numStream
|
||||
.dropWhile((n: number) => n % 2 == 0)
|
||||
.map(n => "number " + n)
|
||||
.dropWhile(/^$/)
|
||||
.limit(100)
|
||||
.sorted()
|
||||
.sort()
|
||||
.sort("propName")
|
||||
.sorted(comparator)
|
||||
.sort(comparator)
|
||||
.sorted("propName")
|
||||
.shuffle()
|
||||
.reverse()
|
||||
.distinct()
|
||||
.skip(5)
|
||||
.peek(s => console.log(s))
|
||||
.takeWhile(s => s.length < 5)
|
||||
.takeWhile(/^aa.*$/)
|
||||
.slice(5, 2)
|
||||
;
|
||||
strStream = Stream.from("foobar");
|
||||
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<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();
|
||||
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();
|
||||
|
||||
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[];
|
||||
|
||||
var myStream: Stream<MyList> = Stream.from([new MyList, new MyList]);
|
||||
elems = myStream
|
||||
.flatMap(list => list.elems)
|
||||
.toArray();
|
||||
|
||||
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,
|
||||
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);
|
||||
groupingResult = myStream.groupBy("name");
|
||||
groupingResult = myStream.groupingBy("name");
|
||||
|
||||
var mappingResult = myStream.toMap((lst) => lst.name, (e1: MyList, e2: MyList) => e2);
|
||||
var aMappingResult: MyList = mappingResult["a"];
|
||||
|
||||
mappingResult = myStream.toMap("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 partitionedList: MyList[][] = myStream.partitionBy({name : "foo"});
|
||||
partitionedList = myStream.partitioningBy({name : "foo"});
|
||||
|
||||
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<number> = Stream.Optional.of(2);
|
||||
optNum = Stream.Optional.ofNullable(null);
|
||||
|
||||
var optStr: Stream.Optional<String> = 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");
|
||||
|
||||
|
||||
165
streamjs/streamjs.d.ts
vendored
Normal file
165
streamjs/streamjs.d.ts
vendored
Normal file
@@ -0,0 +1,165 @@
|
||||
// Type definitions for streamjs 1.5.0
|
||||
// Project: http://winterbe.github.io/streamjs/
|
||||
// Definitions by: Bence Eros <https://github.com/erosb>
|
||||
// Definitions: https://github.com/borisyankov/DefinitelyTyped
|
||||
|
||||
declare class Stream<T> {
|
||||
static from <T> (elems: T[]): Stream<T>;
|
||||
static from(str: string): Stream<string>;
|
||||
static of<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: Stream.Supplier<T>): Stream<T>;
|
||||
static iterate<T>(seed: T, fn: Stream.Function<T, T>): Stream<T>;
|
||||
|
||||
anyMatch(predicate: Stream.Predicate<T>): boolean;
|
||||
anyMatch(regexp: RegExp): boolean;
|
||||
anyMatch(sample: Stream.Sample): boolean;
|
||||
allMatch(predicate: Stream.Predicate<T>): 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>): T;
|
||||
count(): number;
|
||||
distinct(): Stream<T>;
|
||||
dropWhile(predicate: Stream.Predicate<T>): Stream<T>;
|
||||
dropWhile(regexp: RegExp): Stream<string>;
|
||||
dropWhile(sample: Stream.Sample): Stream<T>;
|
||||
each(consumer: Stream.Consumer<T>): void;
|
||||
filter(predicate: Stream.Predicate<T>): Stream<T>;
|
||||
filter(regexp: RegExp): Stream<string>;
|
||||
filter(sample: Stream.Sample): Stream<T>;
|
||||
findAny(): Stream.Optional<T>;
|
||||
findFirst(): Stream.Optional<T>;
|
||||
forEach(consumer: Stream.Consumer<T>): void;
|
||||
|
||||
groupBy(mapper: Stream.Function<T, string>): Stream.GroupingResult<T>;
|
||||
groupBy(path: string): Stream.GroupingResult<T>;
|
||||
groupingBy(mapper: Stream.Function<T, string>): Stream.GroupingResult<T>;
|
||||
groupingBy(path: string): Stream.GroupingResult<T>;
|
||||
indexBy(keyMapper: Stream.Function<T, string>, mergeFunction?: Stream.Accumulator<T>): Stream.Map<T>;
|
||||
map <U> (mapper: Stream.Function<T, U>): Stream<U>;
|
||||
max(): Stream.Optional<T>;
|
||||
max(comparator: Stream.Comparator<T>): Stream.Optional<T>;
|
||||
max(path: string): Stream.Optional<T>;
|
||||
min(): Stream.Optional<T>;
|
||||
min(comparator: Stream.Comparator<T>): Stream.Optional<T>;
|
||||
min(path: string): Stream.Optional<T>;
|
||||
noneMatch(predicate: (elem: T) => boolean): boolean;
|
||||
noneMatch(regexp: RegExp): boolean;
|
||||
flatMap <U> (mapper: Stream.Function<T, U[]>): Stream<U>;
|
||||
iterator(): Stream.Iterator<T>;
|
||||
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<T>;
|
||||
partitioningBy(predicate: Stream.Predicate<T>): T[][];
|
||||
partitionBy(predicate: Stream.Predicate<T>): 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<T>): Stream<T>;
|
||||
reduce(identity: T, accumulator: Stream.Accumulator<T>): T;
|
||||
reduce(accumulator: Stream.Accumulator<T>): Stream.Optional<T>;
|
||||
reverse(): Stream<T>;
|
||||
size(): number;
|
||||
sorted(): Stream<T>;
|
||||
sorted(comparator: Stream.Comparator<T>): Stream<T>;
|
||||
sorted(path: string): Stream<T>;
|
||||
sort(): Stream<T>;
|
||||
sort(comparator: Stream.Comparator<T>): Stream<T>;
|
||||
sort(path: string): Stream<T>;
|
||||
shuffle(): Stream<T>;
|
||||
skip(n: number): Stream<T>;
|
||||
slice(begin: number, end: number): Stream<T>;
|
||||
sum(): number;
|
||||
sum(path: string): number;
|
||||
takeWhile(predicate: Stream.Predicate<T>): Stream<T>;
|
||||
takeWhile(regexp: RegExp): Stream<string>;
|
||||
takeWhile(sample: Stream.Sample): Stream<T>;
|
||||
toArray(): T[];
|
||||
toList(): T[];
|
||||
toMap(keyMapper: Stream.Function<T, string>, mergeFunction?: Stream.Accumulator<T>): Stream.Map<T>;
|
||||
toMap(path: string, mergeFunction?: Stream.Accumulator<T>): Stream.Map<T>;
|
||||
}
|
||||
|
||||
declare module Stream {
|
||||
|
||||
export interface Map<T> {
|
||||
[index: string]: T
|
||||
}
|
||||
|
||||
|
||||
export interface Sample {
|
||||
[index: string]: any
|
||||
}
|
||||
|
||||
export interface Accumulator<T> {
|
||||
(e1: T, e2: T): T;
|
||||
}
|
||||
|
||||
export interface Collector<T> {
|
||||
supplier: Supplier<T>;
|
||||
accumulator: Stream.Accumulator<T>;
|
||||
finisher: Function<T, T>;
|
||||
}
|
||||
|
||||
export interface Comparator<T> {
|
||||
(e1: T, e2: T): number
|
||||
}
|
||||
|
||||
export interface Consumer<T> {
|
||||
(elem: T): void;
|
||||
}
|
||||
|
||||
export interface Function<T, U> {
|
||||
(elem: T): U;
|
||||
}
|
||||
|
||||
export interface GroupingResult<T> {
|
||||
[index: string]: T
|
||||
}
|
||||
|
||||
export interface Iterator<T> {
|
||||
next(): T;
|
||||
done: boolean;
|
||||
}
|
||||
|
||||
export interface JoinOptions {
|
||||
prefix: string;
|
||||
delimiter: string;
|
||||
suffix: string;
|
||||
}
|
||||
|
||||
export interface Predicate<T> {
|
||||
(elem: T): boolean;
|
||||
}
|
||||
|
||||
export interface Supplier<T> {
|
||||
(): T
|
||||
}
|
||||
|
||||
export class Optional<T> {
|
||||
static of<T>(elem: T): Optional<T>;
|
||||
static ofNullable<T>(elem: T): Optional<T>;
|
||||
|
||||
filter(predicate: (elem: T) => boolean): Optional<T>;
|
||||
map<U>(mapper: (elem: T) => U): Optional<U>;
|
||||
flatMap<U>(mapper: (elem: T) => Stream.Optional<U>): Optional<U>;
|
||||
isPresent(): boolean;
|
||||
get(): T;
|
||||
ifPresent(consumer: (elem: T) => void): void;
|
||||
orElse(other: T): T;
|
||||
orElseGet(supplier: Stream.Supplier<T>): T;
|
||||
orElseThrow(error: any): T;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user