久しぶりのTypeScript。Announcing TypeScript 0.9というわけで、ついに待望のジェネリクスが搭載されました。やったね！というわけで、ジェネリクス対応のlinq.jsの型定義を早速作りました、と。ver 3.0.4-Beta5です。まだまだBeta、すみませんすみません、色々忙しくて……。NuGetからもしくはサイトからのダウンロードで公開してます。
とりあえず例として使ってみた感じ。
// booleanしか受け入れないwhereにnumberを突っ込んだらちゃんと怒ってくれるよ！ // Call signatures of types '(x: any) => number' and '(element: number, index: number) => boolean' are incompatible. var seq = Enumerable.from([1, 10, 100, 100]).where(x => x * 2);
やったー。これだよこれ！LINQはジェネリクスがあって本当の本当の真価を発揮するんです！！！
面白げな型定義
C#とちょっと違うところとしては、ジェネリクスの型変数のところにもオブジェクトを突っ込めるんですね。だから
// from(obj)の型定義はこんな感じ。 from(obj: any): IEnumerable<{ key: string; value: any }>; // ちなみにfromのオーバーロードはいっぱいある // linq.js自体はJScriptのIEnumerableとWinMDのIIterable<T>にも対応してるのですがTSで表現できないので、そこは未定義……。。。 from(): IEnumerable<any>; // empty from<T>(obj: IEnumerable<T>): IEnumerable<T>; from(obj: number): IEnumerable<number>; from(obj: boolean): IEnumerable<boolean>; from(obj: string): IEnumerable<string>; from<T>(obj: T[]): IEnumerable<T>; from<T>(obj: { length: number;[x: number]: T; }): IEnumerable<T>;
このkey,valueはどこから出てきたんだよって感じでわかりづらかったので、こうして見えてくれると嬉しい度高い。
型消去
場合によってはIEnumerable<any>となるため、Tの型をつけてあげたかったり、もしくは強引に変換したかったり（例えば↑のIIterable<T>は{key,value}に解釈されてしまうので、明示的に変換してあげる必要がある）する場合のために、castメソッドを用意しました。
// any[]型で渡ってきたりする場合に var seq: any[] = [1, 2, 3, 4, 5]; var result = Enumerable.from(seq) .cast<number>() // numberに変換 .select(x => x * x) // x:number .toArray(); // result:number[]
さて、ところで、TypeScriptのジェネリクスは型消去(Type Erasure)式です。コンパイル結果のJSは以下のような感じで
var result = Enumerable.from(seq) .cast() .select(function (x) { return x * x; }) .toArray();
一切の型は消えています。なので、TypeScriptでTの型を取って実行時に扱ったりはできません。型が欲しければ型を渡せ方式。
linq.jsにはofTypeという、型でフィルタリングするメソッドがあるのですが
// 混在した配列から、型でフィルタして取り出す var mixed: any[] = [1, "hoge", 100, true, "nano"]; // このままじゃ型が分からないのでresultはany[] var result1 = Enumerable.from(mixed) .ofType(Number) // 数値型のみでフィルタ、つまり[1, 100] .toArray(); // ofTypeの後にcastするか、もしくはofTypeで型指定するか var result2 = Enumerable.from(mixed) .ofType<number>(Number) .toArray();
というように、<number>(Number)と連続するのが非常に不恰好……。まあ、この辺はそういうものなのでしょうがないと諦めましょう。
地雷ふんだり
さて、そんな素敵なTypeScript 0.9なのですが、残念なお知らせ。現在の、というか、この0.9ですが、完成度はものすごーーーーーーーーく、低いです。はい、超低いです。Visual Studioと組み合わせて使う場合、半端無く動作も補完も遅いです。正直、ベータどころかアルファぐらいのクオリティで、何故に堂々と出してきたのか理解に苦しむ。遅いだけならまだしも、ジェネリクスの解釈が非常に怪しく、地雷を踏むと補完やエラー通知が消え去ります。いや、消え去るだけならまだよくて、Visual Studioと裏で動くTypeScript Compilerが大暴走をはじめてCPUが100%に張り付いたりします。もうヤヴァい。タスクマネージャー開きっぱにして警戒しながらじゃないと書けないです。linq.jsの型定義書くの超絶苦労した……。
interface IEnumerable<T> { // 戻り値の型をIEnumerable<IGrouping<TKey, T>>にしたいのですが、 // interface側で定義しているTをネストした型変数に使うとVSが大暴走して死ぬ // ので、今回のバージョンではanyにしてます groupBy<TKey>(keySelector: (element: T) => TKey): IEnumerable<IGrouping<TKey, any>>; }
具体的に踏んだのは↑ですねえ。最初原因が分かってなくてかなり時間食われちゃいました。んもー。最小セットで試してる限りでは、コンパイルエラーにはなるんですが(A generic type may not reference itself with a wrapped form of its own type parameters.)暴走はしない、んですがlinq.d.tsで弄ってると死ぬ。おうふ。もう定義の仕方が悪いのかコンパイラがアレなのか判断つかないのでしんどい。
そんなわけで、0.8の完成度からだいぶ退化して、実用性はゼロになってしまいました。私の環境だけ、じゃあないよねえ…‥？とりあえず0.9.1を待ちましょう。どうやらコンパイラをまるっと書き換えたそうですしねー、初物だからshoganaiと思うことにして。しかし泣きたい。
linq.d.ts
とりあえず、こんな感じになってます。
// Type Definition for linq.js, ver 3.0.4-Beta5 declare module linqjs { interface IEnumerator<T> { current(): T; moveNext(): boolean; dispose(): void; } interface Enumerable { Utils: { createLambda(expression: any): (...params: any[]) => any; createEnumerable<T>(getEnumerator: () => IEnumerator<T>): IEnumerable<T>; createEnumerator<T>(initialize: () => void , tryGetNext: () => boolean, dispose: () => void ): IEnumerator<T>; extendTo(type: any): void; }; choice<T>(...params: T[]): IEnumerable<T>; cycle<T>(...params: T[]): IEnumerable<T>; empty<T>(): IEnumerable<T>; // from<T>, obj as JScript's IEnumerable or WinMD IIterable<T> is IEnumerable<T> but it can't define. from(): IEnumerable<any>; // empty from<T>(obj: IEnumerable<T>): IEnumerable<T>; from(obj: number): IEnumerable<number>; from(obj: boolean): IEnumerable<boolean>; from(obj: string): IEnumerable<string>; from<T>(obj: T[]): IEnumerable<T>; from<T>(obj: { length: number;[x: number]: T; }): IEnumerable<T>; from(obj: any): IEnumerable<{ key: string; value: any }>; make<T>(element: T): IEnumerable<T>; matches<T>(input: string, pattern: RegExp): IEnumerable<T>; matches<T>(input: string, pattern: string, flags?: string): IEnumerable<T>; range(start: number, count: number, step?: number): IEnumerable<number>; rangeDown(start: number, count: number, step?: number): IEnumerable<number>; rangeTo(start: number, to: number, step?: number): IEnumerable<number>; repeat<T>(element: T, count?: number): IEnumerable<T>; repeatWithFinalize<T>(initializer: () => T, finalizer: (element) => void ): IEnumerable<T>; generate<T>(func: () => T, count?: number): IEnumerable<T>; toInfinity(start?: number, step?: number): IEnumerable<number>; toNegativeInfinity(start?: number, step?: number): IEnumerable<number>; unfold<T>(seed: T, func: (value: T) => T): IEnumerable<T>; defer<T>(enumerableFactory: () => IEnumerable<T>): IEnumerable<T>; } interface IEnumerable<T> { constructor(getEnumerator: () => IEnumerator<T>); getEnumerator(): IEnumerator<T>; // Extension Methods traverseBreadthFirst(func: (element: T) => IEnumerable<T>): IEnumerable<T>; traverseBreadthFirst<TResult>(func: (element: T) => IEnumerable<T>, resultSelector: (element: T, nestLevel: number) => TResult): IEnumerable<TResult>; traverseDepthFirst<TResult>(func: (element: T) => Enumerable): IEnumerable<T>; traverseDepthFirst<TResult>(func: (element: T) => Enumerable, resultSelector?: (element: T, nestLevel: number) => TResult): IEnumerable<TResult>; flatten(): IEnumerable<any>; pairwise<TResult>(selector: (prev: T, current: T) => TResult): IEnumerable<TResult>; scan(func: (prev: T, current: T) => T): IEnumerable<T>; scan<TAccumulate>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate): IEnumerable<TAccumulate>; select<TResult>(selector: (element: T, index: number) => TResult): IEnumerable<TResult>; selectMany<TOther>(collectionSelector: (element: T, index: number) => IEnumerable<TOther>): IEnumerable<TOther>; selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => IEnumerable<TCollection>, resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>; selectMany<TOther>(collectionSelector: (element: T, index: number) => TOther[]): IEnumerable<TOther>; selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => TCollection[], resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>; selectMany<TOther>(collectionSelector: (element: T, index: number) => { length: number;[x: number]: TOther; }): IEnumerable<TOther>; selectMany<TCollection, TResult>(collectionSelector: (element: T, index: number) => { length: number;[x: number]: TCollection; }, resultSelector: (outer: T, inner: TCollection) => TResult): IEnumerable<TResult>; where(predicate: (element: T, index: number) => boolean): IEnumerable<T>; choose(selector: (element: T, index: number) => T): IEnumerable<T>; ofType<TResult>(type: any): IEnumerable<TResult>; zip<TResult>(second: IEnumerable<T>, resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>; zip<TResult>(second: { length: number;[x: number]: T; }, resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>; zip<TResult>(second: T[], resultSelector: (first: T, second: T, index: number) => TResult): IEnumerable<TResult>; zip<TResult>(...params: any[]): IEnumerable<TResult>; // last one is selector merge<TResult>(...params: IEnumerable<T>[]): IEnumerable<T>; merge<TResult>(...params: { length: number;[x: number]: T; }[]): IEnumerable<T>; merge<TResult>(...params: T[][]): IEnumerable<T>; join<TInner, TKey, TResult>(inner: IEnumerable<TInner>, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TKey) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>; join<TInner, TKey, TResult>(inner: { length: number;[x: number]: TInner; }, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TKey) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>; join<TInner, TKey, TResult>(inner: TInner[], outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TKey) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>; groupJoin<TInner, TKey, TResult>(inner: IEnumerable<TInner>, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TKey) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>; groupJoin<TInner, TKey, TResult>(inner: { length: number;[x: number]: TInner; }, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TKey) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>; groupJoin<TInner, TKey, TResult>(inner: TInner[], outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TKey) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>; all(predicate: (element: T) => boolean): boolean; any(predicate?: (element: T) => boolean): boolean; isEmpty(): boolean; concat(...sequences: IEnumerable<T>[]): IEnumerable<T>; concat(...sequences: { length: number;[x: number]: T; }[]): IEnumerable<T>; concat(...sequences: T[]): IEnumerable<T>; insert(index: number, second: IEnumerable<T>): IEnumerable<T>; insert(index: number, second: { length: number;[x: number]: T; }): IEnumerable<T>; alternate(alternateValue: T): IEnumerable<T>; alternate(alternateSequence: { length: number;[x: number]: T; }): IEnumerable<T>; alternate(alternateSequence: IEnumerable<T>): IEnumerable<T>; alternate(alternateSequence: T[]): IEnumerable<T>; contains(value: T): boolean; contains<TCompare>(value: T, compareSelector?: (element: T) => TCompare): boolean; defaultIfEmpty(defaultValue?: T): IEnumerable<T>; distinct(): IEnumerable<T>; distinct<TCompare>(compareSelector: (element: T) => TCompare): IEnumerable<T>; distinctUntilChanged(): IEnumerable<T>; distinctUntilChanged<TCompare>(compareSelector: (element: T) => TCompare): IEnumerable<T>; except(second: { length: number;[x: number]: T; }): IEnumerable<T>; except<TCompare>(second: { length: number;[x: number]: T; }, compareSelector: (element: T) => TCompare): IEnumerable<T>; except(second: IEnumerable<T>): IEnumerable<T>; except<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>; except(second: T[]): IEnumerable<T>; except<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>; intersect(second: { length: number;[x: number]: T; }): IEnumerable<T>; intersect<TCompare>(second: { length: number;[x: number]: T; }, compareSelector: (element: T) => TCompare): IEnumerable<T>; intersect(second: IEnumerable<T>): IEnumerable<T>; intersect<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>; intersect(second: T[]): IEnumerable<T>; intersect<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>; union(second: { length: number;[x: number]: T; }): IEnumerable<T>; union<TCompare>(second: { length: number;[x: number]: T; }, compareSelector: (element: T) => TCompare): IEnumerable<T>; union(second: IEnumerable<T>): IEnumerable<T>; union<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): IEnumerable<T>; union(second: T[]): IEnumerable<T>; union<TCompare>(second: T[], compareSelector: (element: T) => TCompare): IEnumerable<T>; sequenceEqual(second: { length: number;[x: number]: T; }): boolean; sequenceEqual<TCompare>(second: { length: number;[x: number]: T; }, compareSelector: (element: T) => TCompare): boolean; sequenceEqual(second: IEnumerable<T>): boolean; sequenceEqual<TCompare>(second: IEnumerable<T>, compareSelector: (element: T) => TCompare): boolean; sequenceEqual(second: T[]): boolean; sequenceEqual<TCompare>(second: T[], compareSelector: (element: T) => TCompare): boolean; orderBy<TKey>(keySelector: (element: T) => TKey): IOrderedEnumerable<T>; orderByDescending<TKey>(keySelector: (element: T) => TKey): IOrderedEnumerable<T>; reverse(): IEnumerable<T>; shuffle(): IEnumerable<T>; weightedSample(weightSelector: (element: T) => number): IEnumerable<T>; // truly, return type is IEnumerable<IGrouping<TKey, T>> but Visual Studio + TypeScript Compiler can't compile. groupBy<TKey>(keySelector: (element: T) => TKey): IEnumerable<IGrouping<TKey, T>>; groupBy<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): IEnumerable<IGrouping<TKey, TElement>>; groupBy<TKey, TElement, TResult>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult): IEnumerable<TResult>; groupBy<TKey, TElement, TResult, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult, compareSelector: (element: T) => TCompare): IEnumerable<TResult>; // :IEnumerable<IGrouping<TKey, T>> partitionBy<TKey>(keySelector: (element: T) => TKey): IEnumerable<IGrouping<TKey, any>>; // :IEnumerable<IGrouping<TKey, TElement>> partitionBy<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): IEnumerable<IGrouping<TKey, TElement>>; partitionBy<TKey, TElement, TResult>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult): IEnumerable<TResult>; partitionBy<TKey, TElement, TResult, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult, compareSelector: (element: T) => TCompare): IEnumerable<TResult>; buffer(count: number): IEnumerable<T>; aggregate(func: (prev: T, current: T) => T): T; aggregate<TAccumulate>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate): TAccumulate; aggregate<TAccumulate, TResult>(seed: TAccumulate, func: (prev: TAccumulate, current: T) => TAccumulate, resultSelector: (last: TAccumulate) => TResult): TResult; average(selector?: (element: T) => number): number; count(predicate?: (element: T, index: number) => boolean): number; max(selector?: (element: T) => number): number; min(selector?: (element: T) => number): number; maxBy<TKey>(keySelector: (element: T) => TKey): T; minBy<TKey>(keySelector: (element: T) => TKey): T; sum(selector?: (element: T) => number): number; elementAt(index: number): T; elementAtOrDefault(index: number, defaultValue?: T): T; first(predicate?: (element: T, index: number) => boolean): T; firstOrDefault(predicate?: (element: T, index: number) => boolean, defaultValue?: T): T; last(predicate?: (element: T, index: number) => boolean): T; lastOrDefault(predicate?: (element: T, index: number) => boolean, defaultValue?: T): T; single(predicate?: (element: T, index: number) => boolean): T; singleOrDefault(predicate?: (element: T, index: number) => boolean, defaultValue?: T): T; skip(count: number): IEnumerable<T>; skipWhile(predicate: (element: T, index: number) => boolean): IEnumerable<T>; take(count: number): IEnumerable<T>; takeWhile(predicate: (element: T, index: number) => boolean): IEnumerable<T>; takeExceptLast(count?: number): IEnumerable<T>; takeFromLast(count: number): IEnumerable<T>; indexOf(item: T): number; indexOf(predicate: (element: T, index: number) => boolean): number; lastIndexOf(item: T): number; lastIndexOf(predicate: (element: T, index: number) => boolean): number; asEnumerable(): IEnumerable<T>; cast<TResult>(): IEnumerable<TResult>; toArray(): T[]; // truly, return type is ILookup<TKey, T> but Visual Studio + TypeScript Compiler can't compile. toLookup<TKey>(keySelector: (element: T) => TKey): ILookup<TKey, any>; toLookup<TKey, TElement>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement): ILookup<TKey, TElement>; toLookup<TKey, TElement, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, compareSelector: (key: TKey) => TCompare): ILookup<TKey, TElement>; toObject(keySelector: (element: T) => any, elementSelector?: (element: T) => any): Object; // :IDictionary<TKey, T> toDictionary<TKey>(keySelector: (element: T) => TKey): IDictionary<TKey, any>; toDictionary<TKey, TValue>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue): IDictionary<TKey, TValue>; toDictionary<TKey, TValue, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TValue, compareSelector: (key: TKey) => TCompare): IDictionary<TKey, TValue>; toJSONString(replacer: (key: string, value: any) => any): string; toJSONString(replacer: any[]): string; toJSONString(replacer: (key: string, value: any) => any, space: any): string; toJSONString(replacer: any[], space: any): string; toJoinedString(separator?: string): string; toJoinedString<TResult>(separator: string, selector: (element: T, index: number) => TResult): string; doAction(action: (element: T, index: number) => void ): IEnumerable<T>; doAction(action: (element: T, index: number) => boolean): IEnumerable<T>; forEach(action: (element: T, index: number) => void ): void; forEach(action: (element: T, index: number) => boolean): void; write(separator?: string): void; write<TResult>(separator: string, selector: (element: T) => TResult): void; writeLine(): void; writeLine<TResult>(selector: (element: T) => TResult): void; force(): void; letBind<TResult>(func: (source: IEnumerable<T>) => { length: number;[x: number]: TResult; }): IEnumerable<TResult>; letBind<TResult>(func: (source: IEnumerable<T>) => TResult[]): IEnumerable<TResult>; letBind<TResult>(func: (source: IEnumerable<T>) => IEnumerable<TResult>): IEnumerable<TResult>; share(): IDisposableEnumerable<T>; memoize(): IDisposableEnumerable<T>; catchError(handler: (exception: any) => void ): IEnumerable<T>; finallyAction(finallyAction: () => void ): IEnumerable<T>; log(): IEnumerable<T>; log<TValue>(selector: (element: T) => TValue ): IEnumerable<T>; trace(message?: string): IEnumerable<T>; trace<TValue>(message: string, selector: (element: T) => TValue ): IEnumerable<T>; } interface IOrderedEnumerable<T> extends IEnumerable<T> { createOrderedEnumerable<TKey>(keySelector: (element: T) => TKey, descending: boolean): IOrderedEnumerable<T>; thenBy<TKey>(keySelector: (element: T) => TKey): IOrderedEnumerable<T>; thenByDescending<TKey>(keySelector: (element: T) => TKey): IOrderedEnumerable<T>; } interface IDisposableEnumerable<T> extends IEnumerable<T> { dispose(): void; } interface IDictionary<TKey, TValue> { add(key: TKey, value: TValue): void; get(key: TKey): TValue; set(key: TKey, value: TValue): boolean; contains(key: TKey): boolean; clear(): void; remove(key: TKey): void; count(): number; toEnumerable(): IEnumerable<{ key: TKey; value: TValue }>; } interface ILookup<TKey, TElement> { count(): number; get(key: TKey): IEnumerable<TElement>; contains(key: TKey): boolean; toEnumerable(): IEnumerable<IGrouping<TKey, TElement>>; } interface IGrouping<TKey, TElement> extends IEnumerable<TElement> { key(): TKey; } } // export definition declare var Enumerable: linqjs.Enumerable;
アップデートを全然追ってないので、初期に作った定義の仕方のまんまなので、大丈夫かな、まあ、大丈夫じゃないかな、きっと。
とりあえずとにかく面倒くさかった。しかし定義する人が苦労すれば、利用者はハッピーになれるから！！！なのではやくVS対応がまともになってください。ぶんぶんぶん回したいのだけれどねえ←その前にlinq.js ver.3がいつまでもBetaなのをなんとかしろ
