mirror of
https://github.com/gosticks/DefinitelyTyped.git
synced 2026-08-11 20:40:20 +00:00
Merge pull request #1798 from Bartvds/def/lazy.js
Converted lazy.js to generics
This commit is contained in:
Bart van der Schoor
+129
-104
@@ -1,9 +1,33 @@
|
||||
/// <reference path="lazy.js.d.ts" />
|
||||
|
||||
var sequence: LazyJS.Sequence;
|
||||
var arraySeq: LazyJS.ArrayLikeSequence;
|
||||
var objectSeq: LazyJS.ObjectLikeSequence;
|
||||
var asyncSeq: LazyJS.AsyncSequence;
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
|
||||
interface Foo {
|
||||
foo(): string;
|
||||
}
|
||||
interface Bar {
|
||||
bar(): string;
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
|
||||
var foo: Foo;
|
||||
var bar: Bar;
|
||||
|
||||
var fooArr: Foo[];
|
||||
var barArr: Bar[];
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
|
||||
var fooSequence: LazyJS.Sequence<Foo>;
|
||||
var barSequence: LazyJS.Sequence<Bar>;
|
||||
var fooArraySeq: LazyJS.ArrayLikeSequence<Foo>;
|
||||
var barArraySeq: LazyJS.ArrayLikeSequence<Bar>;
|
||||
var fooObjectSeq: LazyJS.ObjectLikeSequence<Foo>;
|
||||
var anyObjectSeq: LazyJS.ObjectLikeSequence<any>;
|
||||
var fooAsyncSeq: LazyJS.AsyncSequence<Foo>;
|
||||
|
||||
var strSequence: LazyJS.Sequence<string>;
|
||||
var stringSeq: LazyJS.StringLikeSequence;
|
||||
|
||||
var obj: Object;
|
||||
@@ -23,141 +47,142 @@ function fnErrorCallback(error: any): void {
|
||||
|
||||
}
|
||||
|
||||
function fnValueCallback(value: any): void {
|
||||
function fnValueCallback(value: Foo): void {
|
||||
}
|
||||
|
||||
function fnGetKeyCallback(value: any): string {
|
||||
return '';
|
||||
function fnGetKeyCallback(value: Foo): string {
|
||||
return str;
|
||||
}
|
||||
|
||||
function fnTestCallback(value: any): boolean {
|
||||
return false;
|
||||
function fnTestCallback(value: Foo): boolean {
|
||||
return bool;
|
||||
}
|
||||
|
||||
function fnMapCallback(value: any): any {
|
||||
return null;
|
||||
function fnMapCallback(value: Foo): Bar {
|
||||
return bar;
|
||||
}
|
||||
|
||||
function fnMapStringCallback(value: string): string {
|
||||
return '';
|
||||
return str;
|
||||
}
|
||||
|
||||
function fnNumberCallback(value: any): number {
|
||||
return 0;
|
||||
function fnNumberCallback(value: Foo): number {
|
||||
return num;
|
||||
}
|
||||
|
||||
function fnMemoCallback(memo: any, value: any): any {
|
||||
return null;
|
||||
function fnMemoCallback(memo: Bar, value: Foo): Bar {
|
||||
return bar;
|
||||
}
|
||||
|
||||
function fnGeneratorCallback(index: number): any {
|
||||
return null;
|
||||
function fnGeneratorCallback(index: number): Foo {
|
||||
return foo;
|
||||
}
|
||||
|
||||
// Lazy
|
||||
|
||||
arraySeq = Lazy([]);
|
||||
objectSeq = Lazy({});
|
||||
stringSeq = Lazy('');
|
||||
fooArraySeq = Lazy(fooArr);
|
||||
fooObjectSeq = Lazy<Foo>({a:foo, b:foo});
|
||||
anyObjectSeq = Lazy<any>({a:num, b:str});
|
||||
stringSeq = Lazy(str);
|
||||
|
||||
// Strict
|
||||
|
||||
var Strict = Lazy.strict();
|
||||
arraySeq = Strict([1, 2, num]).pop();
|
||||
fooArraySeq = Strict([foo, foo]).pop();
|
||||
|
||||
// Sequence
|
||||
|
||||
asyncSeq = sequence.async(num);
|
||||
sequence = sequence.chunk(num);
|
||||
sequence = sequence.compact();
|
||||
sequence = sequence.concat(arr);
|
||||
sequence = sequence.consecutive(num);
|
||||
bool = sequence.contains(x);
|
||||
sequence = sequence.countBy(str);
|
||||
sequence = sequence.countBy(fnGetKeyCallback);
|
||||
sequence = sequence.dropWhile(fnTestCallback);
|
||||
sequence = sequence.each(fnValueCallback);
|
||||
bool = sequence.every(fnTestCallback);
|
||||
sequence = sequence.filter(fnTestCallback);
|
||||
sequence = sequence.find(fnTestCallback);
|
||||
sequence = sequence.findWhere(obj);
|
||||
fooAsyncSeq = fooSequence.async(num);
|
||||
fooSequence = fooSequence.chunk(num);
|
||||
fooSequence = fooSequence.compact();
|
||||
fooSequence = fooSequence.concat(arr);
|
||||
fooSequence = fooSequence.consecutive(num);
|
||||
bool = fooSequence.contains(foo);
|
||||
fooSequence = fooSequence.countBy(str);
|
||||
fooObjectSeq = fooSequence.countBy(fnGetKeyCallback);
|
||||
fooSequence = fooSequence.dropWhile(fnTestCallback);
|
||||
fooSequence = fooSequence.each(fnValueCallback);
|
||||
bool = fooSequence.every(fnTestCallback);
|
||||
fooSequence = fooSequence.filter(fnTestCallback);
|
||||
fooSequence = fooSequence.find(fnTestCallback);
|
||||
fooSequence = fooSequence.findWhere(obj);
|
||||
|
||||
x = sequence.first();
|
||||
sequence = sequence.first(num);
|
||||
x = fooSequence.first();
|
||||
fooSequence = fooSequence.first(num);
|
||||
|
||||
sequence = sequence.flatten();
|
||||
objectSeq = sequence.groupBy(fnGetKeyCallback);
|
||||
sequence = sequence.indexOf(x);
|
||||
sequence = sequence.initial();
|
||||
sequence = sequence.initial(num);
|
||||
sequence = sequence.intersection(arr);
|
||||
sequence = sequence.invoke(str);
|
||||
bool = sequence.isEmpty();
|
||||
str = sequence.join();
|
||||
str = sequence.join(str);
|
||||
fooSequence = fooSequence.flatten();
|
||||
fooObjectSeq = fooSequence.groupBy(fnGetKeyCallback);
|
||||
fooSequence = fooSequence.indexOf(x);
|
||||
fooSequence = fooSequence.initial();
|
||||
fooSequence = fooSequence.initial(num);
|
||||
fooSequence = fooSequence.intersection(arr);
|
||||
fooSequence = fooSequence.invoke(str);
|
||||
bool = fooSequence.isEmpty();
|
||||
str = fooSequence.join();
|
||||
str = fooSequence.join(str);
|
||||
|
||||
x = sequence.last();
|
||||
sequence = sequence.last(num);
|
||||
foo = fooSequence.last();
|
||||
fooSequence = fooSequence.last(num);
|
||||
|
||||
sequence = sequence.lastIndexOf(x);
|
||||
sequence = sequence.map(fnMapCallback);
|
||||
x = sequence.max();
|
||||
x = sequence.max(fnNumberCallback);
|
||||
x = sequence.min();
|
||||
x = sequence.min(fnNumberCallback);
|
||||
sequence = sequence.pluck(str);
|
||||
x = sequence.reduce(fnMemoCallback);
|
||||
x = sequence.reduce(fnMemoCallback, x);
|
||||
x = sequence.reduceRight(fnMemoCallback, x);
|
||||
sequence = sequence.reject(fnTestCallback);
|
||||
sequence = sequence.rest(num);
|
||||
sequence = sequence.reverse();
|
||||
sequence = sequence.shuffle();
|
||||
bool = sequence.some();
|
||||
bool = sequence.some(fnTestCallback);
|
||||
sequence = sequence.sortBy(fnNumberCallback);
|
||||
sequence = sequence.sortedIndex(x);
|
||||
sequence = sequence.sum();
|
||||
sequence = sequence.sum(fnNumberCallback);
|
||||
sequence = sequence.takeWhile(fnTestCallback);
|
||||
sequence = sequence.union(arr);
|
||||
sequence = sequence.uniq();
|
||||
sequence = sequence.where(obj);
|
||||
sequence = sequence.without(arr);
|
||||
sequence = sequence.zip(arr);
|
||||
fooSequence = fooSequence.lastIndexOf(foo);
|
||||
barSequence = fooSequence.map(fnMapCallback);
|
||||
foo = fooSequence.max();
|
||||
foo = fooSequence.max(fnNumberCallback);
|
||||
foo = fooSequence.min();
|
||||
foo = fooSequence.min(fnNumberCallback);
|
||||
fooSequence = fooSequence.pluck(str);
|
||||
bar = fooSequence.reduce(fnMemoCallback);
|
||||
bar = fooSequence.reduce(fnMemoCallback, bar);
|
||||
bar = fooSequence.reduceRight(fnMemoCallback, bar);
|
||||
fooSequence = fooSequence.reject(fnTestCallback);
|
||||
fooSequence = fooSequence.rest(num);
|
||||
fooSequence = fooSequence.reverse();
|
||||
fooSequence = fooSequence.shuffle();
|
||||
bool = fooSequence.some();
|
||||
bool = fooSequence.some(fnTestCallback);
|
||||
fooSequence = fooSequence.sortBy(fnNumberCallback);
|
||||
fooSequence = fooSequence.sortedIndex(foo);
|
||||
fooSequence = fooSequence.sum();
|
||||
fooSequence = fooSequence.sum(fnNumberCallback);
|
||||
fooSequence = fooSequence.takeWhile(fnTestCallback);
|
||||
fooSequence = fooSequence.union(fooArr);
|
||||
fooSequence = fooSequence.uniq();
|
||||
fooSequence = fooSequence.where(obj);
|
||||
fooSequence = fooSequence.without(fooArr);
|
||||
fooSequence = fooSequence.zip(arr);
|
||||
|
||||
arr = sequence.toArray();
|
||||
obj = sequence.toObject();
|
||||
fooArr = fooSequence.toArray();
|
||||
obj = fooSequence.toObject();
|
||||
|
||||
// ArrayLikeSequence
|
||||
|
||||
arraySeq = arraySeq.concat();
|
||||
arraySeq = arraySeq.first();
|
||||
arraySeq = arraySeq.first(num);
|
||||
x = arraySeq.get(num);
|
||||
num = arraySeq.length();
|
||||
arraySeq = arraySeq.map(fnMapCallback);
|
||||
arraySeq = arraySeq.pop();
|
||||
arraySeq = arraySeq.rest();
|
||||
arraySeq = arraySeq.rest(num);
|
||||
arraySeq = arraySeq.reverse();
|
||||
arraySeq = arraySeq.shift();
|
||||
arraySeq = arraySeq.slice(num);
|
||||
arraySeq = arraySeq.slice(num, num);
|
||||
fooArraySeq = fooArraySeq.concat();
|
||||
fooArraySeq = fooArraySeq.first();
|
||||
fooArraySeq = fooArraySeq.first(num);
|
||||
foo = fooArraySeq.get(num);
|
||||
num = fooArraySeq.length();
|
||||
barArraySeq = fooArraySeq.map(fnMapCallback);
|
||||
fooArraySeq = fooArraySeq.pop();
|
||||
fooArraySeq = fooArraySeq.rest();
|
||||
fooArraySeq = fooArraySeq.rest(num);
|
||||
fooArraySeq = fooArraySeq.reverse();
|
||||
fooArraySeq = fooArraySeq.shift();
|
||||
fooArraySeq = fooArraySeq.slice(num);
|
||||
fooArraySeq = fooArraySeq.slice(num, num);
|
||||
|
||||
// ObjectLikeSequence
|
||||
|
||||
objectSeq = objectSeq.defaults(obj);
|
||||
sequence = objectSeq.functions();
|
||||
objectSeq = objectSeq.get(str);
|
||||
objectSeq = objectSeq.invert();
|
||||
sequence = objectSeq.keys();
|
||||
objectSeq = objectSeq.omit(strArr);
|
||||
sequence = objectSeq.pairs();
|
||||
objectSeq = objectSeq.pick(strArr);
|
||||
arr = objectSeq.toArray();
|
||||
obj = objectSeq.toObject();
|
||||
sequence = objectSeq.values();
|
||||
fooObjectSeq = fooObjectSeq.defaults(obj);
|
||||
fooSequence = fooObjectSeq.functions();
|
||||
fooObjectSeq = fooObjectSeq.get(str);
|
||||
fooObjectSeq = fooObjectSeq.invert();
|
||||
strSequence = fooObjectSeq.keys();
|
||||
fooObjectSeq = fooObjectSeq.omit(strArr);
|
||||
fooSequence = fooObjectSeq.pairs();
|
||||
fooObjectSeq = fooObjectSeq.pick(strArr);
|
||||
arr = fooObjectSeq.toArray();
|
||||
obj = fooObjectSeq.toObject();
|
||||
fooSequence = fooObjectSeq.values();
|
||||
|
||||
// StringLikeSequence
|
||||
|
||||
@@ -181,8 +206,8 @@ stringSeq = stringSeq.mapString(fnMapStringCallback);
|
||||
stringSeq = stringSeq.match(exp);
|
||||
stringSeq = stringSeq.reverse();
|
||||
|
||||
sequence = stringSeq.split(str);
|
||||
sequence = stringSeq.split(exp);
|
||||
stringSeq = stringSeq.split(str);
|
||||
stringSeq = stringSeq.split(exp);
|
||||
|
||||
bool = stringSeq.startsWith(str);
|
||||
stringSeq = stringSeq.substring(num);
|
||||
|
||||
Vendored
+142
-138
@@ -6,28 +6,31 @@
|
||||
declare module LazyJS {
|
||||
|
||||
interface LazyStatic {
|
||||
(value:string):StringLikeSequence;
|
||||
(value:any[]):ArrayLikeSequence;
|
||||
(value:Object):ObjectLikeSequence;
|
||||
(value:ArrayLike):ArrayLikeSequence;
|
||||
|
||||
(value: string):StringLikeSequence;
|
||||
<T>(value: T[]):ArrayLikeSequence<T>;
|
||||
(value: any[]):ArrayLikeSequence<any>;
|
||||
<T>(value: Object):ObjectLikeSequence<T>;
|
||||
(value: Object):ObjectLikeSequence<any>;
|
||||
|
||||
strict():LazyStatic;
|
||||
|
||||
generate(generatorFn:GeneratorCallback, length?:number):GeneratedSequence;
|
||||
generate<T>(generatorFn: GeneratorCallback<T>, length?: number):GeneratedSequence<T>;
|
||||
|
||||
range(to:number):GeneratedSequence;
|
||||
range(from:number, to:number, step?:number):GeneratedSequence;
|
||||
range(to: number):GeneratedSequence<number>;
|
||||
range(from: number, to: number, step?: number):GeneratedSequence<number>;
|
||||
|
||||
repeat(value:any, count?:number):GeneratedSequence;
|
||||
repeat<T>(value: T, count?: number):GeneratedSequence<T>;
|
||||
|
||||
on(eventType:string):Sequence;
|
||||
on<T>(eventType: string):Sequence<T>;
|
||||
|
||||
readFile(path:string):StringLikeSequence;
|
||||
makeHttpRequest(path:string):StringLikeSequence;
|
||||
readFile(path: string):StringLikeSequence;
|
||||
makeHttpRequest(path: string):StringLikeSequence;
|
||||
}
|
||||
|
||||
interface ArrayLike {
|
||||
interface ArrayLike<T> {
|
||||
length:number;
|
||||
[index:number]:T;
|
||||
}
|
||||
|
||||
interface Callback {
|
||||
@@ -35,212 +38,213 @@ declare module LazyJS {
|
||||
}
|
||||
|
||||
interface ErrorCallback {
|
||||
(error:any):void;
|
||||
(error: any):void;
|
||||
}
|
||||
|
||||
interface ValueCallback {
|
||||
(value:any):void;
|
||||
interface ValueCallback<T> {
|
||||
(value: T):void;
|
||||
}
|
||||
|
||||
interface GetKeyCallback {
|
||||
(value:any):string;
|
||||
interface GetKeyCallback<T> {
|
||||
(value: T):string;
|
||||
}
|
||||
|
||||
interface TestCallback {
|
||||
(value:any):boolean;
|
||||
interface TestCallback<T> {
|
||||
(value: T):boolean;
|
||||
}
|
||||
|
||||
interface MapCallback {
|
||||
(value:any):any;
|
||||
interface MapCallback<T, U> {
|
||||
(value: T):U;
|
||||
}
|
||||
|
||||
interface MapStringCallback {
|
||||
(value:string):string;
|
||||
(value: string):string;
|
||||
}
|
||||
|
||||
interface NumberCallback {
|
||||
(value:any):number;
|
||||
interface NumberCallback<T> {
|
||||
(value: T):number;
|
||||
}
|
||||
|
||||
interface MemoCallback {
|
||||
(memo:any, value:any):any;
|
||||
interface MemoCallback<T, U> {
|
||||
(memo: U, value: T):U;
|
||||
}
|
||||
|
||||
interface GeneratorCallback {
|
||||
(index:number):any;
|
||||
interface GeneratorCallback<T> {
|
||||
(index: number):T;
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
|
||||
interface Iterator {
|
||||
new(sequence:Sequence):Iterator;
|
||||
current():any;
|
||||
interface Iterator<T> {
|
||||
new (sequence: Sequence<T>):Iterator<T>;
|
||||
current():T;
|
||||
moveNext():boolean;
|
||||
}
|
||||
|
||||
interface GeneratedSequence extends Sequence {
|
||||
new(generatorFn:GeneratorCallback, length:number):GeneratedSequence;
|
||||
interface GeneratedSequence<T> extends Sequence<T> {
|
||||
new(generatorFn: GeneratorCallback<T>, length: number):GeneratedSequence<T>;
|
||||
length():number;
|
||||
}
|
||||
|
||||
interface AsyncSequence extends SequenceBase {
|
||||
each(callback:ValueCallback):AsyncHandle;
|
||||
interface AsyncSequence<T> extends SequenceBase<T> {
|
||||
each(callback: ValueCallback<T>):AsyncHandle<T>;
|
||||
}
|
||||
|
||||
interface AsyncHandle {
|
||||
interface AsyncHandle<T> {
|
||||
cancel():void;
|
||||
onComplete(callback:Callback):void;
|
||||
onError(callback:ErrorCallback):void;
|
||||
onComplete(callback: Callback):void;
|
||||
onError(callback: ErrorCallback):void;
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
|
||||
module Sequence {
|
||||
function define(methodName:string[], overrides:Object):Function;
|
||||
function define(methodName: string[], overrides: Object): Function;
|
||||
}
|
||||
|
||||
interface Sequence extends SequenceBase {
|
||||
each(eachFn:ValueCallback):Sequence;
|
||||
interface Sequence<T> extends SequenceBase<T> {
|
||||
each(eachFn: ValueCallback<T>):Sequence<T>;
|
||||
}
|
||||
|
||||
interface SequenceBase extends SequenceBaser {
|
||||
interface SequenceBase<T> extends SequenceBaser<T> {
|
||||
first():any;
|
||||
first(count:number):Sequence;
|
||||
indexOf(value:any, startIndex?:number):Sequence;
|
||||
first(count: number):Sequence<T>;
|
||||
indexOf(value: any, startIndex?: number):Sequence<T>;
|
||||
|
||||
last():any;
|
||||
last(count:number):Sequence;
|
||||
lastIndexOf(value:any):Sequence;
|
||||
last(count: number):Sequence<T>;
|
||||
lastIndexOf(value: any):Sequence<T>;
|
||||
|
||||
reverse():Sequence;
|
||||
reverse():Sequence<T>;
|
||||
}
|
||||
|
||||
interface SequenceBaser {
|
||||
interface SequenceBaser<T> {
|
||||
// TODO improve define() (needs ugly overload)
|
||||
async(interval:number):AsyncSequence;
|
||||
chunk(size:number):Sequence;
|
||||
compact():Sequence;
|
||||
concat(var_args:any[]):Sequence;
|
||||
consecutive(length:number):Sequence;
|
||||
contains(value:any):boolean;
|
||||
countBy(propertyName:string):Sequence;
|
||||
countBy(keyFn:GetKeyCallback):Sequence;
|
||||
dropWhile(predicateFn:TestCallback):Sequence;
|
||||
every(predicateFn:TestCallback):boolean;
|
||||
filter(predicateFn:TestCallback):Sequence;
|
||||
find(predicateFn:TestCallback):Sequence;
|
||||
findWhere(properties:Object):Sequence;
|
||||
async(interval: number):AsyncSequence<T>;
|
||||
chunk(size: number):Sequence<T>;
|
||||
compact():Sequence<T>;
|
||||
concat(var_args: T[]):Sequence<T>;
|
||||
consecutive(length: number):Sequence<T>;
|
||||
contains(value: T):boolean;
|
||||
countBy(keyFn: GetKeyCallback<T>): ObjectLikeSequence<T>;
|
||||
countBy(propertyName: string): ObjectLikeSequence<T>;
|
||||
dropWhile(predicateFn: TestCallback<T>): Sequence<T>;
|
||||
every(predicateFn: TestCallback<T>): boolean;
|
||||
filter(predicateFn: TestCallback<T>): Sequence<T>;
|
||||
find(predicateFn: TestCallback<T>): Sequence<T>;
|
||||
findWhere(properties: Object): Sequence<T>;
|
||||
|
||||
flatten():Sequence;
|
||||
groupBy(keyFn:GetKeyCallback):ObjectLikeSequence;
|
||||
initial(count?:number):Sequence;
|
||||
intersection(var_args:any[]):Sequence;
|
||||
invoke(methodName:string):Sequence;
|
||||
isEmpty():boolean;
|
||||
join(delimiter?:string):string;
|
||||
map(mapFn:MapCallback):Sequence;
|
||||
max(valueFn?:NumberCallback):any;
|
||||
min(valueFn?:NumberCallback):any;
|
||||
pluck(propertyName:string):Sequence;
|
||||
reduce(aggregatorFn:MemoCallback, memo?:any):any;
|
||||
reduceRight(aggregatorFn:MemoCallback, memo:any):any;
|
||||
reject(predicateFn:TestCallback):Sequence;
|
||||
rest(count?:number):Sequence;
|
||||
shuffle():Sequence;
|
||||
some(predicateFn?:TestCallback):boolean;
|
||||
sortBy(sortFn:NumberCallback):Sequence;
|
||||
sortedIndex(value:any):Sequence;
|
||||
sum(valueFn?:NumberCallback):Sequence;
|
||||
takeWhile(predicateFn:TestCallback):Sequence;
|
||||
union(var_args:any[]):Sequence;
|
||||
uniq():Sequence;
|
||||
where(properties:Object):Sequence;
|
||||
without(var_args:any[]):Sequence;
|
||||
zip(var_args:any[]):Sequence;
|
||||
flatten(): Sequence<T>;
|
||||
groupBy(keyFn: GetKeyCallback<T>): ObjectLikeSequence<T>;
|
||||
initial(count?: number): Sequence<T>;
|
||||
intersection(var_args: T[]): Sequence<T>;
|
||||
invoke(methodName: string): Sequence<T>;
|
||||
isEmpty(): boolean;
|
||||
join(delimiter?: string): string;
|
||||
map<U>(mapFn: MapCallback<T, U>): Sequence<U>;
|
||||
|
||||
toArray():any[];
|
||||
toObject():Object;
|
||||
max(valueFn?: NumberCallback<T>): T;
|
||||
min(valueFn?: NumberCallback<T>): T;
|
||||
pluck(propertyName: string): Sequence<T>;
|
||||
reduce<U>(aggregatorFn: MemoCallback<T, U>, memo?: U): U;
|
||||
reduceRight<U>(aggregatorFn: MemoCallback<T, U>, memo: U): U;
|
||||
reject(predicateFn: TestCallback<T>): Sequence<T>;
|
||||
rest(count?: number): Sequence<T>;
|
||||
shuffle(): Sequence<T>;
|
||||
some(predicateFn?: TestCallback<T>): boolean;
|
||||
sortBy(sortFn: NumberCallback<T>): Sequence<T>;
|
||||
sortedIndex(value: T): Sequence<T>;
|
||||
sum(valueFn?: NumberCallback<T>): Sequence<T>;
|
||||
takeWhile(predicateFn: TestCallback<T>): Sequence<T>;
|
||||
union(var_args: T[]): Sequence<T>;
|
||||
uniq(): Sequence<T>;
|
||||
where(properties: Object): Sequence<T>;
|
||||
without(var_args: T[]): Sequence<T>;
|
||||
zip(var_args: T[]): Sequence<T>;
|
||||
|
||||
toArray(): T[];
|
||||
toObject(): Object;
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
|
||||
module ArrayLikeSequence {
|
||||
function define(methodName:string[], overrides:Object):Function;
|
||||
function define(methodName: string[], overrides: Object): Function;
|
||||
}
|
||||
|
||||
interface ArrayLikeSequence extends Sequence {
|
||||
interface ArrayLikeSequence<T> extends Sequence<T> {
|
||||
// define()X;
|
||||
concat():ArrayLikeSequence;
|
||||
first(count?:number):ArrayLikeSequence;
|
||||
get(index:number):any;
|
||||
length():number;
|
||||
map(mapFn:MapCallback):ArrayLikeSequence;
|
||||
pop():ArrayLikeSequence;
|
||||
rest(count?:number):ArrayLikeSequence;
|
||||
reverse():ArrayLikeSequence;
|
||||
shift():ArrayLikeSequence;
|
||||
slice(begin:number, end?:number):ArrayLikeSequence;
|
||||
concat(): ArrayLikeSequence<T>;
|
||||
first(count?: number): ArrayLikeSequence<T>;
|
||||
get(index: number): T;
|
||||
length(): number;
|
||||
map<U>(mapFn: MapCallback<T, U>): ArrayLikeSequence<U>;
|
||||
pop(): ArrayLikeSequence<T>;
|
||||
rest(count?: number): ArrayLikeSequence<T>;
|
||||
reverse(): ArrayLikeSequence<T>;
|
||||
shift(): ArrayLikeSequence<T>;
|
||||
slice(begin: number, end?: number): ArrayLikeSequence<T>;
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
|
||||
module ObjectLikeSequence {
|
||||
function define(methodName:string[], overrides:Object):Function;
|
||||
function define(methodName: string[], overrides: Object): Function;
|
||||
}
|
||||
|
||||
interface ObjectLikeSequence extends Sequence {
|
||||
assign(other:Object):ObjectLikeSequence;
|
||||
interface ObjectLikeSequence<T> extends Sequence<T> {
|
||||
assign(other: Object): ObjectLikeSequence<T>;
|
||||
// throws error
|
||||
//async():X;
|
||||
defaults(defaults:Object):ObjectLikeSequence;
|
||||
functions():Sequence;
|
||||
get(property:string):ObjectLikeSequence;
|
||||
invert():ObjectLikeSequence;
|
||||
keys():Sequence;
|
||||
omit(properties:string[]):ObjectLikeSequence;
|
||||
pairs():Sequence;
|
||||
pick(properties:string[]):ObjectLikeSequence;
|
||||
toArray():any[];
|
||||
toObject():Object;
|
||||
values():Sequence;
|
||||
//async(): X;
|
||||
defaults(defaults: Object): ObjectLikeSequence<T>;
|
||||
functions(): Sequence<T>;
|
||||
get(property: string): ObjectLikeSequence<T>;
|
||||
invert(): ObjectLikeSequence<T>;
|
||||
keys(): Sequence<string>;
|
||||
omit(properties: string[]): ObjectLikeSequence<T>;
|
||||
pairs(): Sequence<T>;
|
||||
pick(properties: string[]): ObjectLikeSequence<T>;
|
||||
toArray(): T[];
|
||||
toObject(): Object;
|
||||
values(): Sequence<T>;
|
||||
}
|
||||
|
||||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||||
|
||||
module StringLikeSequence {
|
||||
function define(methodName:string[], overrides:Object):Function;
|
||||
function define(methodName: string[], overrides: Object): Function;
|
||||
}
|
||||
|
||||
interface StringLikeSequence extends SequenceBaser {
|
||||
charAt(index:number):string;
|
||||
charCodeAt(index:number):number;
|
||||
contains(value:string):boolean;
|
||||
endsWith(suffix:string):boolean;
|
||||
interface StringLikeSequence extends SequenceBaser<string> {
|
||||
charAt(index: number): string;
|
||||
charCodeAt(index: number): number;
|
||||
contains(value: string): boolean;
|
||||
endsWith(suffix: string): boolean;
|
||||
|
||||
first():string;
|
||||
first(count:number):StringLikeSequence;
|
||||
first(): string;
|
||||
first(count: number): StringLikeSequence;
|
||||
|
||||
indexOf(substring:string, startIndex?:number):number;
|
||||
indexOf(substring: string, startIndex?: number): number;
|
||||
|
||||
last():string;
|
||||
last(count:number):StringLikeSequence;
|
||||
last(): string;
|
||||
last(count: number): StringLikeSequence;
|
||||
|
||||
lastIndexOf(substring:string, startIndex?:number):number;
|
||||
mapString(mapFn:MapStringCallback):StringLikeSequence;
|
||||
match(pattern:RegExp):StringLikeSequence;
|
||||
reverse():StringLikeSequence;
|
||||
lastIndexOf(substring: string, startIndex?: number): number;
|
||||
mapString(mapFn: MapStringCallback): StringLikeSequence;
|
||||
match(pattern: RegExp): StringLikeSequence;
|
||||
reverse(): StringLikeSequence;
|
||||
|
||||
split(delimiter:string):Sequence;
|
||||
split(delimiter:RegExp):Sequence;
|
||||
split(delimiter: string): StringLikeSequence;
|
||||
split(delimiter: RegExp): StringLikeSequence;
|
||||
|
||||
startsWith(prefix:string):boolean;
|
||||
substring(start:number, stop?:number):StringLikeSequence;
|
||||
toLowerCase():StringLikeSequence;
|
||||
toUpperCase():StringLikeSequence;
|
||||
startsWith(prefix: string): boolean;
|
||||
substring(start: number, stop?: number): StringLikeSequence;
|
||||
toLowerCase(): StringLikeSequence;
|
||||
toUpperCase(): StringLikeSequence;
|
||||
}
|
||||
}
|
||||
|
||||
declare var Lazy:LazyJS.LazyStatic;
|
||||
declare var Lazy: LazyJS.LazyStatic;
|
||||
|
||||
declare module 'lazy.js' {
|
||||
export = Lazy;
|
||||
|
||||
Reference in New Issue
Block a user