From 9006a88ab5a9cc9695c8640a19af3babf0e38f52 Mon Sep 17 00:00:00 2001 From: Bart van der Schoor Date: Fri, 28 Feb 2014 00:09:59 +0100 Subject: [PATCH 1/2] converted lazy.js to generics --- lazy.js/lazy.js-tests.ts | 232 +++++++++++++++++--------------- lazy.js/lazy.js.d.ts | 280 ++++++++++++++++++++------------------- 2 files changed, 270 insertions(+), 242 deletions(-) diff --git a/lazy.js/lazy.js-tests.ts b/lazy.js/lazy.js-tests.ts index 356ee177b5..59331377c2 100644 --- a/lazy.js/lazy.js-tests.ts +++ b/lazy.js/lazy.js-tests.ts @@ -1,9 +1,32 @@ /// -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; +var barSequence: LazyJS.Sequence; +var fooArraySeq: LazyJS.ArrayLikeSequence; +var barArraySeq: LazyJS.ArrayLikeSequence; +var fooObjectSeq: LazyJS.ObjectLikeSequence; +var anyObjectSeq: LazyJS.ObjectLikeSequence; +var fooAsyncSeq: LazyJS.AsyncSequence; + var stringSeq: LazyJS.StringLikeSequence; var obj: Object; @@ -23,141 +46,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({a:foo, b:foo}); +anyObjectSeq = Lazy({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); +fooSequence = 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(); +stringSeq = 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 +205,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); diff --git a/lazy.js/lazy.js.d.ts b/lazy.js/lazy.js.d.ts index 47925bdf94..53de92ae3b 100644 --- a/lazy.js/lazy.js.d.ts +++ b/lazy.js/lazy.js.d.ts @@ -6,28 +6,31 @@ declare module LazyJS { interface LazyStatic { - (value:string):StringLikeSequence; - (value:any[]):ArrayLikeSequence; - (value:Object):ObjectLikeSequence; - (value:ArrayLike):ArrayLikeSequence; + (value: string):StringLikeSequence; + + (value: T[]):ArrayLikeSequence; + (value: any[]):ArrayLikeSequence; + (value: Object):ObjectLikeSequence; + (value: Object):ObjectLikeSequence; strict():LazyStatic; - generate(generatorFn:GeneratorCallback, length?:number):GeneratedSequence; + generate(generatorFn: GeneratorCallback, length?: number):GeneratedSequence; - range(to:number):GeneratedSequence; - range(from:number, to:number, step?:number):GeneratedSequence; + range(to: number):GeneratedSequence; + range(from: number, to: number, step?: number):GeneratedSequence; - repeat(value:any, count?:number):GeneratedSequence; + repeat(value: T, count?: number):GeneratedSequence; - on(eventType:string):Sequence; + on(eventType: string):Sequence; - readFile(path:string):StringLikeSequence; - makeHttpRequest(path:string):StringLikeSequence; + readFile(path: string):StringLikeSequence; + makeHttpRequest(path: string):StringLikeSequence; } - interface ArrayLike { + interface ArrayLike { 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 { + (value: T):void; } - interface GetKeyCallback { - (value:any):string; + interface GetKeyCallback { + (value: T):string; } - interface TestCallback { - (value:any):boolean; + interface TestCallback { + (value: T):boolean; } - interface MapCallback { - (value:any):any; + interface MapCallback { + (value: T):U; } interface MapStringCallback { - (value:string):string; + (value: string):string; } - interface NumberCallback { - (value:any):number; + interface NumberCallback { + (value: T):number; } - interface MemoCallback { - (memo:any, value:any):any; + interface MemoCallback { + (memo: U, value: T):U; } - interface GeneratorCallback { - (index:number):any; + interface GeneratorCallback { + (index: number):T; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - interface Iterator { - new(sequence:Sequence):Iterator; - current():any; + interface Iterator { + new (sequence: Sequence):Iterator; + current():T; moveNext():boolean; } - interface GeneratedSequence extends Sequence { - new(generatorFn:GeneratorCallback, length:number):GeneratedSequence; + interface GeneratedSequence extends Sequence { + new(generatorFn: GeneratorCallback, length: number):GeneratedSequence; length():number; } - interface AsyncSequence extends SequenceBase { - each(callback:ValueCallback):AsyncHandle; + interface AsyncSequence extends SequenceBase { + each(callback: ValueCallback):AsyncHandle; } - interface AsyncHandle { + interface AsyncHandle { 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 extends SequenceBase { + each(eachFn: ValueCallback):Sequence; } - interface SequenceBase extends SequenceBaser { + interface SequenceBase extends SequenceBaser { first():any; - first(count:number):Sequence; - indexOf(value:any, startIndex?:number):Sequence; + first(count: number):Sequence; + indexOf(value: any, startIndex?: number):Sequence; last():any; - last(count:number):Sequence; - lastIndexOf(value:any):Sequence; + last(count: number):Sequence; + lastIndexOf(value: any):Sequence; - reverse():Sequence; + reverse():Sequence; } - interface SequenceBaser { + interface SequenceBaser { // 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; + chunk(size: number):Sequence; + compact():Sequence; + concat(var_args: T[]):Sequence; + consecutive(length: number):Sequence; + contains(value: T):boolean; + countBy(keyFn: GetKeyCallback): ObjectLikeSequence; + countBy(propertyName: string): ObjectLikeSequence; + dropWhile(predicateFn: TestCallback): Sequence; + every(predicateFn: TestCallback): boolean; + filter(predicateFn: TestCallback): Sequence; + find(predicateFn: TestCallback): Sequence; + findWhere(properties: Object): Sequence; - 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; + groupBy(keyFn: GetKeyCallback): ObjectLikeSequence; + initial(count?: number): Sequence; + intersection(var_args: T[]): Sequence; + invoke(methodName: string): Sequence; + isEmpty(): boolean; + join(delimiter?: string): string; + map(mapFn: MapCallback): Sequence; - toArray():any[]; - toObject():Object; + max(valueFn?: NumberCallback): T; + min(valueFn?: NumberCallback): T; + pluck(propertyName: string): Sequence; + reduce(aggregatorFn: MemoCallback, memo?: U): U; + reduceRight(aggregatorFn: MemoCallback, memo: U): U; + reject(predicateFn: TestCallback): Sequence; + rest(count?: number): Sequence; + shuffle(): Sequence; + some(predicateFn?: TestCallback): boolean; + sortBy(sortFn: NumberCallback): Sequence; + sortedIndex(value: T): Sequence; + sum(valueFn?: NumberCallback): Sequence; + takeWhile(predicateFn: TestCallback): Sequence; + union(var_args: T[]): Sequence; + uniq(): Sequence; + where(properties: Object): Sequence; + without(var_args: T[]): Sequence; + zip(var_args: T[]): Sequence; + + 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 extends Sequence { // 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; + first(count?: number): ArrayLikeSequence; + get(index: number): T; + length(): number; + map(mapFn: MapCallback): ArrayLikeSequence; + pop(): ArrayLikeSequence; + rest(count?: number): ArrayLikeSequence; + reverse(): ArrayLikeSequence; + shift(): ArrayLikeSequence; + slice(begin: number, end?: number): ArrayLikeSequence; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 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 extends Sequence { + assign(other: Object): ObjectLikeSequence; // 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; + functions(): Sequence; + get(property: string): ObjectLikeSequence; + invert(): ObjectLikeSequence; + keys(): StringLikeSequence; + omit(properties: string[]): ObjectLikeSequence; + pairs(): Sequence; + pick(properties: string[]): ObjectLikeSequence; + toArray(): T[]; + toObject(): Object; + values(): Sequence; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 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 { + 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; From a6964c6bf2d5a17443028b5796603c2f859b2702 Mon Sep 17 00:00:00 2001 From: Bart van der Schoor Date: Fri, 7 Mar 2014 18:48:32 +0100 Subject: [PATCH 2/2] small fixes to Lazy.js --- lazy.js/lazy.js-tests.ts | 5 +++-- lazy.js/lazy.js.d.ts | 6 +++--- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/lazy.js/lazy.js-tests.ts b/lazy.js/lazy.js-tests.ts index 59331377c2..7689bcaf78 100644 --- a/lazy.js/lazy.js-tests.ts +++ b/lazy.js/lazy.js-tests.ts @@ -27,6 +27,7 @@ var fooObjectSeq: LazyJS.ObjectLikeSequence; var anyObjectSeq: LazyJS.ObjectLikeSequence; var fooAsyncSeq: LazyJS.AsyncSequence; +var strSequence: LazyJS.Sequence; var stringSeq: LazyJS.StringLikeSequence; var obj: Object; @@ -124,7 +125,7 @@ foo = fooSequence.last(); fooSequence = fooSequence.last(num); fooSequence = fooSequence.lastIndexOf(foo); -fooSequence = fooSequence.map(fnMapCallback); +barSequence = fooSequence.map(fnMapCallback); foo = fooSequence.max(); foo = fooSequence.max(fnNumberCallback); foo = fooSequence.min(); @@ -175,7 +176,7 @@ fooObjectSeq = fooObjectSeq.defaults(obj); fooSequence = fooObjectSeq.functions(); fooObjectSeq = fooObjectSeq.get(str); fooObjectSeq = fooObjectSeq.invert(); -stringSeq = fooObjectSeq.keys(); +strSequence = fooObjectSeq.keys(); fooObjectSeq = fooObjectSeq.omit(strArr); fooSequence = fooObjectSeq.pairs(); fooObjectSeq = fooObjectSeq.pick(strArr); diff --git a/lazy.js/lazy.js.d.ts b/lazy.js/lazy.js.d.ts index 53de92ae3b..ca19aed983 100644 --- a/lazy.js/lazy.js.d.ts +++ b/lazy.js/lazy.js.d.ts @@ -6,8 +6,8 @@ declare module LazyJS { interface LazyStatic { - (value: string):StringLikeSequence; + (value: string):StringLikeSequence; (value: T[]):ArrayLikeSequence; (value: any[]):ArrayLikeSequence; (value: Object):ObjectLikeSequence; @@ -141,7 +141,7 @@ declare module LazyJS { invoke(methodName: string): Sequence; isEmpty(): boolean; join(delimiter?: string): string; - map(mapFn: MapCallback): Sequence; + map(mapFn: MapCallback): Sequence; max(valueFn?: NumberCallback): T; min(valueFn?: NumberCallback): T; @@ -200,7 +200,7 @@ declare module LazyJS { functions(): Sequence; get(property: string): ObjectLikeSequence; invert(): ObjectLikeSequence; - keys(): StringLikeSequence; + keys(): Sequence; omit(properties: string[]): ObjectLikeSequence; pairs(): Sequence; pick(properties: string[]): ObjectLikeSequence;