mirror of
https://github.com/wassname/DefinitelyTyped.git
synced 2026-08-27 11:40:08 +08:00
Merge pull request #3174 from Sebazzz/generic-linqjs
Generic linqjs typing
This commit is contained in:
Masahiro Wakame
+1
-1
@@ -30,7 +30,7 @@ describe("Linq.js tests", function () {
|
||||
it("Grouping Methods", function () {
|
||||
expect(Enumerable.From(["a","aa","aaa","a","a","aaa"])
|
||||
.GroupBy((item:string) => item.length)
|
||||
.Select((g: linq.Grouping) => { return { key: g.Key(), count: g.Count() }; })
|
||||
.Select((g: linq.Grouping<string>) => { return { key: g.Key(), count: g.Count() }; })
|
||||
.OrderBy(g => g.key)
|
||||
.Select(g => g.key+":"+g.count)
|
||||
.ToString(",")).toBe("1:3,2:1,3:2");
|
||||
|
||||
Vendored
+166
-146
@@ -1,6 +1,6 @@
|
||||
// Type definitions for linq.js 2.2
|
||||
// Project: http://linqjs.codeplex.com/
|
||||
// Definitions by: Marcin Najder <https://github.com/marcinnajder>
|
||||
// Definitions by: Marcin Najder <https://github.com/marcinnajder>, Sebastiaan Dammann <https://github.com/Sebazzz>
|
||||
// Definitions: https://github.com/borisyankov/DefinitelyTyped
|
||||
|
||||
// todo: jQuery plugin, RxJS Binding
|
||||
@@ -8,107 +8,110 @@
|
||||
declare module linq {
|
||||
|
||||
interface EnumerableStatic {
|
||||
Choice(...contents: any[]): Enumerable;
|
||||
Choice(contents: any[]): Enumerable;
|
||||
Cycle(...contents: any[]): Enumerable;
|
||||
Cycle(contents: any[]): Enumerable;
|
||||
Empty(): Enumerable;
|
||||
From(obj: any[]): Enumerable;
|
||||
From(obj: any): Enumerable;
|
||||
Return(element: any): Enumerable;
|
||||
Matches(input: string, pattern: RegExp): Enumerable;
|
||||
Matches(input: string, pattern: string, flags?: string): Enumerable;
|
||||
Range(start: number, count: number, step?: number): Enumerable;
|
||||
RangeDown(start: number, count: number, step?: number): Enumerable;
|
||||
RangeTo(start: number, to: number, step?: number): Enumerable;
|
||||
Repeat(obj: any, count?: number): Enumerable;
|
||||
RepeatWithFinalize(initializer: () => any, finalizer: (resource: any) =>void ): Enumerable;
|
||||
Generate(func: () => any, count?: number): Enumerable;
|
||||
Generate(func: string, count?: number): Enumerable;
|
||||
ToInfinity(start?: number, step?: number): Enumerable;
|
||||
ToNegativeInfinity(start?: number, step?: number): Enumerable;
|
||||
Unfold(seed, func: ($) => any): Enumerable;
|
||||
Unfold(seed, func: string): Enumerable;
|
||||
Choice<T>(...contents: T[]): Enumerable<T>;
|
||||
Choice<T>(contents: T[]): Enumerable<T>;
|
||||
Cycle<T>(...contents: T[]): Enumerable<T>;
|
||||
Cycle<T>(contents: T[]): Enumerable<T>;
|
||||
Empty<T>(): Enumerable<T>;
|
||||
From<T>(obj: T[]): Enumerable<T>;
|
||||
From(obj: number): Enumerable<number>; // input number returns single number
|
||||
From(obj: string): Enumerable<string>; // input string returns sequence of characters
|
||||
From(obj: NodeList): Enumerable<Node>; // node list returns sequence of nodes
|
||||
From(obj: Object): Enumerable<KeyValuePair<string, any>>; // object returns sequence of key/value pairs
|
||||
Return<T>(element: T): Enumerable<T>;
|
||||
Matches<T>(input: string, pattern: RegExp): Enumerable<string>;
|
||||
Matches<T>(input: string, pattern: string, flags?: string): Enumerable<string>;
|
||||
Range(start: number, count: number, step?: number): Enumerable<number>;
|
||||
RangeDown(start: number, count: number, step?: number): Enumerable<number>;
|
||||
RangeTo(start: number, to: number, step?: number): Enumerable<number>;
|
||||
Repeat<T>(obj: any, count?: number): Enumerable<T>;
|
||||
RepeatWithFinalize<T>(initializer: () => T, finalizer: (resource: T) => void): Enumerable<T>;
|
||||
Generate<T>(func: () => T, count?: number): Enumerable<T>;
|
||||
Generate(func: string, count?: number): Enumerable<any>;
|
||||
ToInfinity(start?: number, step?: number): Enumerable<number>;
|
||||
ToNegativeInfinity(start?: number, step?: number): Enumerable<number>;
|
||||
Unfold<T>(seed, func: ($) => T): Enumerable<T>;
|
||||
Unfold(seed, func: string): Enumerable<any>;
|
||||
}
|
||||
|
||||
interface Enumerable {
|
||||
interface Enumerable<T> {
|
||||
//Projection and Filtering Methods
|
||||
CascadeBreadthFirst(func: ($) => any[], resultSelector: (v, i: number) => any): Enumerable;
|
||||
CascadeBreadthFirst(func: string, resultSelector: string): Enumerable;
|
||||
CascadeDepthFirst(func: ($) => any[], resultSelector: (v, i: number) => any): Enumerable;
|
||||
CascadeDepthFirst(func: string, resultSelector: string): Enumerable;
|
||||
Flatten(...items: any[]): Enumerable;
|
||||
Pairwise(selector: (prev, next) => any): Enumerable;
|
||||
Pairwise(selector: string): Enumerable;
|
||||
Scan(func: (a, b) => any): Enumerable;
|
||||
Scan(func: string): Enumerable;
|
||||
Scan(seed, func: (a, b) => any, resultSelector?: ($) => any): Enumerable;
|
||||
Scan(seed, func: string, resultSelector?: string): Enumerable;
|
||||
Select(selector: ($, i: number) => any): Enumerable;
|
||||
Select(selector: string): Enumerable;
|
||||
SelectMany(collectionSelector: ($, i: number) => any[], resultSelector?: ($, item) => any): Enumerable;
|
||||
SelectMany(collectionSelector: ($, i: number) => Enumerable, resultSelector?: ($, item) => any): Enumerable;
|
||||
SelectMany(collectionSelector: string, resultSelector?: string): Enumerable;
|
||||
Where(predicate: ($, i: number) => boolean): Enumerable;
|
||||
Where(predicate: string): Enumerable;
|
||||
OfType(type: Function): Enumerable;
|
||||
Zip(second: any[], selector: (v1, v2, i: number) => any): Enumerable;
|
||||
Zip(second: any[], selector: string): Enumerable;
|
||||
Zip(second: Enumerable, selector: (v1, v2, i: number) => any): Enumerable;
|
||||
Zip(second: Enumerable, selector: string): Enumerable;
|
||||
CascadeBreadthFirst(func: ($) => any[], resultSelector: (v, i: number) => any): Enumerable<any>;
|
||||
CascadeBreadthFirst(func: string, resultSelector: string): Enumerable<any>;
|
||||
CascadeDepthFirst(func: ($) => any[], resultSelector: (v, i: number) => any): Enumerable<any>;
|
||||
CascadeDepthFirst(func: string, resultSelector: string): Enumerable<any>;
|
||||
Flatten(...items: any[]): Enumerable<any>;
|
||||
Pairwise(selector: (prev, next) => any): Enumerable<any>;
|
||||
Pairwise(selector: string): Enumerable<any>;
|
||||
Scan(func: (a, b) => any): Enumerable<any>;
|
||||
Scan(func: string): Enumerable<any>;
|
||||
Scan(seed, func: (a, b) => any, resultSelector?: ($) => any): Enumerable<any>;
|
||||
Scan(seed, func: string, resultSelector?: string): Enumerable<any>;
|
||||
Select<TResult>(selector: ($: T, i: number) => TResult): Enumerable<TResult>;
|
||||
Select(selector: string): Enumerable<any>;
|
||||
SelectMany(collectionSelector: ($, i: number) => any[], resultSelector?: ($, item) => any): Enumerable<any>;
|
||||
SelectMany(collectionSelector: ($, i: number) => Enumerable<any>, resultSelector?: ($, item) => any): Enumerable<any>;
|
||||
SelectMany(collectionSelector: string, resultSelector?: string): Enumerable<any>;
|
||||
Where(predicate: ($ : T, i: number) => boolean): Enumerable<T>;
|
||||
Where(predicate: string): Enumerable<any>;
|
||||
OfType(type: Function): Enumerable<any>;
|
||||
Zip(second: any[], selector: (v1, v2, i: number) => any): Enumerable<any>;
|
||||
Zip(second: any[], selector: string): Enumerable<any>;
|
||||
Zip(second: Enumerable<any>, selector: (v1, v2, i: number) => any): Enumerable<any>;
|
||||
Zip(second: Enumerable<any>, selector: string): Enumerable<any>;
|
||||
//Join Methods
|
||||
Join(inner: any[], outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2) => any, compareSelector?: (v) => any): Enumerable;
|
||||
Join(inner: any[], outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable;
|
||||
Join(inner: Enumerable, outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2) => any, compareSelector?: (v) => any): Enumerable;
|
||||
Join(inner: Enumerable, outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable;
|
||||
GroupJoin(inner: any[], outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2: Enumerable) => any, compareSelector?: (v) => any): Enumerable;
|
||||
GroupJoin(inner: any[], outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable;
|
||||
GroupJoin(inner: Enumerable, outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2: Enumerable) => any, compareSelector?: (v) => any): Enumerable;
|
||||
GroupJoin(inner: Enumerable, outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable;
|
||||
Join(inner: any[], outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2) => any, compareSelector?: (v) => any): Enumerable<any>;
|
||||
Join(inner: any[], outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable<any>;
|
||||
Join(inner: Enumerable<any>, outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2) => any, compareSelector?: (v) => any): Enumerable<any>;
|
||||
Join(inner: Enumerable<any>, outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable<any>;
|
||||
GroupJoin(inner: any[], outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2: Enumerable<any>) => any, compareSelector?: (v) => any): Enumerable<any>;
|
||||
GroupJoin(inner: any[], outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable<any>;
|
||||
GroupJoin(inner: Enumerable<any>, outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2: Enumerable<any>) => any, compareSelector?: (v) => any): Enumerable<any>;
|
||||
GroupJoin(inner: Enumerable<any>, outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable<any>;
|
||||
//Set Methods
|
||||
All(predicate: ($) => boolean): boolean;
|
||||
All(predicate: ($ : T) => boolean): boolean;
|
||||
All(predicate: string): boolean;
|
||||
Any(predicate?: ($) => boolean): boolean;
|
||||
Any(predicate?: ($: T) => boolean): boolean;
|
||||
Any(predicate?: string): boolean;
|
||||
Concat(second: any[]): Enumerable;
|
||||
Concat(second: Enumerable): Enumerable;
|
||||
Insert(index: number, second: any[]): Enumerable;
|
||||
Insert(index: number, second: Enumerable): Enumerable;
|
||||
Alternate(value): Enumerable;
|
||||
Concat(second: any[]): Enumerable<any>;
|
||||
Concat(second: Enumerable<any>): Enumerable<any>;
|
||||
Insert(index: number, second: any[]): Enumerable<any>;
|
||||
Insert(index: number, second: Enumerable<any>): Enumerable<any>;
|
||||
Alternate(value): Enumerable<any>;
|
||||
Contains(value, compareSelector?: ($) => any): boolean;
|
||||
Contains(value, compareSelector?: string): boolean;
|
||||
DefaultIfEmpty(defaultValue): Enumerable;
|
||||
Distinct(compareSelector?: ($) => any): Enumerable;
|
||||
Distinct(compareSelector?: string): Enumerable;
|
||||
Except(second: any[], compareSelector?: ($) => any): Enumerable;
|
||||
Except(second: any[], compareSelector?: string): Enumerable;
|
||||
Except(second: Enumerable, compareSelector?: ($) => any): Enumerable;
|
||||
Except(second: Enumerable, compareSelector?: string): Enumerable;
|
||||
Intersect(second: any[], compareSelector?: ($) => any): Enumerable;
|
||||
Intersect(second: any[], compareSelector?: string): Enumerable;
|
||||
Intersect(second: Enumerable, compareSelector?: ($) => any): Enumerable;
|
||||
Intersect(second: Enumerable, compareSelector?: string): Enumerable;
|
||||
DefaultIfEmpty(defaultValue): Enumerable<any>;
|
||||
Distinct(compareSelector?: ($) => any): Enumerable<any>;
|
||||
Distinct(compareSelector?: string): Enumerable<any>;
|
||||
Except(second: any[], compareSelector?: ($) => any): Enumerable<any>;
|
||||
Except(second: any[], compareSelector?: string): Enumerable<any>;
|
||||
Except(second: Enumerable<any>, compareSelector?: ($) => any): Enumerable<any>;
|
||||
Except(second: Enumerable<any>, compareSelector?: string): Enumerable<any>;
|
||||
Intersect(second: any[], compareSelector?: ($) => any): Enumerable<any>;
|
||||
Intersect(second: any[], compareSelector?: string): Enumerable<any>;
|
||||
Intersect(second: Enumerable<any>, compareSelector?: ($) => any): Enumerable<any>;
|
||||
Intersect(second: Enumerable<any>, compareSelector?: string): Enumerable<any>;
|
||||
SequenceEqual(second: any[], compareSelector?: ($) => any): boolean;
|
||||
SequenceEqual(second: any[], compareSelector?: string): boolean;
|
||||
SequenceEqual(second: Enumerable, compareSelector?: ($) => any): boolean;
|
||||
SequenceEqual(second: Enumerable, compareSelector?: string): boolean;
|
||||
Union(second: any[], compareSelector?: ($) => any): Enumerable;
|
||||
Union(second: any[], compareSelector?: string): Enumerable;
|
||||
Union(second: Enumerable, compareSelector?: ($) => any): Enumerable;
|
||||
Union(second: Enumerable, compareSelector?: string): Enumerable;
|
||||
SequenceEqual(second: Enumerable<any>, compareSelector?: ($) => any): boolean;
|
||||
SequenceEqual(second: Enumerable<any>, compareSelector?: string): boolean;
|
||||
Union(second: any[], compareSelector?: ($) => any): Enumerable<any>;
|
||||
Union(second: any[], compareSelector?: string): Enumerable<any>;
|
||||
Union(second: Enumerable<any>, compareSelector?: ($) => any): Enumerable<any>;
|
||||
Union(second: Enumerable<any>, compareSelector?: string): Enumerable<any>;
|
||||
//Ordering Methods
|
||||
OrderBy(keySelector?: ($) => any): OrderedEnumerable;
|
||||
OrderBy(keySelector?: string): OrderedEnumerable;
|
||||
OrderByDescending(keySelector?: ($) => any): OrderedEnumerable;
|
||||
OrderByDescending(keySelector?: string): OrderedEnumerable;
|
||||
Reverse(): Enumerable;
|
||||
Shuffle(): Enumerable;
|
||||
OrderBy(keySelector?: ($: T) => any): OrderedEnumerable<T>;
|
||||
OrderBy(keySelector?: string): OrderedEnumerable<T>;
|
||||
OrderByDescending(keySelector?: ($) => any): OrderedEnumerable<T>;
|
||||
OrderByDescending(keySelector?: string): OrderedEnumerable<T>;
|
||||
Reverse(): Enumerable<T>;
|
||||
Shuffle(): Enumerable<T>;
|
||||
//Grouping Methods
|
||||
GroupBy(keySelector: ($) => any, elementSelector?: ($) => any, resultSelector?: (key, e) => any, compareSelector?: ($) =>any): Enumerable;
|
||||
GroupBy(keySelector: string, elementSelector?: string, resultSelector?: string, compareSelector?: string): Enumerable;
|
||||
PartitionBy(keySelector: ($) => any, elementSelector?: ($) => any, resultSelector?: (key, e) => any, compareSelector?: ($) =>any): Enumerable;
|
||||
PartitionBy(keySelector: string, elementSelector?: string, resultSelector?: string, compareSelector?: string): Enumerable;
|
||||
BufferWithCount(count: number): Enumerable;
|
||||
GroupBy(keySelector: ($) => any, elementSelector?: ($) => any, resultSelector?: (key, e) => any, compareSelector?: ($) =>any): Enumerable<any>;
|
||||
GroupBy(keySelector: string, elementSelector?: string, resultSelector?: string, compareSelector?: string): Enumerable<any>;
|
||||
PartitionBy(keySelector: ($) => any, elementSelector?: ($) => any, resultSelector?: (key, e) => any, compareSelector?: ($) =>any): Enumerable<any>;
|
||||
PartitionBy(keySelector: string, elementSelector?: string, resultSelector?: string, compareSelector?: string): Enumerable<any>;
|
||||
BufferWithCount(count: number): Enumerable<any>;
|
||||
// Aggregate Methods
|
||||
Aggregate(func: (a, b) => any);
|
||||
Aggregate(seed, func: (a, b) => any, resultSelector?: ($) => any);
|
||||
@@ -118,96 +121,108 @@ declare module linq {
|
||||
Average(selector?: string): number;
|
||||
Count(predicate?: ($) => boolean): number;
|
||||
Count(predicate?: string): number;
|
||||
Max(selector?: ($) => number): number;
|
||||
Max(selector?: string): number;
|
||||
Min(selector?: ($) => number): number;
|
||||
Min(selector?: string): number;
|
||||
MaxBy(selector: ($) => number): any;
|
||||
Max(selector?: ($: T) => any): any;
|
||||
Max(selector?: ($: T) => Date): Date;
|
||||
Max(selector?: ($: T) => number): number;
|
||||
Max(selector: ($: T) => string): string;
|
||||
Max(selector?: string): any;
|
||||
Min(selector?: ($: T) => any): any;
|
||||
Min(selector?: ($: T) => Date): Date;
|
||||
Min(selector: ($: T) => string): string;
|
||||
Min(selector?: ($: T) => number): number;
|
||||
Min(selector?: string): any;
|
||||
MaxBy(selector: ($: T) => any): any;
|
||||
MaxBy(selector: ($: T) => string): string;
|
||||
MaxBy(selector: ($: T) => Date): Date;
|
||||
MaxBy(selector: ($: T) => number): number;
|
||||
MaxBy(selector: string): any;
|
||||
MinBy(selector: ($) => number): any;
|
||||
MinBy(selector: ($: T) => Date): Date;
|
||||
MinBy(selector: ($: T) => number): any;
|
||||
MinBy(selector: ($: T) => string): string;
|
||||
MinBy(selector: ($: T) => any): any;
|
||||
MinBy(selector: string): any;
|
||||
Sum(selector?: ($) => number): number;
|
||||
Sum(selector?: string): number;
|
||||
//Paging Methods
|
||||
ElementAt(index: number): any;
|
||||
ElementAtOrDefault(index: number, defaultValue): any;
|
||||
First(predicate?: ($) => boolean): any;
|
||||
First(predicate?: string): any;
|
||||
FirstOrDefault(defaultValue, predicate?: ($) => boolean): any;
|
||||
FirstOrDefault(defaultValue, predicate?: string): any;
|
||||
Last(predicate?: ($) => boolean): any;
|
||||
Last(predicate?: string): any;
|
||||
LastOrDefault(defaultValue, predicate?: ($) => boolean): any;
|
||||
LastOrDefault(defaultValue, predicate?: string): any;
|
||||
Single(predicate?: ($) => boolean): any;
|
||||
Single(predicate?: string): any;
|
||||
SingleOrDefault(defaultValue, predicate?: ($) => boolean): any;
|
||||
SingleOrDefault(defaultValue, predicate?: string): any;
|
||||
Skip(count: number): Enumerable;
|
||||
SkipWhile(predicate: ($, i: number) => boolean): Enumerable;
|
||||
SkipWhile(predicate: string): Enumerable;
|
||||
Take(count: number): Enumerable;
|
||||
TakeWhile(predicate: ($, i: number) => boolean): Enumerable;
|
||||
TakeWhile(predicate: string): Enumerable;
|
||||
TakeExceptLast(count?: number): Enumerable;
|
||||
TakeFromLast(count: number): Enumerable;
|
||||
ElementAt(index: number): T;
|
||||
ElementAtOrDefault(index: number, defaultValue: T): T;
|
||||
First(predicate?: ($: T) => boolean): T;
|
||||
First(predicate?: string): T;
|
||||
FirstOrDefault(defaultValue: T, predicate?: ($: T) => boolean): T;
|
||||
FirstOrDefault(defaultValue: T, predicate?: string): T;
|
||||
Last(predicate?: ($: T) => boolean): T;
|
||||
Last(predicate?: string): T;
|
||||
LastOrDefault(defaultValue: T, predicate?: ($: T) => boolean): T;
|
||||
LastOrDefault(defaultValue: T, predicate?: string): T;
|
||||
Single(predicate?: ($: T) => boolean): T;
|
||||
Single(predicate?: string): T;
|
||||
SingleOrDefault(defaultValue: T, predicate?: ($: T) => boolean): T;
|
||||
SingleOrDefault(defaultValue: T, predicate?: string): T;
|
||||
Skip(count: number): Enumerable<T>;
|
||||
SkipWhile(predicate: ($: T, i: number) => boolean): Enumerable<T>;
|
||||
SkipWhile(predicate: string): Enumerable<T>;
|
||||
Take(count: number): Enumerable<T>;
|
||||
TakeWhile(predicate: ($: T, i: number) => boolean): Enumerable<T>;
|
||||
TakeWhile(predicate: string): Enumerable<T>;
|
||||
TakeExceptLast(count?: number): Enumerable<T>;
|
||||
TakeFromLast(count: number): Enumerable<T>;
|
||||
IndexOf(item): number;
|
||||
LastIndexOf(item): number;
|
||||
// Convert Methods
|
||||
ToArray(): any[];
|
||||
ToLookup(keySelector: ($) => any, elementSelector?: ($) => any, compareSelector?: (key) => any): Lookup;
|
||||
ToLookup(keySelector: string, elementSelector?: string, compareSelector?: string): Lookup;
|
||||
ToArray(): T[];
|
||||
ToLookup(keySelector: ($) => any, elementSelector?: ($) => any, compareSelector?: (key) => any): Lookup<T>;
|
||||
ToLookup(keySelector: string, elementSelector?: string, compareSelector?: string): Lookup<T>;
|
||||
ToObject(keySelector: ($) => string, elementSelector: ($) => any): any;
|
||||
ToObject(keySelector: string, elementSelector: string): any;
|
||||
ToDictionary(keySelector: ($) => any, elementSelector: ($) => any, compareSelector?: (key) => any): Dictionary;
|
||||
ToDictionary(keySelector: string, elementSelector: string, compareSelector?: string): Dictionary;
|
||||
ToDictionary(keySelector: ($) => any, elementSelector: ($) => any, compareSelector?: (key) => any): Dictionary<T>;
|
||||
ToDictionary(keySelector: string, elementSelector: string, compareSelector?: string): Dictionary<T>;
|
||||
ToJSON(replacer?: (key, value) => any, space?: number): string;
|
||||
ToJSON(replacer?: string, space?: number): string;
|
||||
ToString(separator?: string, selector?: ($) =>any): string;
|
||||
ToString(separator?: string, selector?: string): string;
|
||||
//Action Methods
|
||||
Do(action: ($, i: number) => void ): Enumerable;
|
||||
Do(action: string): Enumerable;
|
||||
ForEach(action: ($, i: number) => void ): void;
|
||||
ForEach(func: ($, i: number) => boolean): void;
|
||||
Do(action: ($, i: number) => void ): Enumerable<any>;
|
||||
Do(action: string): Enumerable<any>;
|
||||
ForEach(action: ($: T, i: number) => void ): void;
|
||||
ForEach(func: ($: T, i: number) => boolean): void;
|
||||
ForEach(action_func: string): void;
|
||||
Write(separator?: string, selector?: ($) =>any): void;
|
||||
Write(separator?: string, selector?: string): void;
|
||||
WriteLine(selector?: ($) =>any): void;
|
||||
Force(): void;
|
||||
//Functional Methods
|
||||
Let(func: (e: Enumerable) => Enumerable): Enumerable;
|
||||
Share(): Enumerable;
|
||||
MemoizeAll(): Enumerable;
|
||||
Let(func: (e: Enumerable<any>) => Enumerable<any>): Enumerable<any>;
|
||||
Share(): Enumerable<any>;
|
||||
MemoizeAll(): Enumerable<any>;
|
||||
//Error Handling Methods
|
||||
Catch(handler: (error: Error) => void ): Enumerable;
|
||||
Catch(handler: string): Enumerable;
|
||||
Finally(finallyAction: () => void ): Enumerable;
|
||||
Finally(finallyAction: string): Enumerable;
|
||||
Catch(handler: (error: Error) => void ): Enumerable<any>;
|
||||
Catch(handler: string): Enumerable<any>;
|
||||
Finally(finallyAction: () => void ): Enumerable<any>;
|
||||
Finally(finallyAction: string): Enumerable<any>;
|
||||
//For Debug Methods
|
||||
Trace(message?: string, selector?: ($) =>any): Enumerable;
|
||||
Trace(message?: string, selector?: string): Enumerable;
|
||||
Trace(message?: string, selector?: ($) =>any): Enumerable<any>;
|
||||
Trace(message?: string, selector?: string): Enumerable<any>;
|
||||
}
|
||||
|
||||
interface OrderedEnumerable extends Enumerable {
|
||||
ThenBy(keySelector: ($) => any): OrderedEnumerable;
|
||||
ThenBy(keySelector: string): OrderedEnumerable;
|
||||
ThenByDescending(keySelector: ($) => any): OrderedEnumerable;
|
||||
ThenByDescending(keySelector: string): OrderedEnumerable;
|
||||
interface OrderedEnumerable<T> extends Enumerable<T> {
|
||||
ThenBy(keySelector: ($) => T): OrderedEnumerable<T>;
|
||||
ThenBy(keySelector: string): OrderedEnumerable<T>;
|
||||
ThenByDescending(keySelector: ($) => T): OrderedEnumerable<T>;
|
||||
ThenByDescending(keySelector: T): OrderedEnumerable<T>;
|
||||
}
|
||||
|
||||
interface Grouping extends Enumerable {
|
||||
interface Grouping<T> extends Enumerable<T> {
|
||||
Key();
|
||||
}
|
||||
|
||||
interface Lookup {
|
||||
interface Lookup<TValue> {
|
||||
Count(): number;
|
||||
Get(key): Enumerable;
|
||||
Get(key): Enumerable<TValue>;
|
||||
Contains(key): boolean;
|
||||
ToEnumerable(): Enumerable;
|
||||
ToEnumerable(): Enumerable<TValue>;
|
||||
}
|
||||
|
||||
interface Dictionary {
|
||||
interface Dictionary<TValue> {
|
||||
Add(key, value): void;
|
||||
Get(key): any;
|
||||
Set(key, value): boolean;
|
||||
@@ -215,7 +230,12 @@ declare module linq {
|
||||
Clear(): void;
|
||||
Remove(key): void;
|
||||
Count(): number;
|
||||
ToEnumerable(): Enumerable;
|
||||
ToEnumerable(): Enumerable<TValue>;
|
||||
}
|
||||
|
||||
interface KeyValuePair<TKey, TValue> {
|
||||
Key: TKey;
|
||||
Value: TValue;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user