mirror of
https://github.com/wassname/DefinitelyTyped.git
synced 2026-09-09 11:13:57 +08:00
Merge pull request #1180 from Igorbek/master
Added type definition for IxJS project
This commit is contained in:
basarat
@@ -0,0 +1,116 @@
|
||||
///<reference path="ix.d.ts"/>
|
||||
|
||||
var ec_ns = (a: number, b: string) => a.toString() == b; //equality comparer on number,string
|
||||
var ec_ss = (a: string, b: string) => a == b; //equality comparer on string,string
|
||||
var ec_nn = (a: number, b: number) => a === b; //equality comparer on number,number
|
||||
var c_nn = (a: number, b: number) => a - b; //comparer on number,number
|
||||
|
||||
// static
|
||||
|
||||
Ix.Enumerable.throw(new Error("error"));
|
||||
Ix.Enumerable.throwException(new Error("error"));
|
||||
|
||||
var ax = Ix.Enumerable.generate(-100, a => a < 100, a=> a + 10, a=> a * 2);
|
||||
|
||||
Ix.Enumerable.defer(() => ax);
|
||||
|
||||
Ix.Enumerable.using(() => ax.getEnumerator(), e => Ix.Enumerable.return(e.getCurrent()));
|
||||
|
||||
Ix.Enumerable.catch(ax, ax, ax);
|
||||
Ix.Enumerable.catchException(ax, ax, ax);
|
||||
Ix.Enumerable.catch<string>();
|
||||
Ix.Enumerable.catchException<string>();
|
||||
|
||||
Ix.Enumerable.onErrorResumeNext(ax, ax, ax);
|
||||
Ix.Enumerable.onErrorResumeNext<string>();
|
||||
|
||||
Ix.Enumerable.while(x => x.count() > 0, ax);
|
||||
Ix.Enumerable.whileDo(x => x.count() > 0, ax);
|
||||
|
||||
Ix.Enumerable.if(() => true, ax, ax);
|
||||
Ix.Enumerable.ifThen(() => true, ax, ax);
|
||||
Ix.Enumerable.if(() => true, ax);
|
||||
Ix.Enumerable.ifThen(() => true, ax);
|
||||
|
||||
Ix.Enumerable.doWhile(ax, x => x.count() > 0);
|
||||
|
||||
Ix.Enumerable.case(() => 42, { 42: ax }, ax);
|
||||
Ix.Enumerable.switchCase(() => 42, { 42: ax }, ax);
|
||||
Ix.Enumerable.case(() => 42, { 42: ax });
|
||||
Ix.Enumerable.switchCase(() => 42, { 42: ax });
|
||||
Ix.Enumerable.case(() => "42", { "42": ax }, ax);
|
||||
Ix.Enumerable.switchCase(() => "42", { "42": ax }, ax);
|
||||
Ix.Enumerable.case(() => "42", { "42": ax });
|
||||
Ix.Enumerable.switchCase(() => "42", { "42": ax });
|
||||
|
||||
Ix.Enumerable.for(ax, a => ax);
|
||||
Ix.Enumerable.forIn(ax, a => ax);
|
||||
|
||||
// instance
|
||||
|
||||
var bx: Ix.Enumerable<string>;
|
||||
|
||||
ax.isEmpty();
|
||||
|
||||
bx.minBy(b => b.length, c_nn);
|
||||
bx.minBy(b => b.length);
|
||||
bx.maxBy(b => b.length, c_nn);
|
||||
bx.maxBy(b => b.length);
|
||||
|
||||
ax.share(ax => bx);
|
||||
ax.share();
|
||||
|
||||
ax.publish(ax => bx);
|
||||
ax.publish();
|
||||
|
||||
ax.memoize();
|
||||
|
||||
ax.do({ onNext: (a: number) => console.log(a), onError: err => console.log(err), onCompleted: () => console.log("completed") });
|
||||
ax.do(a => console.log(a), err => console.log(err), () => console.log("completed"));
|
||||
ax.do(a => console.log(a), err => console.log(err));
|
||||
ax.do((a: number) => console.log(a));
|
||||
ax.doAction({ onNext: (a: number) => console.log(a), onError: err => console.log(err), onCompleted: () => console.log("completed") });
|
||||
ax.doAction(a => console.log(a), err => console.log(err), () => console.log("completed"));
|
||||
ax.doAction(a => console.log(a), err => console.log(err));
|
||||
ax.doAction((a: number) => console.log(a));
|
||||
|
||||
ax.bufferWithCount(10, 20);
|
||||
ax.bufferWithCount(10);
|
||||
|
||||
ax.ignoreElements();
|
||||
|
||||
bx.distinctBy(b => b.length, ec_nn);
|
||||
bx.distinctBy(b => b.length);
|
||||
|
||||
bx.distinctUntilChanged(b => b.length, ec_nn);
|
||||
bx.distinctUntilChanged(b => b.length);
|
||||
bx.distinctUntilChanged();
|
||||
bx.distinctUntilChanged(false, ec_ss);
|
||||
|
||||
ax.expand(a => ax);
|
||||
|
||||
ax.startWith(10, 20);
|
||||
|
||||
ax.scan(0, (acc, a) => acc + a);
|
||||
ax.scan((acc, a) => acc + a);
|
||||
|
||||
ax.takeLast(10);
|
||||
ax.skipLast(10);
|
||||
|
||||
ax.repeat(10);
|
||||
ax.repeat();
|
||||
|
||||
ax.catch(ax, ax, ax);
|
||||
ax.catchException(ax, ax, ax);
|
||||
ax.catch(ax);
|
||||
ax.catchException(ax);
|
||||
ax.catch(err => ax);
|
||||
ax.catchException(err => ax);
|
||||
|
||||
ax.finally(() => { });
|
||||
ax.finallyDo(() => { });
|
||||
|
||||
ax.onErrorResumeNext(ax);
|
||||
|
||||
ax.retry(10);
|
||||
ax.retry();
|
||||
Vendored
+112
@@ -0,0 +1,112 @@
|
||||
// Type definitions for IxJS 1.0.6 / ix.js
|
||||
// Project: https://github.com/Reactive-Extensions/IxJS
|
||||
// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
|
||||
|
||||
///<reference path="l2o.d.ts"/>
|
||||
|
||||
declare module Ix {
|
||||
|
||||
export interface Observer<T> {
|
||||
onNext? (value: T): void;
|
||||
onError? (error: Error): void;
|
||||
onCompleted? (): void;
|
||||
}
|
||||
|
||||
export interface Enumerable<T> {
|
||||
isEmpty(): boolean;
|
||||
|
||||
minBy<TKey>(keySelector: (item: T) => TKey, comparer: Comparer<TKey, TKey>): Enumerable<T>;
|
||||
minBy(keySelector: (item: T) => number): Enumerable<T>;
|
||||
maxBy<TKey>(keySelector: (item: T) => TKey, comparer: Comparer<TKey, TKey>): Enumerable<T>;
|
||||
maxBy(keySelector: (item: T) => number): Enumerable<T>;
|
||||
|
||||
share<TResult>(selector: (source: Enumerable<T>) => Enumerable<TResult>): Enumerable<TResult>;
|
||||
share(): Enumerable<T>;
|
||||
|
||||
publish<TResult>(selector: (source: Enumerable<T>) => Enumerable<TResult>): Enumerable<TResult>;
|
||||
publish(): Enumerable<T>;
|
||||
|
||||
memoize(): Enumerable<T>;
|
||||
|
||||
do(onNext: (value: T) => void, onError?: (error: Error) => void, onCompleted?: () => void): Enumerable<T>;
|
||||
doAction(onNext: (value: T) => void, onError?: (error: Error) => void, onCompleted?: () => void): Enumerable<T>;
|
||||
do(onbserver: Observer<T>): Enumerable<T>;
|
||||
doAction(onbserver: Observer<T>): Enumerable<T>;
|
||||
|
||||
bufferWithCount(count: number, skip?: number): Enumerable<T>;
|
||||
|
||||
ignoreElements(): Enumerable<T>;
|
||||
|
||||
distinctBy<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): Enumerable<T>;
|
||||
|
||||
distinctUntilChanged<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): Enumerable<T>;
|
||||
distinctUntilChanged(): Enumerable<T>;
|
||||
// if need to set comparer without keySelector
|
||||
distinctUntilChanged(_: boolean, comparer: EqualityComparer<T, T>): Enumerable<T>;
|
||||
|
||||
expand(selector: (item: T) => Enumerable<T>): Enumerable<T>;
|
||||
|
||||
startWith(...values: T[]): Enumerable<T>;
|
||||
|
||||
scan<TSeed, TAccumulator>(seed: TSeed, accumulate: (acc: TAccumulator, item: T) => TAccumulator): Enumerable<TAccumulator>;
|
||||
scan(accumulate: (acc: T, item: T) => T): Enumerable<T>;
|
||||
|
||||
takeLast(count: number): Enumerable<T>;
|
||||
skipLast(count: number): Enumerable<T>;
|
||||
|
||||
repeat(count?: number): Enumerable<T>;
|
||||
|
||||
catch(handler: (error: Error) => Enumerable<T>): Enumerable<T>;
|
||||
catchException(handler: (error: Error) => Enumerable<T>): Enumerable<T>;
|
||||
catch(second: Enumerable<T>, ...other: Enumerable<T>[]): Enumerable<T>;
|
||||
catchException(second: Enumerable<T>, ...other: Enumerable<T>[]): Enumerable<T>;
|
||||
|
||||
// todo: Enumerable<Enumerable<T>>.catch(): Enumerable<T>
|
||||
//catch<TInner, T extends Enumerable<TInner>>(): Enumerable<TInner>;
|
||||
|
||||
finally(finallyAction: () => void): Enumerable<T>;
|
||||
finallyDo(finallyAction: () => void): Enumerable<T>;
|
||||
|
||||
onErrorResumeNext(second: Enumerable<T>): Enumerable<T>;
|
||||
|
||||
retry(retryCount?: number): Enumerable<T>;
|
||||
}
|
||||
|
||||
export interface EnumerableStatic {
|
||||
throw<T>(error: Error): Enumerable<T>;
|
||||
throwException<T>(error: Error): Enumerable<T>;
|
||||
|
||||
defer<T>(enumerableFactory: () => Enumerable<T>): Enumerable<T>;
|
||||
|
||||
generate<TState, TResult>(
|
||||
initialState: TState,
|
||||
condition: Predicate<TState>,
|
||||
iterate: (state: TState) => TState,
|
||||
resultSelector: (state: TState) => TResult): Enumerable<TResult>;
|
||||
|
||||
using<TResource extends Disposable, T>(
|
||||
resourceFactory: () => TResource,
|
||||
enumerableFactory: (resource: TResource) => Enumerable<T>): Enumerable<T>;
|
||||
|
||||
catch<T>(...sources: Enumerable<T>[]): Enumerable<T>;
|
||||
catchException<T>(...sources: Enumerable<T>[]): Enumerable<T>;
|
||||
|
||||
onErrorResumeNext<T>(...sources: Enumerable<T>[]): Enumerable<T>;
|
||||
|
||||
while<T>(condition: EnumerablePredicate<Enumerable<T>>, source: Enumerable<T>): Enumerable<T>;
|
||||
whileDo<T>(condition: EnumerablePredicate<Enumerable<T>>, source: Enumerable<T>): Enumerable<T>;
|
||||
|
||||
if<T>(condition: () => boolean, thenSource: Enumerable<T>, elseSource?: Enumerable<T>): Enumerable<T>;
|
||||
ifThen<T>(condition: () => boolean, thenSource: Enumerable<T>, elseSource?: Enumerable<T>): Enumerable<T>;
|
||||
|
||||
doWhile<T>(source: Enumerable<T>, condition: EnumerablePredicate<Enumerable<T>>): Enumerable<T>;
|
||||
|
||||
case<T>(selector: () => number, sources: { [key: number]: Enumerable<T>; }, defaultSource?: Enumerable<T>): Enumerable<T>;
|
||||
case<T>(selector: () => string, sources: { [key: string]: Enumerable<T>; }, defaultSource?: Enumerable<T>): Enumerable<T>;
|
||||
switchCase<T>(selector: () => number, sources: { [key: number]: Enumerable<T>; }, defaultSource?: Enumerable<T>): Enumerable<T>;
|
||||
switchCase<T>(selector: () => string, sources: { [key: string]: Enumerable<T>; }, defaultSource?: Enumerable<T>): Enumerable<T>;
|
||||
|
||||
for<T, TResult>(source: Enumerable<T>, resultSelector: EnumerableFunc<T, TResult>): Enumerable<TResult>;
|
||||
forIn<T, TResult>(source: Enumerable<T>, resultSelector: EnumerableFunc<T, TResult>): Enumerable<TResult>;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,221 @@
|
||||
///<reference path="l2o.d.ts"/>
|
||||
|
||||
var ec_ns = (a: number, b: string) => a.toString() == b; //equality comparer on number,string
|
||||
var ec_nn = (a: number, b: number) => a === b; //equality comparer on number,number
|
||||
var c_nn = (a: number, b: number) => a - b; //comparer on number,number
|
||||
|
||||
// static
|
||||
|
||||
var ax = Ix.Enumerable.fromArray([0, 2, 7, 3, 4, 5]);
|
||||
|
||||
var bx = Ix.Enumerable.create(() => {
|
||||
var current = ".";
|
||||
return Ix.Enumerator.create(
|
||||
() => { current += "."; return true; },
|
||||
() => current,
|
||||
() => { });
|
||||
});
|
||||
|
||||
Ix.Enumerator.create(() => true, () => 1); // without dispose method
|
||||
|
||||
var cx = Ix.Enumerable.empty<number>();
|
||||
|
||||
var dx = Ix.Enumerable.concat(ax, cx);
|
||||
|
||||
var ex = Ix.Enumerable.return(42);
|
||||
var fx = Ix.Enumerable.returnValue("42");
|
||||
|
||||
var gx = Ix.Enumerable.range(-100, 200);
|
||||
|
||||
Ix.Enumerable.repeat(42, 42);
|
||||
Ix.Enumerable.repeat(42); // infinite
|
||||
|
||||
Ix.Enumerable.sequenceEqual(ax, fx, ec_ns);
|
||||
Ix.Enumerable.sequenceEqual(ax, ex); // default comparer on same type
|
||||
|
||||
// instance
|
||||
|
||||
ax.getEnumerator();
|
||||
|
||||
ax.aggregate("", (acc, i) => acc + i, acc=> acc.length);
|
||||
ax.aggregate("", (acc, i) => acc + i);
|
||||
ax.aggregate((acc, i) => acc + i);
|
||||
|
||||
ax.reduce((acc, i) => acc + i, 100);
|
||||
ax.reduce((acc, i) => acc + i);
|
||||
|
||||
ax.all(item => true);
|
||||
ax.all(item => true, bx);
|
||||
ax.every(item => true);
|
||||
ax.every(item => true, bx);
|
||||
|
||||
ax.any();
|
||||
ax.any(item => true);
|
||||
ax.any(item => true, bx);
|
||||
ax.some();
|
||||
ax.some(item => true);
|
||||
ax.some(item => true, bx);
|
||||
|
||||
ax.average();
|
||||
bx.average(item => item.length);
|
||||
ax.min();
|
||||
bx.min(item => item.length);
|
||||
ax.max();
|
||||
bx.max(item => item.length);
|
||||
ax.sum();
|
||||
bx.sum(item => item.length);
|
||||
|
||||
ax.concat(ax, cx, dx, ex, gx);
|
||||
|
||||
ax.contains(10);
|
||||
ax.contains("10", ec_ns);
|
||||
|
||||
ax.count();
|
||||
ax.count(item=>false);
|
||||
ax.count(item=> false, {});
|
||||
|
||||
cx.defaultIfEmpty();
|
||||
cx.defaultIfEmpty(10);
|
||||
|
||||
dx.distinct();
|
||||
dx.distinct((d1, d2) => d1 === d2);
|
||||
|
||||
ax.elementAt(2);
|
||||
ax.elementAtOrDefault(2);
|
||||
|
||||
//ax.except(bx, ec_ns); // bug https://typescript.codeplex.com/workitem/1841
|
||||
bx.except(fx);
|
||||
|
||||
ax.first();
|
||||
ax.firstOrDefault();
|
||||
ax.last();
|
||||
ax.lastOrDefault();
|
||||
ax.single();
|
||||
ax.singleOrDefault();
|
||||
|
||||
ax.forEach(a => console.log(a));
|
||||
ax.forEach(a => console.log(a), cx);
|
||||
|
||||
//bx.groupBy(b => b.length); // spec 3.5.2, waiting for restriction on generative recursion removal
|
||||
bx.groupBy(b => b.length, b => "[" + b + "]");
|
||||
bx.groupBy(b => b.length, b => "[" + b + "]", (l, values) => l + values.count());
|
||||
bx.groupBy(b => b.length, false, (l, values) => l + values.count());
|
||||
bx.groupBy(b => b.length, b => "[" + b + "]", (l, values) => l + values.count(), ec_nn);
|
||||
bx.groupBy(b => b.length, b => "[" + b + "]", false, (x, y) => x == y);
|
||||
bx.groupBy(b => b.length, false, (l, values) => l + values.count(), ec_nn);
|
||||
//bx.groupBy(b => b.length, false, false, ec_nn); // spec 3.5.2, waiting for restriction on generative recursion removal
|
||||
|
||||
ax.groupJoin(bx, a => a, b => b, (a, b) => [a, b], ec_ns);
|
||||
ax.groupJoin(bx, a => a, b => b.length, (a, b) => [a, b]);
|
||||
|
||||
ax.join(bx, a => a, b => b, (a, b) => [a, b], ec_ns);
|
||||
ax.join(bx, a => a, b => b.length, (a, b) => [a, b]);
|
||||
|
||||
//ax.intersect(bx, ec_ns); // bug https://typescript.codeplex.com/workitem/1841
|
||||
ax.intersect(cx);
|
||||
ax.union(cx);
|
||||
|
||||
ax.orderBy(a=> -a).thenBy(a => a);
|
||||
ax.orderBy(a=> -a, c_nn).thenBy(a => a, c_nn);
|
||||
ax.orderByDescending(a=> -a).thenByDescending(a => a);
|
||||
ax.orderByDescending(a=> -a, c_nn).thenByDescending(a => a, c_nn);
|
||||
|
||||
ax.reverse();
|
||||
|
||||
ax.select(a=> a.toString());
|
||||
ax.select(a=> a.toString(), {});
|
||||
ax.map(a=> a.toString());
|
||||
ax.map(a=> a.toString(), {});
|
||||
|
||||
ax.selectMany(a=> bx);
|
||||
ax.selectMany(a=> bx, (a, b) => [a, b]);
|
||||
|
||||
ax.sequenceEqual(fx, ec_ns);
|
||||
ax.sequenceEqual(ax, ec_nn);
|
||||
ax.sequenceEqual(cx);
|
||||
|
||||
ax.skip(10);
|
||||
ax.skipWhile(a => a > 10);
|
||||
ax.take(10);
|
||||
ax.takeWhile(a => a > 10);
|
||||
|
||||
ax.toArray();
|
||||
|
||||
bx.toDictionary(b => b.length, b => 10, ec_nn);
|
||||
//bx.toDictionary(b => b.length, false, ec_nn); // spec 3.5.2, waiting for restriction on generative recursion removal
|
||||
bx.toDictionary(b => b.length, b => 10);
|
||||
//bx.toDictionary(b => b.length); // spec 3.5.2, waiting for restriction on generative recursion removal
|
||||
|
||||
bx.toLookup(b => b.length, b => 10, ec_nn);
|
||||
//bx.toLookup(b => b.length, false, ec_nn); // spec 3.5.2, waiting for restriction on generative recursion removal
|
||||
bx.toLookup(b => b.length, b => 10);
|
||||
//bx.toLookup(b => b.length); // spec 3.5.2, waiting for restriction on generative recursion removal
|
||||
|
||||
ax.where(a=> a > 10, {});
|
||||
ax.where(a=> a > 10);
|
||||
ax.filter(a=> a > 10, {});
|
||||
ax.filter(a=> a > 10);
|
||||
|
||||
ax.zip(bx, (a: number, b: string) => [a, b]);
|
||||
ax.zip(bx, (a, b) => [a, b]);
|
||||
|
||||
// Disposable
|
||||
|
||||
{
|
||||
var d: Ix.Disposable;
|
||||
|
||||
d.dispose();
|
||||
}
|
||||
|
||||
// Enumerator
|
||||
|
||||
{
|
||||
var e: Ix.Enumerator<number>;
|
||||
|
||||
try {
|
||||
while (e.moveNext()) { var c = e.getCurrent(); }
|
||||
}
|
||||
finally {
|
||||
e.dispose();
|
||||
}
|
||||
}
|
||||
|
||||
// Dictionary
|
||||
|
||||
{
|
||||
var dic = new Ix.Dictionary<number, string>(0, ec_nn);
|
||||
|
||||
var key = dic.toEnumerable().first().key;
|
||||
var value = dic.toEnumerable().first().value;
|
||||
|
||||
dic.add(1, "1");
|
||||
dic.remove(1);
|
||||
dic.clear();
|
||||
dic.length();
|
||||
dic.tryGetValue(1);
|
||||
dic.get(1);
|
||||
dic.set(1, "1");
|
||||
dic.getValues();
|
||||
dic.has(1);
|
||||
}
|
||||
|
||||
// KeyValuePair
|
||||
|
||||
{
|
||||
var kv: Ix.KeyValuePair<number, string>;
|
||||
var key = kv.key;
|
||||
var value = kv.value;
|
||||
}
|
||||
|
||||
// Lookup
|
||||
|
||||
{
|
||||
var lookup: Ix.Lookup<number, string>;
|
||||
|
||||
var key = lookup.toEnumerable().first().key;
|
||||
lookup.toEnumerable().first().first();
|
||||
|
||||
lookup.has(1);
|
||||
lookup.length();
|
||||
lookup.get(1).first();
|
||||
}
|
||||
Vendored
+256
@@ -0,0 +1,256 @@
|
||||
// Type definitions for IxJS 1.0.6 / l2o.js
|
||||
// Project: https://github.com/Reactive-Extensions/IxJS
|
||||
// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
|
||||
|
||||
declare module Ix {
|
||||
export interface Disposable {
|
||||
dispose(): void;
|
||||
}
|
||||
|
||||
export interface Enumerator<T> extends Disposable {
|
||||
moveNext(): boolean;
|
||||
getCurrent(): T;
|
||||
}
|
||||
|
||||
export interface EnumeratorStatic {
|
||||
new <T>(moveNext: () => boolean, getCurrent: () => T, dispose: () => void): Enumerator<T>;
|
||||
create<T>(moveNext: () => boolean, getCurrent: () => T, dispose?: () => void): Enumerator<T>;
|
||||
}
|
||||
|
||||
var Enumerator: EnumeratorStatic;
|
||||
|
||||
export interface EnumerableFunc<T, TResult> {
|
||||
(item: T, index: number, self: Enumerable<T>): TResult;
|
||||
}
|
||||
export interface EnumerablePredicate<T> extends EnumerableFunc<T, boolean> { }
|
||||
export interface Predicate<T> {
|
||||
(item: T): boolean;
|
||||
}
|
||||
export interface EqualityComparer<TFirst, TSecond> {
|
||||
(item1: TFirst, item2: TSecond): boolean;
|
||||
}
|
||||
export interface Comparer<TFirst, TSecond> {
|
||||
(item1: TFirst, item2: TSecond): number;
|
||||
}
|
||||
|
||||
export interface Enumerable<T> {
|
||||
// base functions
|
||||
getEnumerator(): Enumerator<T>;
|
||||
|
||||
// "extension" functions
|
||||
|
||||
aggregate<TAccumulate, TResult>(seed: TAccumulate, func: (accumulate: TAccumulate, current: T, index: number, self: Enumerable<T>) => TAccumulate, resultSelector: (accumulate: TAccumulate) => TResult): TResult;
|
||||
aggregate<TAccumulate>(seed: TAccumulate, func: (accumulate: TAccumulate, current: T, index: number, self: Enumerable<T>) => TAccumulate): TAccumulate;
|
||||
aggregate(func: (accumulate: T, current: T, index: number, self: Enumerable<T>) => T): T;
|
||||
|
||||
reduce(func: (accumulate: T, current: T, index: number, self: Enumerable<T>) => T): T;
|
||||
reduce<TAccumulate>(func: (accumulate: TAccumulate, current: T, index: number, self: Enumerable<T>) => TAccumulate, seed: TAccumulate): TAccumulate;
|
||||
|
||||
all(predicate: EnumerablePredicate<T>, thisArg?: any): boolean;
|
||||
every(predicate: EnumerablePredicate<T>, thisArg?: any): boolean; // alias
|
||||
|
||||
any(predicate?: EnumerablePredicate<T>, thisArg?: any): boolean;
|
||||
some(predicate?: EnumerablePredicate<T>, thisArg?: any): boolean; // alias
|
||||
|
||||
average(selector?: EnumerableFunc<T, number>): number;
|
||||
max(selector?: EnumerableFunc<T, number>): number;
|
||||
min(selector?: EnumerableFunc<T, number>): number;
|
||||
sum(selector?: EnumerableFunc<T, number>): number;
|
||||
|
||||
concat<T>(...sources: Enumerable<T>[]): Enumerable<T>;
|
||||
|
||||
contains<TValue>(value: TValue, comparer: EqualityComparer<T, TValue>): boolean;
|
||||
contains(value: T): boolean;
|
||||
|
||||
count(predicate?: EnumerablePredicate<T>, thisArg?: any): number;
|
||||
|
||||
defaultIfEmpty(defaultValue?: T): Enumerable<T>;
|
||||
|
||||
distinct(comparer?: EqualityComparer<T, T>): Enumerable<T>;
|
||||
|
||||
elementAt(index: number): T;
|
||||
elementAtOrDefault(index: number): T;
|
||||
|
||||
except<TOther>(second: Enumerable<TOther>, comparer: EqualityComparer<T, TOther>): Enumerable<T>;
|
||||
except(second: Enumerable<T>): Enumerable<T>;
|
||||
|
||||
first(predicate?: Predicate<T>): T;
|
||||
firstOrDefault(predicate?: Predicate<T>): T;
|
||||
last(predicate?: Predicate<T>): T;
|
||||
lastOrDefault(predicate?: Predicate<T>): T;
|
||||
single(predicate?: Predicate<T>): T;
|
||||
singleOrDefault(predicate?: Predicate<T>): T;
|
||||
|
||||
forEach(action: EnumerableFunc<T, void>, thisArg?: any): void;
|
||||
|
||||
groupBy<TKey, TElement, TResult>(
|
||||
keySelector: (item: T) => TKey,
|
||||
elementSelector: (item: T) => TElement,
|
||||
resultSelector: (key: TKey, values: Enumerable<TElement>) => TResult,
|
||||
comparer?: EqualityComparer<TKey, TKey>): Enumerable<TResult>;
|
||||
groupBy<TKey, TElement>(
|
||||
keySelector: (item: T) => TKey,
|
||||
elementSelector: (item: T) => TElement): Grouping<TKey, TElement>;
|
||||
// spec 3.5.2, waiting for restriction on generative recursion removal
|
||||
/*groupBy<TKey>(
|
||||
keySelector: (item: T) => TKey): Grouping<TKey, T>;*/
|
||||
|
||||
// if need to set comparer without resultSelector
|
||||
groupBy<TKey, TElement>(
|
||||
keySelector: (item: T) => TKey,
|
||||
elementSelector: (item: T) => TElement,
|
||||
_: boolean,
|
||||
comparer: EqualityComparer<TKey, TKey>): Grouping<TKey, TElement>;
|
||||
// if need to set resultSelector without elementSelector
|
||||
groupBy<TKey, TResult>(
|
||||
keySelector: (item: T) => TKey,
|
||||
_: boolean,
|
||||
resultSelector: (key: TKey, values: Enumerable<T>) => TResult,
|
||||
comparer?: EqualityComparer<TKey, TKey>): Enumerable<TResult>;
|
||||
// if need to set comparer without elementSelector and resultSelector
|
||||
// spec 3.5.2, waiting for restriction on generative recursion removal
|
||||
/*groupBy<TKey>(
|
||||
keySelector: (item: T) => TKey,
|
||||
_: boolean,
|
||||
__: boolean,
|
||||
comparer: EqualityComparer<TKey, TKey>): Grouping<TKey, T>;*/
|
||||
|
||||
groupJoin<TInner, TOuterKey, TInnerKey, TResult>(
|
||||
inner: Enumerable<TInner>,
|
||||
outerKeySelector: (item: T) => TOuterKey,
|
||||
innerKeySelector: (item: TInner) => TInnerKey,
|
||||
resultSelector: (outer: T, innerSequence: Enumerable<TInner>) => TResult,
|
||||
comparer: EqualityComparer<TOuterKey, TInnerKey>): Enumerable<TResult>;
|
||||
groupJoin<TInner, TKey, TResult>(
|
||||
inner: Enumerable<TInner>,
|
||||
outerKeySelector: (item: T) => TKey,
|
||||
innerKeySelector: (item: TInner) => TKey,
|
||||
resultSelector: (outer: T, innerSequence: Enumerable<TInner>) => TResult): Enumerable<TResult>;
|
||||
|
||||
join<TInner, TOuterKey, TInnerKey, TResult>(
|
||||
inner: Enumerable<TInner>,
|
||||
outerKeySelector: (item: T) => TOuterKey,
|
||||
innerKeySelector: (item: TInner) => TInnerKey,
|
||||
resultSelector: (outer: T, inner: TInner) => TResult,
|
||||
comparer: EqualityComparer<TOuterKey, TInnerKey>): Enumerable<TResult>;
|
||||
join<TInner, TKey, TResult>(
|
||||
inner: Enumerable<TInner>,
|
||||
outerKeySelector: (item: T) => TKey,
|
||||
innerKeySelector: (item: TInner) => TKey,
|
||||
resultSelector: (outer: T, inner: TInner) => TResult): Enumerable<TResult>;
|
||||
|
||||
intersect<TSecond>(second: Enumerable<TSecond>, comparer: EqualityComparer<T, TSecond>): Enumerable<T>;
|
||||
intersect(second: Enumerable<T>): Enumerable<T>;
|
||||
union(second: Enumerable<T>, comparer?: EqualityComparer<T, T>): Enumerable<T>;
|
||||
|
||||
orderBy<TKey>(keySelector: (item: T) => TKey, comparer?: Comparer<TKey, TKey>): OrderedEnumerable<T>;
|
||||
orderByDescending<TKey>(keySelector: (item: T) => TKey, comparer?: Comparer<TKey, TKey>): OrderedEnumerable<T>;
|
||||
|
||||
reverse(): Enumerable<T>;
|
||||
|
||||
select<TResult>(selector: EnumerableFunc<T, TResult>, thisArg?: any): Enumerable<TResult>;
|
||||
map<TResult>(selector: EnumerableFunc<T, TResult>, thisArg?: any): Enumerable<TResult>;
|
||||
|
||||
selectMany<TCollection, TResult>(collectionSelector: (item: T, index: number) => Enumerable<TCollection>,
|
||||
resultSelector: (outer: T, inner: TCollection) => TResult): Enumerable<TResult>;
|
||||
selectMany<TCollection>(collectionSelector: (item: T, index: number) => Enumerable<TCollection>): Enumerable<TCollection>;
|
||||
|
||||
sequenceEqual<TSecond>(second: Enumerable<TSecond>, comparer: EqualityComparer<T, TSecond>): boolean;
|
||||
sequenceEqual(second: Enumerable<T>): boolean;
|
||||
|
||||
skip(count: number): Enumerable<T>;
|
||||
skipWhile(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
|
||||
take(count: number): Enumerable<T>;
|
||||
takeWhile(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
|
||||
|
||||
toArray(): T[];
|
||||
|
||||
toDictionary<TKey, TValue>(
|
||||
keySelector: (item: T) => TKey,
|
||||
elementSelector: (item: T) => TValue,
|
||||
comparer?: EqualityComparer<TKey, TKey>): Dictionary<TKey, TValue>;
|
||||
// spec 3.5.2, waiting for restriction on generative recursion removal
|
||||
/*toDictionary<TKey>(
|
||||
keySelector: (item: T) => TKey): Dictionary<TKey, T>;*/
|
||||
// if need to set comparer without elementSelector
|
||||
// spec 3.5.2, waiting for restriction on generative recursion removal
|
||||
/*toDictionary<TKey>(
|
||||
keySelector: (item: T) => TKey,
|
||||
_: boolean,
|
||||
comparer: EqualityComparer<TKey, TKey>): Dictionary<TKey, T>;*/
|
||||
|
||||
toLookup<TKey, TValue>(
|
||||
keySelector: (item: T) => TKey,
|
||||
elementSelector: (item: T) => TValue,
|
||||
comparer?: EqualityComparer<TKey, TKey>): Lookup<TKey, TValue>;
|
||||
// spec 3.5.2, waiting for restriction on generative recursion removal
|
||||
/*toLookup<TKey>(
|
||||
keySelector: (item: T) => TKey): Lookup<TKey, T>;*/
|
||||
// if need to set comparer without elementSelector
|
||||
// spec 3.5.2, waiting for restriction on generative recursion removal
|
||||
/*toLookup<TKey>(
|
||||
keySelector: (item: T) => TKey,
|
||||
_: boolean,
|
||||
comparer: EqualityComparer<TKey, TKey>): Lookup<TKey, T>;*/
|
||||
|
||||
where(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
|
||||
filter(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
|
||||
|
||||
zip<TRight, TResult>(right: Enumerable<TRight>, selector: (left: T, right: TRight) => TResult): Enumerable<TResult>;
|
||||
}
|
||||
|
||||
export interface Grouping<TKey, T> extends Enumerable<T> {
|
||||
key: TKey;
|
||||
}
|
||||
|
||||
export interface OrderedEnumerable<T> extends Enumerable<T> {
|
||||
thenBy<TKey>(keySelector: (item: T) => TKey, comparer?: Comparer<TKey, TKey>): OrderedEnumerable<T>;
|
||||
thenByDescending<TKey>(keySelector: (item: T) => TKey, comparer?: Comparer<TKey, TKey>): OrderedEnumerable<T>;
|
||||
}
|
||||
|
||||
class Dictionary<TKey, TValue> {
|
||||
constructor(capacity?: number, comparer?: EqualityComparer<TKey, TKey>);
|
||||
|
||||
toEnumerable(): Enumerable<KeyValuePair<TKey, TValue>>;
|
||||
|
||||
add(key: TKey, value: TValue): void;
|
||||
remove(key: TKey): boolean;
|
||||
clear(): void;
|
||||
length(): number;
|
||||
tryGetValue(key: TKey): TValue;
|
||||
get(key: TKey): TValue;
|
||||
set(key: TKey, value: TValue): void;
|
||||
getValues(): TValue[];
|
||||
has(key: TKey): boolean;
|
||||
}
|
||||
|
||||
export interface KeyValuePair<TKey, TValue> {
|
||||
key: TKey;
|
||||
value: TValue;
|
||||
}
|
||||
|
||||
export interface Lookup<TKey, TValue> {
|
||||
toEnumerable(): Enumerable<Grouping<TKey, TValue>>;
|
||||
has(key: TKey): boolean;
|
||||
length(): number;
|
||||
get(key: TKey): Enumerable<TValue>;
|
||||
}
|
||||
|
||||
export interface EnumerableStatic {
|
||||
new <T>(getEnumerator: () => Enumerator<T>): Enumerable<T>;
|
||||
create<T>(getEnumerator: () => Enumerator<T>): Enumerable<T>;
|
||||
|
||||
concat<T>(...sources: Enumerable<T>[]): Enumerable<T>;
|
||||
empty<T>(): Enumerable<T>;
|
||||
fromArray<T>(array: T[]): Enumerable<T>;
|
||||
return<T>(value: T): Enumerable<T>;
|
||||
returnValue<T>(value: T): Enumerable<T>; // alias for <IE9
|
||||
range(start: number, count: number): Enumerable<number>;
|
||||
repeat<T>(value: T, repeatCount?: number): Enumerable<T>;
|
||||
|
||||
sequenceEqual<TFirst, TSecond>(first: Enumerable<TFirst>, second: Enumerable<TSecond>, comparer: EqualityComparer<TFirst, TSecond>): boolean;
|
||||
sequenceEqual<T>(first: Enumerable<T>, second: Enumerable<T>): boolean;
|
||||
}
|
||||
|
||||
var Enumerable: EnumerableStatic;
|
||||
}
|
||||
Reference in New Issue
Block a user