From 4f1786355cc5480b184e06d5da3f6da0c257b39c Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Fri, 25 Oct 2013 13:55:57 +0400
Subject: [PATCH 01/12] Added type definitions for IxJS (only for l2o.js)

Added type definitions for IxJS project v1.0.6
(https://github.com/Reactive-Extensions/IxJS) only for core Linq to
Objects (l2o.js).
---
 ix.js/l2o.d.ts | 241 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 241 insertions(+)
 create mode 100644 ix.js/l2o.d.ts

diff --git a/ix.js/l2o.d.ts b/ix.js/l2o.d.ts
new file mode 100644
index 000000000..be5f43c2f
--- /dev/null
+++ b/ix.js/l2o.d.ts
@@ -0,0 +1,241 @@
+// Type definitions for IxJS 1.0.6
+// Project: https://github.com/Reactive-Extensions/IxJS
+// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
+
+declare module Ix {
+    export interface Enumerator<T> {
+        moveNext(): boolean;
+        getCurrent(): T;
+        dispose();
+    }
+
+    export interface EnumeratorStatic {
+        new<T>(moveNext: () => boolean, getCurrent: () => T, dispose: () => void): Enumerator<T>;
+        create<T>(moveNext: () => boolean, getCurrent: () => T, dispose?: () => void): Enumerator<T>;
+    }
+
+    var Enumerator: EnumerableStatic;
+
+    export interface EnumerableFunc<T, TResult> {
+        (item: T, index: number, self: Enumerable<T>): TResult;
+    }
+    export interface EnumerablePredicate<T> extends EnumerableFunc<T, boolean> { }
+    export interface Predicate<T> {
+        (item: T): boolean;
+    }
+    export interface EqualityComparer<T1, T2> {
+        (item1: T1, item2: T2): boolean;
+    }
+
+    export interface Enumerable<T> {
+        // base functions
+        getEnumerator(): Enumerator<T>;
+
+        // "extension" functions
+
+        aggregate<TAccumulate, TResult>(seed: TAccumulate, func: (accumulate: TAccumulate, current: T, index: number, self: Enumerable<T>) => TAccumulate, resultSelector: (accumulate: TAccumulate) => TResult): TResult;
+        aggregate<TAccumulate>(seed: TAccumulate, func: (accumulate: TAccumulate, current: T, index: number, self: Enumerable<T>) => TAccumulate): TAccumulate;
+        aggregate(func: (accumulate: T, current: T, index: number, self: Enumerable<T>) => T): T;
+
+        reduce(func: (accumulate: T, current: T, index: number, self: Enumerable<T>) => T): T;
+        reduce<TAccumulate>(func: (accumulate: TAccumulate, current: T, index: number, self: Enumerable<T>) => TAccumulate, seed: TAccumulate): TAccumulate;
+
+        all(predicate: EnumerablePredicate<T>, thisArg?: any): boolean;
+        every(predicate: EnumerablePredicate<T>, thisArg?: any): boolean; // alias
+
+        any(predicate?: EnumerablePredicate<T>, thisArg?: any): boolean;
+        some(predicate?: EnumerablePredicate<T>, thisArg?: any): boolean; // alias
+
+        average(selector?: EnumerableFunc<T, number>): number;
+        max(selector?: EnumerableFunc<T, number>): number;
+        min(selector?: EnumerableFunc<T, number>): number;
+        sum(selector?: EnumerableFunc<T, number>): number;
+
+        concat<T>(...sources: Enumerable<T>[]): Enumerable<T>;
+
+        contains<TValue>(value: TValue, comparer: EqualityComparer<T, TValue>): boolean;
+        contains(value: any): boolean;
+
+        count(predicate?: EnumerablePredicate<T>, thisArg?: any): number;
+
+        defaultIfEmpty(defaultValue: T): Enumerable<T>;
+
+        distinct(comparer?: EqualityComparer<T, T>): Enumerable<T>;
+
+        elementAt(index: number): T;
+        elementAtOrDefault(index: number): T;
+
+        except(second: Enumerable<T>, comparer?: EqualityComparer<T, T>): Enumerable<T>;
+
+        first(predicate?: Predicate<T>): T;
+        firstOrDefault(predicate?: Predicate<T>): T;
+        last(predicate?: Predicate<T>): T;
+        lastOrDefault(predicate?: Predicate<T>): T;
+        single(predicate?: Predicate<T>): T;
+        singleOrDefault(predicate?: Predicate<T>): T;
+
+        forEach(action: EnumerableFunc<T, void>, thisArg?: any): void;
+
+        groupBy<TKey, TElement, TResult>(
+            keySelector: (item: T) => TKey,
+            elementSelector: (item: T) => TElement,
+            resultSelector: (key: TKey, values: Enumerable<TElement>) => TResult,
+            comparer?: EqualityComparer<TKey, TKey>): Enumerable<TResult>;
+        groupBy<TKey, TElement>(
+            keySelector: (item: T) => TKey,
+            elementSelector: (item: T) => TElement): Grouping<TKey, TElement>;
+        groupBy<TKey>(
+            keySelector: (item: T) => TKey): Grouping<TKey, T>;
+
+        // if need to set comparer without resultSelector
+        groupBy<TKey, TElement>(
+            keySelector: (item: T) => TKey,
+            elementSelector: (item: T) => TElement,
+            _: boolean,
+            comparer: EqualityComparer<TKey, TKey>): Grouping<TKey, TElement>;
+        // if need to set resultSelector without elementSelector
+        groupBy<TKey, TResult>(
+            keySelector: (item: T) => TKey,
+            _: boolean,
+            resultSelector: (key: TKey, values: Enumerable<T>) => TResult,
+            comparer?: EqualityComparer<TKey, TKey>): Enumerable<TResult>;
+        // if need to set comparer without elementSelector and resultSelector
+        groupBy<TKey>(
+            keySelector: (item: T) => TKey,
+            _: boolean,
+            __: boolean,
+            comparer: EqualityComparer<TKey, TKey>): Grouping<TKey, T>;
+
+        groupJoin<TInner, TOuterKey, TInnerKey, TResult>(
+            inner: Enumerable<TInner>,
+            outerKeySelector: (item: T) => TOuterKey,
+            innerKeySelector: (item: TInner) => TInnerKey,
+            resultSelector: (outer: T, innerSequence: Enumerable<TInner>) => TResult,
+            comparer: EqualityComparer<TOuterKey, TInnerKey>): Enumerable<TResult>;
+        groupJoin<TInner, TKey, TResult>(
+            inner: Enumerable<TInner>,
+            outerKeySelector: (item: T) => TKey,
+            innerKeySelector: (item: TInner) => TKey,
+            resultSelector: (outer: T, innerSequence: Enumerable<TInner>) => TResult): Enumerable<TResult>;
+
+        join<TInner, TOuterKey, TInnerKey, TResult>(
+            inner: Enumerable<TInner>,
+            outerKeySelector: (item: T) => TOuterKey,
+            innerKeySelector: (item: TInner) => TInnerKey,
+            resultSelector: (outer: T, inner: TInner) => TResult,
+            comparer: EqualityComparer<TOuterKey, TInnerKey>): Enumerable<TResult>;
+        join<TInner, TKey, TResult>(
+            inner: Enumerable<TInner>,
+            outerKeySelector: (item: T) => TKey,
+            innerKeySelector: (item: TInner) => TKey,
+            resultSelector: (outer: T, inner: TInner) => TResult): Enumerable<TResult>;
+
+        intersect<TSecond>(second: Enumerable<TSecond>, comparer: EqualityComparer<T, TSecond>): Enumerable<T>;
+        intersect(second: Enumerable<T>): Enumerable<T>;
+        union(second: Enumerable<T>, comparer?: EqualityComparer<T, T>): Enumerable<T>;
+
+        orderBy<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): OrderedEnumerable<T>;
+        orderByDescending<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): OrderedEnumerable<T>;
+
+        reverse(): Enumerable<T>;
+
+        select<TResult>(selector: EnumerableFunc<T, TResult>, thisArg?: any): Enumerable<TResult>;
+        map<TResult>(selector: EnumerableFunc<T, TResult>, thisArg?: any): Enumerable<TResult>;
+
+        selectMany<TCollection, TResult>(collectionSelector: (item: T, index: number) => Enumerable<TCollection>,
+            resultSelector: (outer: T, inner: TCollection) => TResult): Enumerable<TResult>;
+        selectMany<TCollection>(collectionSelector: (item: T, index: number) => Enumerable<TCollection>): Enumerable<TCollection>;
+
+        sequenceEqual<TSecond>(second: Enumerable<TSecond>, comparer: EqualityComparer<T, TSecond>): boolean;
+        sequenceEqual(second: Enumerable<T>): boolean;
+
+        skip(count: number): Enumerable<T>;
+        skipWhile(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
+        take(count: number): Enumerable<T>;
+        takeWhile(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
+
+        toArray(): T[];
+
+        toDictionary<TKey, TValue>(
+            keySelector: (item: T) => TKey,
+            elementSelector: (item: T) => TValue,
+            comparer?: EqualityComparer<TKey, TKey>): Dictionary<TKey, TValue>;
+        toDictionary<TKey>(
+            keySelector: (item: T) => TKey): Dictionary<TKey, T>;
+        // if need to set comparer without elementSelector
+        toDictionary<TKey>(
+            keySelector: (item: T) => TKey,
+            _: boolean,
+            comparer: EqualityComparer<TKey, TKey>): Dictionary<TKey, T>;
+
+        toLookup<TKey, TValue>(
+            keySelector: (item: T) => TKey,
+            elementSelector: (item: T) => TValue,
+            comparer?: EqualityComparer<TKey, TKey>): Lookup<TKey, TValue>;
+        toLookup<TKey>(
+            keySelector: (item: T) => TKey): Lookup<TKey, T>;
+        // if need to set comparer without elementSelector
+        toLookup<TKey>(
+            keySelector: (item: T) => TKey,
+            _: boolean,
+            comparer: EqualityComparer<TKey, TKey>): Lookup<TKey, T>;
+
+        where(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
+        filter(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
+
+        zip<TRight, TResult>(right: Enumerable<TRight>, selector: (left: T, right: TRight) => TResult): Enumerable<TResult>;
+    }
+
+    export interface Grouping<TKey, T> extends Enumerable<T> {
+        key: TKey;
+    }
+
+    export interface OrderedEnumerable<T> extends Enumerable<T> {
+        thenBy<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): OrderedEnumerable<T>;
+        thenByDescending<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): OrderedEnumerable<T>;
+    }
+
+    class Dictionary<TKey, TValue> {
+        constructor(capacity, comparer?: EqualityComparer<TKey, TKey>);
+
+        toEnumerable(): Enumerable<KeyValuePair<TKey, TValue>>;
+        add(key: TKey, value: TValue): void;
+        remove(key: TKey): boolean;
+        clear(): void;
+        length(): number;
+        tryGetValue(key: TKey): TValue;
+        get(key: TKey): TValue;
+        set(key: TKey, value: TValue): void;
+        getValues(): TValue[];
+        has(key: TKey): boolean;
+    }
+
+    export interface KeyValuePair<TKey, TValue> {
+        key: TKey;
+        value: TValue;
+    }
+
+    export interface Lookup<TKey, TValue> {
+        toEnumerable(): Enumerable<Grouping<TKey, TValue>>;
+        has(key: TKey): boolean;
+        length(): number;
+        get(key: TKey): Enumerable<TValue>;
+    }
+
+    export interface EnumerableStatic {
+        new <T>(getEnumerator: () => Enumerator<T>): Enumerable<T>;
+        create<T>(getEnumerator: () => Enumerator<T>): Enumerable<T>;
+
+        concat<T>(...sources: Enumerable<T>[]): Enumerable<T>;
+        empty<T>(): Enumerable<T>;
+        fromArray<T>(array: T[]): Enumerable<T>;
+        returnValue<T>(value: T): Enumerable<T>;
+        range(start: number, count: number): Enumerable<number>;
+        repeat<T>(value: T, repeatCount?: number): Enumerable<T>;
+
+        sequenceEqual<TFirst, TSecond>(first: Enumerable<TFirst>, second: Enumerable<TSecond>, comparer: EqualityComparer<TFirst, TSecond>): boolean;
+        sequenceEqual<T>(first: Enumerable<T>, second: Enumerable<T>): boolean;
+    }
+
+    var Enumerable: EnumerableStatic;
+}
\ No newline at end of file

From 32adbb82c900b7bf8ffae22d32c16ecddb38e99c Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Fri, 25 Oct 2013 16:50:17 +0400
Subject: [PATCH 02/12] Created Disposable (for ix.js); Removed generative type
 recursion

Via TS spec #3.5.2 generative recursive are disallowed (restriction will
be removed in the future), so added workaround.
Disposable interface extracted from Enumerator
---
 ix.js/l2o.d.ts | 59 +++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 44 insertions(+), 15 deletions(-)

diff --git a/ix.js/l2o.d.ts b/ix.js/l2o.d.ts
index be5f43c2f..8177376e1 100644
--- a/ix.js/l2o.d.ts
+++ b/ix.js/l2o.d.ts
@@ -3,10 +3,13 @@
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
 
 declare module Ix {
-    export interface Enumerator<T> {
+	export interface Disposable {
+		dispose();
+	}
+
+	export interface Enumerator<T> extends Disposable {
         moveNext(): boolean;
         getCurrent(): T;
-        dispose();
     }
 
     export interface EnumeratorStatic {
@@ -84,8 +87,11 @@ declare module Ix {
         groupBy<TKey, TElement>(
             keySelector: (item: T) => TKey,
             elementSelector: (item: T) => TElement): Grouping<TKey, TElement>;
-        groupBy<TKey>(
-            keySelector: (item: T) => TKey): Grouping<TKey, T>;
+        // spec 3.5.2, waiting for restriction on generative recursion removal
+		/*groupBy<TKey>(
+            keySelector: (item: T) => TKey): Grouping<TKey, T>;*/
+        groupBy<TKey, _T extends T>(
+            keySelector: (item: T) => TKey): Grouping<TKey, _T>;
 
         // if need to set comparer without resultSelector
         groupBy<TKey, TElement>(
@@ -100,11 +106,17 @@ declare module Ix {
             resultSelector: (key: TKey, values: Enumerable<T>) => TResult,
             comparer?: EqualityComparer<TKey, TKey>): Enumerable<TResult>;
         // if need to set comparer without elementSelector and resultSelector
-        groupBy<TKey>(
+        // spec 3.5.2, waiting for restriction on generative recursion removal
+		/*groupBy<TKey>(
             keySelector: (item: T) => TKey,
             _: boolean,
             __: boolean,
-            comparer: EqualityComparer<TKey, TKey>): Grouping<TKey, T>;
+            comparer: EqualityComparer<TKey, TKey>): Grouping<TKey, T>;*/
+        groupBy<TKey, _T extends T>(
+            keySelector: (item: T) => TKey,
+            _: boolean,
+            __: boolean,
+            comparer: EqualityComparer<TKey, TKey>): Grouping<TKey, _T>;
 
         groupJoin<TInner, TOuterKey, TInnerKey, TResult>(
             inner: Enumerable<TInner>,
@@ -160,25 +172,41 @@ declare module Ix {
             keySelector: (item: T) => TKey,
             elementSelector: (item: T) => TValue,
             comparer?: EqualityComparer<TKey, TKey>): Dictionary<TKey, TValue>;
-        toDictionary<TKey>(
-            keySelector: (item: T) => TKey): Dictionary<TKey, T>;
+        // spec 3.5.2, waiting for restriction on generative recursion removal
+		/*toDictionary<TKey>(
+            keySelector: (item: T) => TKey): Dictionary<TKey, T>;*/
+        toDictionary<TKey, _T extends T>(
+            keySelector: (item: T) => TKey): Dictionary<TKey, _T>;
         // if need to set comparer without elementSelector
-        toDictionary<TKey>(
+        // spec 3.5.2, waiting for restriction on generative recursion removal
+		/*toDictionary<TKey>(
             keySelector: (item: T) => TKey,
             _: boolean,
-            comparer: EqualityComparer<TKey, TKey>): Dictionary<TKey, T>;
+            comparer: EqualityComparer<TKey, TKey>): Dictionary<TKey, T>;*/
+        toDictionary<TKey, _T extends T>(
+            keySelector: (item: T) => TKey,
+            _: boolean,
+            comparer: EqualityComparer<TKey, TKey>): Dictionary<TKey, _T>;
 
         toLookup<TKey, TValue>(
             keySelector: (item: T) => TKey,
             elementSelector: (item: T) => TValue,
             comparer?: EqualityComparer<TKey, TKey>): Lookup<TKey, TValue>;
-        toLookup<TKey>(
-            keySelector: (item: T) => TKey): Lookup<TKey, T>;
+        // spec 3.5.2, waiting for restriction on generative recursion removal
+		/*toLookup<TKey>(
+            keySelector: (item: T) => TKey): Lookup<TKey, T>;*/
+        toLookup<TKey, _T extends T>(
+            keySelector: (item: T) => TKey): Lookup<TKey, _T>;
         // if need to set comparer without elementSelector
-        toLookup<TKey>(
+        // spec 3.5.2, waiting for restriction on generative recursion removal
+		/*toLookup<TKey>(
             keySelector: (item: T) => TKey,
             _: boolean,
-            comparer: EqualityComparer<TKey, TKey>): Lookup<TKey, T>;
+            comparer: EqualityComparer<TKey, TKey>): Lookup<TKey, T>;*/
+        toLookup<TKey, _T extends T>(
+            keySelector: (item: T) => TKey,
+            _: boolean,
+            comparer: EqualityComparer<TKey, TKey>): Lookup<TKey, _T>;
 
         where(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
         filter(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
@@ -199,6 +227,7 @@ declare module Ix {
         constructor(capacity, comparer?: EqualityComparer<TKey, TKey>);
 
         toEnumerable(): Enumerable<KeyValuePair<TKey, TValue>>;
+
         add(key: TKey, value: TValue): void;
         remove(key: TKey): boolean;
         clear(): void;
@@ -216,7 +245,7 @@ declare module Ix {
     }
 
     export interface Lookup<TKey, TValue> {
-        toEnumerable(): Enumerable<Grouping<TKey, TValue>>;
+        toEnumerable(): Enumerable<Grouping<TKey, any>>;
         has(key: TKey): boolean;
         length(): number;
         get(key: TKey): Enumerable<TValue>;

From dd5b76560ba4356a5ad8ddc1c84d568054cfe26a Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Fri, 25 Oct 2013 17:13:23 +0400
Subject: [PATCH 03/12] Added type definitions for IxJs/ix.js.

---
 ix.js/ix.d.ts | 114 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 114 insertions(+)
 create mode 100644 ix.js/ix.d.ts

diff --git a/ix.js/ix.d.ts b/ix.js/ix.d.ts
new file mode 100644
index 000000000..5de2361dd
--- /dev/null
+++ b/ix.js/ix.d.ts
@@ -0,0 +1,114 @@
+///<reference path="l2o.d.ts"/>
+
+declare module Ix {
+
+	export interface Comparer<T1, T2> {
+		(item1: T1, item2: T2): number;
+	}
+
+	export interface Observer<T> {
+		onNext? (value: T): void;
+		onError? (error: Error): void;
+		onCompleted? (): void;
+	}
+
+	export interface Enumerable<T> {
+		isEmpty(): boolean;
+
+		minBy<TKey>(keySelector: (item: T) => TKey, comparer: Comparer<TKey, TKey>): Enumerable<T>;
+		minBy(keySelector: (item: T) => number): Enumerable<T>;
+		maxBy<TKey>(keySelector: (item: T) => TKey, comparer: Comparer<TKey, TKey>): Enumerable<T>;
+		maxBy(keySelector: (item: T) => number): Enumerable<T>;
+
+		share<TResult>(selector: (source: Enumerable<T>) => Enumerable<TResult>): Enumerable<TResult>;
+		share(): Enumerable<T>;
+
+		publish<TResult>(selector: (source: Enumerable<T>) => Enumerable<TResult>): Enumerable<TResult>;
+		publish(): Enumerable<T>;
+
+		memoize(): Enumerable<T>;
+
+		do(onNext: (value: T) => void, onError?: (error: Error) => void, onCompleted?: () => void): Enumerable<T>;
+		doAction(onNext: (value: T) => void, onError?: (error: Error) => void, onCompleted?: () => void): Enumerable<T>;
+		do(onbserver: Observer<T>): Enumerable<T>;
+		doAction(onbserver: Observer<T>): Enumerable<T>;
+
+		bufferWithCount(count: number, skip?: number): Enumerable<T>;
+
+		ignoreElements(): Enumerable<T>;
+
+		distinctBy<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): Enumerable<T>;
+
+		distinctUntilChanged<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): Enumerable<T>;
+		distinctUntilChanged(): Enumerable<T>;
+		// if need to set comparer without keySelector
+		distinctUntilChanged(_: boolean, comparer: EqualityComparer<T, T>): Enumerable<T>;
+
+		expand(selector: (item: T) => Enumerable<T>): Enumerable<T>;
+
+		startWith(...values: T[]): Enumerable<T>;
+
+		scan<TSeed, TAccumulator>(seed: TSeed, accumulate: (acc: TAccumulator, item: T) => TAccumulator): Enumerable<TAccumulator>;
+		scan(accumulate: (acc: T, item: T) => T): Enumerable<T>;
+
+		takeLast(count: number): Enumerable<T>;
+		skipLast(count: number): Enumerable<T>;
+
+		repeat(count?: number): Enumerable<T>;
+
+		catch(handler: (error: Error) => Enumerable<T>): Enumerable<T>;
+		catchException(handler: (error: Error) => Enumerable<T>): Enumerable<T>;
+		catch(second: Enumerable<T>, ...other: Enumerable<T>[]): Enumerable<T>;
+		catchException(second: Enumerable<T>, ...other: Enumerable<T>[]): Enumerable<T>;
+
+		// todo: Enumerable<Enumerable<T>>.catch(): Enumerable<T>
+		//catch<TInner, T extends Enumerable<TInner>>(): Enumerable<TInner>;
+
+		finally(finallyAction: () => void): Enumerable<T>;
+		finallyDo(finallyAction: () => void): Enumerable<T>;
+
+		onErrorResumeNext<T>(second: Enumerable<T>): Enumerable<T>;
+
+		retry(retryCount?: number): Enumerable<T>;
+
+		
+	}
+
+	export interface EnumerableStatic {
+		throw<T>(error: Error): Enumerable<T>;
+		throwException<T>(error: Error): Enumerable<T>;
+
+		defer<T>(enumerableFactory: () => Enumerable<T>): Enumerable<T>;
+
+		generate<TState, TResult>(
+			initialState: TState,
+			condition: Predicate<TState>,
+			iterate: (state: TState) => TState,
+			resultSelector: (state: TState) => TResult): Enumerable<TResult>;
+
+		using<TResource extends Disposable, T>(
+			resourceFactory: () => TResource,
+			enumerableFactory: (resource: TResource) => Enumerable<T>): Enumerable<T>;
+
+		catch<T>(...sources: Enumerable<T>[]): Enumerable<T>;
+		catchException<T>(...sources: Enumerable<T>[]): Enumerable<T>;
+
+		onErrorResumeNext<T>(...sources: Enumerable<T>[]): Enumerable<T>;
+
+		while<T>(condition: EnumerablePredicate<Enumerable<T>>, source: Enumerable<T>): Enumerable<T>;
+		whileDo<T>(condition: EnumerablePredicate<Enumerable<T>>, source: Enumerable<T>): Enumerable<T>;
+
+		if<T>(condition: () => boolean, thenSource: Enumerable<T>, elseSource?: Enumerable<T>): Enumerable<T>;
+		ifThen<T>(condition: () => boolean, thenSource: Enumerable<T>, elseSource?: Enumerable<T>): Enumerable<T>;
+
+		doWhile<T>(source: Enumerable<T>, condition: EnumerablePredicate<Enumerable<T>>): Enumerable<T>;
+
+		case<T>(selector: () => number, sources: { [key: number]: Enumerable<T>; }, defaultSource?: Enumerable<T>): Enumerable<T>;
+		case<T>(selector: () => string, sources: { [key: string]: Enumerable<T>; }, defaultSource?: Enumerable<T>): Enumerable<T>;
+		switchCase<T>(selector: () => number, sources: { [key: number]: Enumerable<T>; }, defaultSource?: Enumerable<T>): Enumerable<T>;
+		switchCase<T>(selector: () => string, sources: { [key: string]: Enumerable<T>; }, defaultSource?: Enumerable<T>): Enumerable<T>;
+
+		for<T, TResult>(source: Enumerable<T>, resultSelector: EnumerableFunc<T, TResult>): Enumerable<TResult>;
+		forIn<T, TResult>(source: Enumerable<T>, resultSelector: EnumerableFunc<T, TResult>): Enumerable<TResult>;
+	}
+}
\ No newline at end of file

From 338e04943c3fc9434827b7b632116cb2e5f7a3c1 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Fri, 25 Oct 2013 17:23:09 +0400
Subject: [PATCH 04/12] Added file descriptions

---
 ix.js/ix.d.ts  | 4 ++++
 ix.js/l2o.d.ts | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/ix.js/ix.d.ts b/ix.js/ix.d.ts
index 5de2361dd..9ea0ae0c9 100644
--- a/ix.js/ix.d.ts
+++ b/ix.js/ix.d.ts
@@ -1,3 +1,7 @@
+// Type definitions for IxJS 1.0.6 / ix.js
+// Project: https://github.com/Reactive-Extensions/IxJS
+// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
+
 ///<reference path="l2o.d.ts"/>
 
 declare module Ix {
diff --git a/ix.js/l2o.d.ts b/ix.js/l2o.d.ts
index 8177376e1..841116c46 100644
--- a/ix.js/l2o.d.ts
+++ b/ix.js/l2o.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for IxJS 1.0.6
+// Type definitions for IxJS 1.0.6 / l2o.js
 // Project: https://github.com/Reactive-Extensions/IxJS
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
 

From ffee8db898ae959478f523fe79653cfe859ba9cf Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Fri, 25 Oct 2013 17:30:07 +0400
Subject: [PATCH 05/12] Added missed return type for Ix.Disposable.dispose

---
 ix.js/l2o.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ix.js/l2o.d.ts b/ix.js/l2o.d.ts
index 841116c46..035d59234 100644
--- a/ix.js/l2o.d.ts
+++ b/ix.js/l2o.d.ts
@@ -4,7 +4,7 @@
 
 declare module Ix {
 	export interface Disposable {
-		dispose();
+		dispose(): void;
 	}
 
 	export interface Enumerator<T> extends Disposable {

From 0efbf156721aa4e8c8c77a55b603d13f2b15f62e Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Fri, 25 Oct 2013 19:21:41 +0400
Subject: [PATCH 06/12] Fixed formatting

---
 ix.js/ix.d.ts  |   2 -
 ix.js/l2o.d.ts | 414 ++++++++++++++++++++++++-------------------------
 2 files changed, 207 insertions(+), 209 deletions(-)

diff --git a/ix.js/ix.d.ts b/ix.js/ix.d.ts
index 9ea0ae0c9..2a598dde7 100644
--- a/ix.js/ix.d.ts
+++ b/ix.js/ix.d.ts
@@ -74,8 +74,6 @@ declare module Ix {
 		onErrorResumeNext<T>(second: Enumerable<T>): Enumerable<T>;
 
 		retry(retryCount?: number): Enumerable<T>;
-
-		
 	}
 
 	export interface EnumerableStatic {
diff --git a/ix.js/l2o.d.ts b/ix.js/l2o.d.ts
index 035d59234..5a74c6259 100644
--- a/ix.js/l2o.d.ts
+++ b/ix.js/l2o.d.ts
@@ -8,263 +8,263 @@ declare module Ix {
 	}
 
 	export interface Enumerator<T> extends Disposable {
-        moveNext(): boolean;
-        getCurrent(): T;
-    }
+		moveNext(): boolean;
+		getCurrent(): T;
+	}
 
-    export interface EnumeratorStatic {
-        new<T>(moveNext: () => boolean, getCurrent: () => T, dispose: () => void): Enumerator<T>;
-        create<T>(moveNext: () => boolean, getCurrent: () => T, dispose?: () => void): Enumerator<T>;
-    }
+	export interface EnumeratorStatic {
+		new <T>(moveNext: () => boolean, getCurrent: () => T, dispose: () => void): Enumerator<T>;
+		create<T>(moveNext: () => boolean, getCurrent: () => T, dispose?: () => void): Enumerator<T>;
+	}
 
-    var Enumerator: EnumerableStatic;
+	var Enumerator: EnumerableStatic;
 
-    export interface EnumerableFunc<T, TResult> {
-        (item: T, index: number, self: Enumerable<T>): TResult;
-    }
-    export interface EnumerablePredicate<T> extends EnumerableFunc<T, boolean> { }
-    export interface Predicate<T> {
-        (item: T): boolean;
-    }
-    export interface EqualityComparer<T1, T2> {
-        (item1: T1, item2: T2): boolean;
-    }
+	export interface EnumerableFunc<T, TResult> {
+		(item: T, index: number, self: Enumerable<T>): TResult;
+	}
+	export interface EnumerablePredicate<T> extends EnumerableFunc<T, boolean> { }
+	export interface Predicate<T> {
+		(item: T): boolean;
+	}
+	export interface EqualityComparer<T1, T2> {
+		(item1: T1, item2: T2): boolean;
+	}
 
-    export interface Enumerable<T> {
-        // base functions
-        getEnumerator(): Enumerator<T>;
+	export interface Enumerable<T> {
+		// base functions
+		getEnumerator(): Enumerator<T>;
 
-        // "extension" functions
+		// "extension" functions
 
-        aggregate<TAccumulate, TResult>(seed: TAccumulate, func: (accumulate: TAccumulate, current: T, index: number, self: Enumerable<T>) => TAccumulate, resultSelector: (accumulate: TAccumulate) => TResult): TResult;
-        aggregate<TAccumulate>(seed: TAccumulate, func: (accumulate: TAccumulate, current: T, index: number, self: Enumerable<T>) => TAccumulate): TAccumulate;
-        aggregate(func: (accumulate: T, current: T, index: number, self: Enumerable<T>) => T): T;
+		aggregate<TAccumulate, TResult>(seed: TAccumulate, func: (accumulate: TAccumulate, current: T, index: number, self: Enumerable<T>) => TAccumulate, resultSelector: (accumulate: TAccumulate) => TResult): TResult;
+		aggregate<TAccumulate>(seed: TAccumulate, func: (accumulate: TAccumulate, current: T, index: number, self: Enumerable<T>) => TAccumulate): TAccumulate;
+		aggregate(func: (accumulate: T, current: T, index: number, self: Enumerable<T>) => T): T;
 
-        reduce(func: (accumulate: T, current: T, index: number, self: Enumerable<T>) => T): T;
-        reduce<TAccumulate>(func: (accumulate: TAccumulate, current: T, index: number, self: Enumerable<T>) => TAccumulate, seed: TAccumulate): TAccumulate;
+		reduce(func: (accumulate: T, current: T, index: number, self: Enumerable<T>) => T): T;
+		reduce<TAccumulate>(func: (accumulate: TAccumulate, current: T, index: number, self: Enumerable<T>) => TAccumulate, seed: TAccumulate): TAccumulate;
 
-        all(predicate: EnumerablePredicate<T>, thisArg?: any): boolean;
-        every(predicate: EnumerablePredicate<T>, thisArg?: any): boolean; // alias
+		all(predicate: EnumerablePredicate<T>, thisArg?: any): boolean;
+		every(predicate: EnumerablePredicate<T>, thisArg?: any): boolean; // alias
 
-        any(predicate?: EnumerablePredicate<T>, thisArg?: any): boolean;
-        some(predicate?: EnumerablePredicate<T>, thisArg?: any): boolean; // alias
+		any(predicate?: EnumerablePredicate<T>, thisArg?: any): boolean;
+		some(predicate?: EnumerablePredicate<T>, thisArg?: any): boolean; // alias
 
-        average(selector?: EnumerableFunc<T, number>): number;
-        max(selector?: EnumerableFunc<T, number>): number;
-        min(selector?: EnumerableFunc<T, number>): number;
-        sum(selector?: EnumerableFunc<T, number>): number;
+		average(selector?: EnumerableFunc<T, number>): number;
+		max(selector?: EnumerableFunc<T, number>): number;
+		min(selector?: EnumerableFunc<T, number>): number;
+		sum(selector?: EnumerableFunc<T, number>): number;
 
-        concat<T>(...sources: Enumerable<T>[]): Enumerable<T>;
+		concat<T>(...sources: Enumerable<T>[]): Enumerable<T>;
 
-        contains<TValue>(value: TValue, comparer: EqualityComparer<T, TValue>): boolean;
-        contains(value: any): boolean;
+		contains<TValue>(value: TValue, comparer: EqualityComparer<T, TValue>): boolean;
+		contains(value: any): boolean;
 
-        count(predicate?: EnumerablePredicate<T>, thisArg?: any): number;
+		count(predicate?: EnumerablePredicate<T>, thisArg?: any): number;
 
-        defaultIfEmpty(defaultValue: T): Enumerable<T>;
+		defaultIfEmpty(defaultValue: T): Enumerable<T>;
 
-        distinct(comparer?: EqualityComparer<T, T>): Enumerable<T>;
+		distinct(comparer?: EqualityComparer<T, T>): Enumerable<T>;
 
-        elementAt(index: number): T;
-        elementAtOrDefault(index: number): T;
+		elementAt(index: number): T;
+		elementAtOrDefault(index: number): T;
 
-        except(second: Enumerable<T>, comparer?: EqualityComparer<T, T>): Enumerable<T>;
+		except(second: Enumerable<T>, comparer?: EqualityComparer<T, T>): Enumerable<T>;
 
-        first(predicate?: Predicate<T>): T;
-        firstOrDefault(predicate?: Predicate<T>): T;
-        last(predicate?: Predicate<T>): T;
-        lastOrDefault(predicate?: Predicate<T>): T;
-        single(predicate?: Predicate<T>): T;
-        singleOrDefault(predicate?: Predicate<T>): T;
+		first(predicate?: Predicate<T>): T;
+		firstOrDefault(predicate?: Predicate<T>): T;
+		last(predicate?: Predicate<T>): T;
+		lastOrDefault(predicate?: Predicate<T>): T;
+		single(predicate?: Predicate<T>): T;
+		singleOrDefault(predicate?: Predicate<T>): T;
 
-        forEach(action: EnumerableFunc<T, void>, thisArg?: any): void;
+		forEach(action: EnumerableFunc<T, void>, thisArg?: any): void;
 
-        groupBy<TKey, TElement, TResult>(
-            keySelector: (item: T) => TKey,
-            elementSelector: (item: T) => TElement,
-            resultSelector: (key: TKey, values: Enumerable<TElement>) => TResult,
-            comparer?: EqualityComparer<TKey, TKey>): Enumerable<TResult>;
-        groupBy<TKey, TElement>(
-            keySelector: (item: T) => TKey,
-            elementSelector: (item: T) => TElement): Grouping<TKey, TElement>;
-        // spec 3.5.2, waiting for restriction on generative recursion removal
+		groupBy<TKey, TElement, TResult>(
+			keySelector: (item: T) => TKey,
+			elementSelector: (item: T) => TElement,
+			resultSelector: (key: TKey, values: Enumerable<TElement>) => TResult,
+			comparer?: EqualityComparer<TKey, TKey>): Enumerable<TResult>;
+		groupBy<TKey, TElement>(
+			keySelector: (item: T) => TKey,
+			elementSelector: (item: T) => TElement): Grouping<TKey, TElement>;
+		// spec 3.5.2, waiting for restriction on generative recursion removal
 		/*groupBy<TKey>(
-            keySelector: (item: T) => TKey): Grouping<TKey, T>;*/
-        groupBy<TKey, _T extends T>(
-            keySelector: (item: T) => TKey): Grouping<TKey, _T>;
+			keySelector: (item: T) => TKey): Grouping<TKey, T>;*/
+		groupBy<TKey, _T extends T>(
+			keySelector: (item: T) => TKey): Grouping<TKey, _T>;
 
-        // if need to set comparer without resultSelector
-        groupBy<TKey, TElement>(
-            keySelector: (item: T) => TKey,
-            elementSelector: (item: T) => TElement,
-            _: boolean,
-            comparer: EqualityComparer<TKey, TKey>): Grouping<TKey, TElement>;
-        // if need to set resultSelector without elementSelector
-        groupBy<TKey, TResult>(
-            keySelector: (item: T) => TKey,
-            _: boolean,
-            resultSelector: (key: TKey, values: Enumerable<T>) => TResult,
-            comparer?: EqualityComparer<TKey, TKey>): Enumerable<TResult>;
-        // if need to set comparer without elementSelector and resultSelector
-        // spec 3.5.2, waiting for restriction on generative recursion removal
+		// if need to set comparer without resultSelector
+		groupBy<TKey, TElement>(
+			keySelector: (item: T) => TKey,
+			elementSelector: (item: T) => TElement,
+			_: boolean,
+			comparer: EqualityComparer<TKey, TKey>): Grouping<TKey, TElement>;
+		// if need to set resultSelector without elementSelector
+		groupBy<TKey, TResult>(
+			keySelector: (item: T) => TKey,
+			_: boolean,
+			resultSelector: (key: TKey, values: Enumerable<T>) => TResult,
+			comparer?: EqualityComparer<TKey, TKey>): Enumerable<TResult>;
+		// if need to set comparer without elementSelector and resultSelector
+		// spec 3.5.2, waiting for restriction on generative recursion removal
 		/*groupBy<TKey>(
-            keySelector: (item: T) => TKey,
-            _: boolean,
-            __: boolean,
-            comparer: EqualityComparer<TKey, TKey>): Grouping<TKey, T>;*/
-        groupBy<TKey, _T extends T>(
-            keySelector: (item: T) => TKey,
-            _: boolean,
-            __: boolean,
-            comparer: EqualityComparer<TKey, TKey>): Grouping<TKey, _T>;
+			keySelector: (item: T) => TKey,
+			_: boolean,
+			__: boolean,
+			comparer: EqualityComparer<TKey, TKey>): Grouping<TKey, T>;*/
+		groupBy<TKey, _T extends T>(
+			keySelector: (item: T) => TKey,
+			_: boolean,
+			__: boolean,
+			comparer: EqualityComparer<TKey, TKey>): Grouping<TKey, _T>;
 
-        groupJoin<TInner, TOuterKey, TInnerKey, TResult>(
-            inner: Enumerable<TInner>,
-            outerKeySelector: (item: T) => TOuterKey,
-            innerKeySelector: (item: TInner) => TInnerKey,
-            resultSelector: (outer: T, innerSequence: Enumerable<TInner>) => TResult,
-            comparer: EqualityComparer<TOuterKey, TInnerKey>): Enumerable<TResult>;
-        groupJoin<TInner, TKey, TResult>(
-            inner: Enumerable<TInner>,
-            outerKeySelector: (item: T) => TKey,
-            innerKeySelector: (item: TInner) => TKey,
-            resultSelector: (outer: T, innerSequence: Enumerable<TInner>) => TResult): Enumerable<TResult>;
+		groupJoin<TInner, TOuterKey, TInnerKey, TResult>(
+			inner: Enumerable<TInner>,
+			outerKeySelector: (item: T) => TOuterKey,
+			innerKeySelector: (item: TInner) => TInnerKey,
+			resultSelector: (outer: T, innerSequence: Enumerable<TInner>) => TResult,
+			comparer: EqualityComparer<TOuterKey, TInnerKey>): Enumerable<TResult>;
+		groupJoin<TInner, TKey, TResult>(
+			inner: Enumerable<TInner>,
+			outerKeySelector: (item: T) => TKey,
+			innerKeySelector: (item: TInner) => TKey,
+			resultSelector: (outer: T, innerSequence: Enumerable<TInner>) => TResult): Enumerable<TResult>;
 
-        join<TInner, TOuterKey, TInnerKey, TResult>(
-            inner: Enumerable<TInner>,
-            outerKeySelector: (item: T) => TOuterKey,
-            innerKeySelector: (item: TInner) => TInnerKey,
-            resultSelector: (outer: T, inner: TInner) => TResult,
-            comparer: EqualityComparer<TOuterKey, TInnerKey>): Enumerable<TResult>;
-        join<TInner, TKey, TResult>(
-            inner: Enumerable<TInner>,
-            outerKeySelector: (item: T) => TKey,
-            innerKeySelector: (item: TInner) => TKey,
-            resultSelector: (outer: T, inner: TInner) => TResult): Enumerable<TResult>;
+		join<TInner, TOuterKey, TInnerKey, TResult>(
+			inner: Enumerable<TInner>,
+			outerKeySelector: (item: T) => TOuterKey,
+			innerKeySelector: (item: TInner) => TInnerKey,
+			resultSelector: (outer: T, inner: TInner) => TResult,
+			comparer: EqualityComparer<TOuterKey, TInnerKey>): Enumerable<TResult>;
+		join<TInner, TKey, TResult>(
+			inner: Enumerable<TInner>,
+			outerKeySelector: (item: T) => TKey,
+			innerKeySelector: (item: TInner) => TKey,
+			resultSelector: (outer: T, inner: TInner) => TResult): Enumerable<TResult>;
 
-        intersect<TSecond>(second: Enumerable<TSecond>, comparer: EqualityComparer<T, TSecond>): Enumerable<T>;
-        intersect(second: Enumerable<T>): Enumerable<T>;
-        union(second: Enumerable<T>, comparer?: EqualityComparer<T, T>): Enumerable<T>;
+		intersect<TSecond>(second: Enumerable<TSecond>, comparer: EqualityComparer<T, TSecond>): Enumerable<T>;
+		intersect(second: Enumerable<T>): Enumerable<T>;
+		union(second: Enumerable<T>, comparer?: EqualityComparer<T, T>): Enumerable<T>;
 
-        orderBy<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): OrderedEnumerable<T>;
-        orderByDescending<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): OrderedEnumerable<T>;
+		orderBy<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): OrderedEnumerable<T>;
+		orderByDescending<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): OrderedEnumerable<T>;
 
-        reverse(): Enumerable<T>;
+		reverse(): Enumerable<T>;
 
-        select<TResult>(selector: EnumerableFunc<T, TResult>, thisArg?: any): Enumerable<TResult>;
-        map<TResult>(selector: EnumerableFunc<T, TResult>, thisArg?: any): Enumerable<TResult>;
+		select<TResult>(selector: EnumerableFunc<T, TResult>, thisArg?: any): Enumerable<TResult>;
+		map<TResult>(selector: EnumerableFunc<T, TResult>, thisArg?: any): Enumerable<TResult>;
 
-        selectMany<TCollection, TResult>(collectionSelector: (item: T, index: number) => Enumerable<TCollection>,
-            resultSelector: (outer: T, inner: TCollection) => TResult): Enumerable<TResult>;
-        selectMany<TCollection>(collectionSelector: (item: T, index: number) => Enumerable<TCollection>): Enumerable<TCollection>;
+		selectMany<TCollection, TResult>(collectionSelector: (item: T, index: number) => Enumerable<TCollection>,
+			resultSelector: (outer: T, inner: TCollection) => TResult): Enumerable<TResult>;
+		selectMany<TCollection>(collectionSelector: (item: T, index: number) => Enumerable<TCollection>): Enumerable<TCollection>;
 
-        sequenceEqual<TSecond>(second: Enumerable<TSecond>, comparer: EqualityComparer<T, TSecond>): boolean;
-        sequenceEqual(second: Enumerable<T>): boolean;
+		sequenceEqual<TSecond>(second: Enumerable<TSecond>, comparer: EqualityComparer<T, TSecond>): boolean;
+		sequenceEqual(second: Enumerable<T>): boolean;
 
-        skip(count: number): Enumerable<T>;
-        skipWhile(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
-        take(count: number): Enumerable<T>;
-        takeWhile(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
+		skip(count: number): Enumerable<T>;
+		skipWhile(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
+		take(count: number): Enumerable<T>;
+		takeWhile(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
 
-        toArray(): T[];
+		toArray(): T[];
 
-        toDictionary<TKey, TValue>(
-            keySelector: (item: T) => TKey,
-            elementSelector: (item: T) => TValue,
-            comparer?: EqualityComparer<TKey, TKey>): Dictionary<TKey, TValue>;
-        // spec 3.5.2, waiting for restriction on generative recursion removal
+		toDictionary<TKey, TValue>(
+			keySelector: (item: T) => TKey,
+			elementSelector: (item: T) => TValue,
+			comparer?: EqualityComparer<TKey, TKey>): Dictionary<TKey, TValue>;
+		// spec 3.5.2, waiting for restriction on generative recursion removal
 		/*toDictionary<TKey>(
-            keySelector: (item: T) => TKey): Dictionary<TKey, T>;*/
-        toDictionary<TKey, _T extends T>(
-            keySelector: (item: T) => TKey): Dictionary<TKey, _T>;
-        // if need to set comparer without elementSelector
-        // spec 3.5.2, waiting for restriction on generative recursion removal
+			keySelector: (item: T) => TKey): Dictionary<TKey, T>;*/
+		toDictionary<TKey, _T extends T>(
+			keySelector: (item: T) => TKey): Dictionary<TKey, _T>;
+		// if need to set comparer without elementSelector
+		// spec 3.5.2, waiting for restriction on generative recursion removal
 		/*toDictionary<TKey>(
-            keySelector: (item: T) => TKey,
-            _: boolean,
-            comparer: EqualityComparer<TKey, TKey>): Dictionary<TKey, T>;*/
-        toDictionary<TKey, _T extends T>(
-            keySelector: (item: T) => TKey,
-            _: boolean,
-            comparer: EqualityComparer<TKey, TKey>): Dictionary<TKey, _T>;
+			keySelector: (item: T) => TKey,
+			_: boolean,
+			comparer: EqualityComparer<TKey, TKey>): Dictionary<TKey, T>;*/
+		toDictionary<TKey, _T extends T>(
+			keySelector: (item: T) => TKey,
+			_: boolean,
+			comparer: EqualityComparer<TKey, TKey>): Dictionary<TKey, _T>;
 
-        toLookup<TKey, TValue>(
-            keySelector: (item: T) => TKey,
-            elementSelector: (item: T) => TValue,
-            comparer?: EqualityComparer<TKey, TKey>): Lookup<TKey, TValue>;
-        // spec 3.5.2, waiting for restriction on generative recursion removal
+		toLookup<TKey, TValue>(
+			keySelector: (item: T) => TKey,
+			elementSelector: (item: T) => TValue,
+			comparer?: EqualityComparer<TKey, TKey>): Lookup<TKey, TValue>;
+		// spec 3.5.2, waiting for restriction on generative recursion removal
 		/*toLookup<TKey>(
-            keySelector: (item: T) => TKey): Lookup<TKey, T>;*/
-        toLookup<TKey, _T extends T>(
-            keySelector: (item: T) => TKey): Lookup<TKey, _T>;
-        // if need to set comparer without elementSelector
-        // spec 3.5.2, waiting for restriction on generative recursion removal
+			keySelector: (item: T) => TKey): Lookup<TKey, T>;*/
+		toLookup<TKey, _T extends T>(
+			keySelector: (item: T) => TKey): Lookup<TKey, _T>;
+		// if need to set comparer without elementSelector
+		// spec 3.5.2, waiting for restriction on generative recursion removal
 		/*toLookup<TKey>(
-            keySelector: (item: T) => TKey,
-            _: boolean,
-            comparer: EqualityComparer<TKey, TKey>): Lookup<TKey, T>;*/
-        toLookup<TKey, _T extends T>(
-            keySelector: (item: T) => TKey,
-            _: boolean,
-            comparer: EqualityComparer<TKey, TKey>): Lookup<TKey, _T>;
+			keySelector: (item: T) => TKey,
+			_: boolean,
+			comparer: EqualityComparer<TKey, TKey>): Lookup<TKey, T>;*/
+		toLookup<TKey, _T extends T>(
+			keySelector: (item: T) => TKey,
+			_: boolean,
+			comparer: EqualityComparer<TKey, TKey>): Lookup<TKey, _T>;
 
-        where(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
-        filter(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
+		where(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
+		filter(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
 
-        zip<TRight, TResult>(right: Enumerable<TRight>, selector: (left: T, right: TRight) => TResult): Enumerable<TResult>;
-    }
+		zip<TRight, TResult>(right: Enumerable<TRight>, selector: (left: T, right: TRight) => TResult): Enumerable<TResult>;
+	}
 
-    export interface Grouping<TKey, T> extends Enumerable<T> {
-        key: TKey;
-    }
+	export interface Grouping<TKey, T> extends Enumerable<T> {
+		key: TKey;
+	}
 
-    export interface OrderedEnumerable<T> extends Enumerable<T> {
-        thenBy<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): OrderedEnumerable<T>;
-        thenByDescending<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): OrderedEnumerable<T>;
-    }
+	export interface OrderedEnumerable<T> extends Enumerable<T> {
+		thenBy<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): OrderedEnumerable<T>;
+		thenByDescending<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): OrderedEnumerable<T>;
+	}
 
-    class Dictionary<TKey, TValue> {
-        constructor(capacity, comparer?: EqualityComparer<TKey, TKey>);
+	class Dictionary<TKey, TValue> {
+		constructor(capacity, comparer?: EqualityComparer<TKey, TKey>);
 
-        toEnumerable(): Enumerable<KeyValuePair<TKey, TValue>>;
+		toEnumerable(): Enumerable<KeyValuePair<TKey, TValue>>;
 
-        add(key: TKey, value: TValue): void;
-        remove(key: TKey): boolean;
-        clear(): void;
-        length(): number;
-        tryGetValue(key: TKey): TValue;
-        get(key: TKey): TValue;
-        set(key: TKey, value: TValue): void;
-        getValues(): TValue[];
-        has(key: TKey): boolean;
-    }
+		add(key: TKey, value: TValue): void;
+		remove(key: TKey): boolean;
+		clear(): void;
+		length(): number;
+		tryGetValue(key: TKey): TValue;
+		get(key: TKey): TValue;
+		set(key: TKey, value: TValue): void;
+		getValues(): TValue[];
+		has(key: TKey): boolean;
+	}
 
-    export interface KeyValuePair<TKey, TValue> {
-        key: TKey;
-        value: TValue;
-    }
+	export interface KeyValuePair<TKey, TValue> {
+		key: TKey;
+		value: TValue;
+	}
 
-    export interface Lookup<TKey, TValue> {
-        toEnumerable(): Enumerable<Grouping<TKey, any>>;
-        has(key: TKey): boolean;
-        length(): number;
-        get(key: TKey): Enumerable<TValue>;
-    }
+	export interface Lookup<TKey, TValue> {
+		toEnumerable(): Enumerable<Grouping<TKey, any>>;
+		has(key: TKey): boolean;
+		length(): number;
+		get(key: TKey): Enumerable<TValue>;
+	}
 
-    export interface EnumerableStatic {
-        new <T>(getEnumerator: () => Enumerator<T>): Enumerable<T>;
-        create<T>(getEnumerator: () => Enumerator<T>): Enumerable<T>;
+	export interface EnumerableStatic {
+		new <T>(getEnumerator: () => Enumerator<T>): Enumerable<T>;
+		create<T>(getEnumerator: () => Enumerator<T>): Enumerable<T>;
 
-        concat<T>(...sources: Enumerable<T>[]): Enumerable<T>;
-        empty<T>(): Enumerable<T>;
-        fromArray<T>(array: T[]): Enumerable<T>;
-        returnValue<T>(value: T): Enumerable<T>;
-        range(start: number, count: number): Enumerable<number>;
-        repeat<T>(value: T, repeatCount?: number): Enumerable<T>;
+		concat<T>(...sources: Enumerable<T>[]): Enumerable<T>;
+		empty<T>(): Enumerable<T>;
+		fromArray<T>(array: T[]): Enumerable<T>;
+		returnValue<T>(value: T): Enumerable<T>;
+		range(start: number, count: number): Enumerable<number>;
+		repeat<T>(value: T, repeatCount?: number): Enumerable<T>;
 
-        sequenceEqual<TFirst, TSecond>(first: Enumerable<TFirst>, second: Enumerable<TSecond>, comparer: EqualityComparer<TFirst, TSecond>): boolean;
-        sequenceEqual<T>(first: Enumerable<T>, second: Enumerable<T>): boolean;
-    }
+		sequenceEqual<TFirst, TSecond>(first: Enumerable<TFirst>, second: Enumerable<TSecond>, comparer: EqualityComparer<TFirst, TSecond>): boolean;
+		sequenceEqual<T>(first: Enumerable<T>, second: Enumerable<T>): boolean;
+	}
 
-    var Enumerable: EnumerableStatic;
+	var Enumerable: EnumerableStatic;
 }
\ No newline at end of file

From 0963cde2eec119b8d48f87ad37af294eca0f1eb8 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Sat, 26 Oct 2013 14:39:04 +0400
Subject: [PATCH 07/12] Fixed several bugs in l2o.d.ts

- fixed Enumerator variable type
- added Comparer interface
- added return alias for returnValue
- minor fixes
---
 ix.js/l2o.d.ts | 29 +++++++++++++++++------------
 1 file changed, 17 insertions(+), 12 deletions(-)

diff --git a/ix.js/l2o.d.ts b/ix.js/l2o.d.ts
index 5a74c6259..44a5efda4 100644
--- a/ix.js/l2o.d.ts
+++ b/ix.js/l2o.d.ts
@@ -17,7 +17,7 @@ declare module Ix {
 		create<T>(moveNext: () => boolean, getCurrent: () => T, dispose?: () => void): Enumerator<T>;
 	}
 
-	var Enumerator: EnumerableStatic;
+	var Enumerator: EnumeratorStatic;
 
 	export interface EnumerableFunc<T, TResult> {
 		(item: T, index: number, self: Enumerable<T>): TResult;
@@ -26,8 +26,11 @@ declare module Ix {
 	export interface Predicate<T> {
 		(item: T): boolean;
 	}
-	export interface EqualityComparer<T1, T2> {
-		(item1: T1, item2: T2): boolean;
+	export interface EqualityComparer<TFirst, TSecond> {
+		(item1: TFirst, item2: TSecond): boolean;
+	}
+	export interface Comparer<TFirst, TSecond> {
+		(item1: TFirst, item2: TSecond): number;
 	}
 
 	export interface Enumerable<T> {
@@ -57,18 +60,19 @@ declare module Ix {
 		concat<T>(...sources: Enumerable<T>[]): Enumerable<T>;
 
 		contains<TValue>(value: TValue, comparer: EqualityComparer<T, TValue>): boolean;
-		contains(value: any): boolean;
+		contains(value: T): boolean;
 
 		count(predicate?: EnumerablePredicate<T>, thisArg?: any): number;
 
-		defaultIfEmpty(defaultValue: T): Enumerable<T>;
+		defaultIfEmpty(defaultValue?: T): Enumerable<T>;
 
 		distinct(comparer?: EqualityComparer<T, T>): Enumerable<T>;
 
 		elementAt(index: number): T;
 		elementAtOrDefault(index: number): T;
 
-		except(second: Enumerable<T>, comparer?: EqualityComparer<T, T>): Enumerable<T>;
+		except<TOther>(second: Enumerable<TOther>, comparer: EqualityComparer<T, TOther>): Enumerable<T>;
+		except(second: Enumerable<T>): Enumerable<T>;
 
 		first(predicate?: Predicate<T>): T;
 		firstOrDefault(predicate?: Predicate<T>): T;
@@ -146,8 +150,8 @@ declare module Ix {
 		intersect(second: Enumerable<T>): Enumerable<T>;
 		union(second: Enumerable<T>, comparer?: EqualityComparer<T, T>): Enumerable<T>;
 
-		orderBy<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): OrderedEnumerable<T>;
-		orderByDescending<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): OrderedEnumerable<T>;
+		orderBy<TKey>(keySelector: (item: T) => TKey, comparer?: Comparer<TKey, TKey>): OrderedEnumerable<T>;
+		orderByDescending<TKey>(keySelector: (item: T) => TKey, comparer?: Comparer<TKey, TKey>): OrderedEnumerable<T>;
 
 		reverse(): Enumerable<T>;
 
@@ -219,12 +223,12 @@ declare module Ix {
 	}
 
 	export interface OrderedEnumerable<T> extends Enumerable<T> {
-		thenBy<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): OrderedEnumerable<T>;
-		thenByDescending<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): OrderedEnumerable<T>;
+		thenBy<TKey>(keySelector: (item: T) => TKey, comparer?: Comparer<TKey, TKey>): OrderedEnumerable<T>;
+		thenByDescending<TKey>(keySelector: (item: T) => TKey, comparer?: Comparer<TKey, TKey>): OrderedEnumerable<T>;
 	}
 
 	class Dictionary<TKey, TValue> {
-		constructor(capacity, comparer?: EqualityComparer<TKey, TKey>);
+		constructor(capacity?: number, comparer?: EqualityComparer<TKey, TKey>);
 
 		toEnumerable(): Enumerable<KeyValuePair<TKey, TValue>>;
 
@@ -258,7 +262,8 @@ declare module Ix {
 		concat<T>(...sources: Enumerable<T>[]): Enumerable<T>;
 		empty<T>(): Enumerable<T>;
 		fromArray<T>(array: T[]): Enumerable<T>;
-		returnValue<T>(value: T): Enumerable<T>;
+		return<T>(value: T): Enumerable<T>;
+		returnValue<T>(value: T): Enumerable<T>;	// alias for <IE9
 		range(start: number, count: number): Enumerable<number>;
 		repeat<T>(value: T, repeatCount?: number): Enumerable<T>;
 

From 6dd6462da3c71ec409a48e5ae33813b2fb3de4c0 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Sat, 26 Oct 2013 14:39:55 +0400
Subject: [PATCH 08/12] Added tests for l2o.d.ts

Tests for all functions defined in Enumerable and EnumerableStatic
---
 ix.js/l2o-tests.ts | 160 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 160 insertions(+)
 create mode 100644 ix.js/l2o-tests.ts

diff --git a/ix.js/l2o-tests.ts b/ix.js/l2o-tests.ts
new file mode 100644
index 000000000..4be2974b3
--- /dev/null
+++ b/ix.js/l2o-tests.ts
@@ -0,0 +1,160 @@
+///<reference path="l2o.d.ts"/>
+
+var ec_ns = (a: number, b: string) => a.toString() == b;	//equality comparer on number,string
+var ec_nn = (a: number, b: number) => a === b;				//equality comparer on number,number
+var c_nn = (a: number, b: number) => a - b;					//comparer on number,number
+
+// static
+
+var ax = Ix.Enumerable.fromArray([0, 2, 7, 3, 4, 5]);
+
+var bx = Ix.Enumerable.create(() => {
+	var current = ".";
+	return Ix.Enumerator.create(
+		() => { current += "."; return true; },
+		() => current,
+		() => { });
+});
+
+Ix.Enumerator.create(() => true, () => 1);	// without dispose method
+
+var cx = Ix.Enumerable.empty<number>();
+
+var dx = Ix.Enumerable.concat(ax, cx);
+
+var ex = Ix.Enumerable.return(42);
+var fx = Ix.Enumerable.returnValue("42");
+
+var gx = Ix.Enumerable.range(-100, 200);
+
+Ix.Enumerable.repeat(42, 42);
+Ix.Enumerable.repeat(42);		// infinite
+
+Ix.Enumerable.sequenceEqual(ax, fx, ec_ns);
+Ix.Enumerable.sequenceEqual(ax, ex);	// default comparer on same type
+
+// instance
+
+ax.getEnumerator();
+
+ax.aggregate("", (acc, i) => acc + i, acc=> acc.length);
+ax.aggregate("", (acc, i) => acc + i);
+ax.aggregate((acc, i) => acc + i);
+
+ax.reduce((acc, i) => acc + i, 100);
+ax.reduce((acc, i) => acc + i);
+
+ax.all(item => true);
+ax.all(item => true, bx);
+ax.every(item => true);
+ax.every(item => true, bx);
+
+ax.any();
+ax.any(item => true);
+ax.any(item => true, bx);
+ax.some();
+ax.some(item => true);
+ax.some(item => true, bx);
+
+ax.average();
+bx.average(item => item.length);
+ax.min();
+bx.min(item => item.length);
+ax.max();
+bx.max(item => item.length);
+ax.sum();
+bx.sum(item => item.length);
+
+ax.concat(ax, cx, dx, ex, gx);
+
+ax.contains(10);
+ax.contains("10", ec_ns);
+
+ax.count();
+ax.count(item=>false);
+ax.count(item=> false, {});
+
+cx.defaultIfEmpty();
+cx.defaultIfEmpty(10);
+
+dx.distinct();
+dx.distinct((d1, d2) => d1 === d2);
+
+ax.elementAt(2);
+ax.elementAtOrDefault(2);
+
+//ax.except(bx, ec_ns);	// bug https://typescript.codeplex.com/workitem/1841
+bx.except(fx);
+
+ax.first();
+ax.firstOrDefault();
+ax.last();
+ax.lastOrDefault();
+ax.single();
+ax.singleOrDefault();
+
+ax.forEach(a => console.log(a));
+ax.forEach(a => console.log(a), cx);
+
+bx.groupBy<number, string>(b => b.length);
+bx.groupBy(b => b.length, b => "[" + b + "]");
+bx.groupBy(b => b.length, b => "[" + b + "]", (l, values) => l + values.count());
+bx.groupBy(b => b.length, false, (l, values) => l + values.count());
+bx.groupBy(b => b.length, b => "[" + b + "]", (l, values) => l + values.count(), ec_nn);
+bx.groupBy(b => b.length, b => "[" + b + "]", false, (x, y) => x == y);
+bx.groupBy(b => b.length, false, (l, values) => l + values.count(), ec_nn);
+bx.groupBy<number, number>(b => b.length, false, false, ec_nn);
+
+ax.groupJoin(bx, a => a, b => b, (a, b) => [a, b], ec_ns);
+ax.groupJoin(bx, a => a, b => b.length, (a, b) => [a, b]);
+
+ax.join(bx, a => a, b => b, (a, b) => [a, b], ec_ns);
+ax.join(bx, a => a, b => b.length, (a, b) => [a, b]);
+
+//ax.intersect(bx, ec_ns);	// bug https://typescript.codeplex.com/workitem/1841
+ax.intersect(cx);
+ax.union(cx);
+
+ax.orderBy(a=> -a).thenBy(a => a);
+ax.orderBy(a=> -a, c_nn).thenBy(a => a, c_nn);
+ax.orderByDescending(a=> -a).thenByDescending(a => a);
+ax.orderByDescending(a=> -a, c_nn).thenByDescending(a => a, c_nn);
+
+ax.reverse();
+
+ax.select(a=> a.toString());
+ax.select(a=> a.toString(), {});
+ax.map(a=> a.toString());
+ax.map(a=> a.toString(), {});
+
+ax.selectMany(a=> bx);
+ax.selectMany(a=> bx, (a, b) => [a, b]);
+
+ax.sequenceEqual(fx, ec_ns);
+ax.sequenceEqual(ax, ec_nn);
+ax.sequenceEqual(cx);
+
+ax.skip(10);
+ax.skipWhile(a => a > 10);
+ax.take(10);
+ax.takeWhile(a => a > 10);
+
+ax.toArray();
+
+bx.toDictionary(b => b.length, b => 10, ec_nn);
+bx.toDictionary<number, string>(b => b.length, false, ec_nn);
+bx.toDictionary(b => b.length, b => 10);
+bx.toDictionary<number, string>(b => b.length);
+
+bx.toLookup(b => b.length, b => 10, ec_nn);
+bx.toLookup<number, string>(b => b.length, false, ec_nn);
+bx.toLookup(b => b.length, b => 10);
+bx.toLookup<number, string>(b => b.length);
+
+ax.where(a=> a > 10, {});
+ax.where(a=> a > 10);
+ax.filter(a=> a > 10, {});
+ax.filter(a=> a > 10);
+
+ax.zip(bx, (a: number, b: string) => [a, b]);
+ax.zip(bx, (a, b) => [a, b]);

From 019e4dd6670790793f2ca721f61ba4923e61bf2d Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Sat, 26 Oct 2013 14:56:18 +0400
Subject: [PATCH 09/12] Removed Comparer from ix.d.ts (alreadu defined in
 l2o.d.ts)

---
 ix.js/ix.d.ts | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/ix.js/ix.d.ts b/ix.js/ix.d.ts
index 2a598dde7..d138b007d 100644
--- a/ix.js/ix.d.ts
+++ b/ix.js/ix.d.ts
@@ -6,10 +6,6 @@
 
 declare module Ix {
 
-	export interface Comparer<T1, T2> {
-		(item1: T1, item2: T2): number;
-	}
-
 	export interface Observer<T> {
 		onNext? (value: T): void;
 		onError? (error: Error): void;
@@ -113,4 +109,4 @@ declare module Ix {
 		for<T, TResult>(source: Enumerable<T>, resultSelector: EnumerableFunc<T, TResult>): Enumerable<TResult>;
 		forIn<T, TResult>(source: Enumerable<T>, resultSelector: EnumerableFunc<T, TResult>): Enumerable<TResult>;
 	}
-}
\ No newline at end of file
+}

From af0f9c4bf5af0178be1b881b97f81351c3545560 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Sat, 26 Oct 2013 14:58:43 +0400
Subject: [PATCH 10/12] Added tests for ix.d.ts

Tested all functions defined in ix.d.ts in EnumerableStatic
---
 ix.js/ix-tests.ts | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 ix.js/ix-tests.ts

diff --git a/ix.js/ix-tests.ts b/ix.js/ix-tests.ts
new file mode 100644
index 000000000..dc44f1589
--- /dev/null
+++ b/ix.js/ix-tests.ts
@@ -0,0 +1,46 @@
+///<reference path="ix.d.ts"/>
+
+var ec_ns = (a: number, b: string) => a.toString() == b;	//equality comparer on number,string
+var ec_nn = (a: number, b: number) => a === b;				//equality comparer on number,number
+var c_nn = (a: number, b: number) => a - b;					//comparer on number,number
+
+// static
+
+Ix.Enumerable.throw(new Error("error"));
+Ix.Enumerable.throwException(new Error("error"));
+
+var ax = Ix.Enumerable.generate(-100, a => a < 100, a=> a + 10, a=> a * 2);
+
+Ix.Enumerable.defer(() => ax);
+
+Ix.Enumerable.using(() => ax.getEnumerator(), e => Ix.Enumerable.return(e.getCurrent()));
+
+Ix.Enumerable.catch(ax, ax, ax);
+Ix.Enumerable.catchException(ax, ax, ax);
+Ix.Enumerable.catch<string>();
+Ix.Enumerable.catchException<string>();
+
+Ix.Enumerable.onErrorResumeNext(ax, ax, ax);
+Ix.Enumerable.onErrorResumeNext<string>();
+
+Ix.Enumerable.while(x => x.count() > 0, ax);
+Ix.Enumerable.whileDo(x => x.count() > 0, ax);
+
+Ix.Enumerable.if(() => true, ax, ax);
+Ix.Enumerable.ifThen(() => true, ax, ax);
+Ix.Enumerable.if(() => true, ax);
+Ix.Enumerable.ifThen(() => true, ax);
+
+Ix.Enumerable.doWhile(ax, x => x.count() > 0);
+
+Ix.Enumerable.case(() => 42, { 42: ax }, ax);
+Ix.Enumerable.switchCase(() => 42, { 42: ax }, ax);
+Ix.Enumerable.case(() => 42, { 42: ax });
+Ix.Enumerable.switchCase(() => 42, { 42: ax });
+Ix.Enumerable.case(() => "42", { "42": ax }, ax);
+Ix.Enumerable.switchCase(() => "42", { "42": ax }, ax);
+Ix.Enumerable.case(() => "42", { "42": ax });
+Ix.Enumerable.switchCase(() => "42", { "42": ax });
+
+Ix.Enumerable.for(ax, a => ax);
+Ix.Enumerable.forIn(ax, a => ax);

From 2b99487a28219716fd7fa8a20b04fe664d5a4be7 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Sat, 26 Oct 2013 16:24:49 +0400
Subject: [PATCH 11/12] Added tests for ix.d.ts

- added tests of all functions defined in ix.d.ts Enumerable
- minor fix in ix.d.ts
---
 ix.js/ix-tests.ts | 70 +++++++++++++++++++++++++++++++++++++++++++++++
 ix.js/ix.d.ts     |  2 +-
 2 files changed, 71 insertions(+), 1 deletion(-)

diff --git a/ix.js/ix-tests.ts b/ix.js/ix-tests.ts
index dc44f1589..6953621ca 100644
--- a/ix.js/ix-tests.ts
+++ b/ix.js/ix-tests.ts
@@ -1,6 +1,7 @@
 ///<reference path="ix.d.ts"/>
 
 var ec_ns = (a: number, b: string) => a.toString() == b;	//equality comparer on number,string
+var ec_ss = (a: string, b: string) => a == b;				//equality comparer on string,string
 var ec_nn = (a: number, b: number) => a === b;				//equality comparer on number,number
 var c_nn = (a: number, b: number) => a - b;					//comparer on number,number
 
@@ -44,3 +45,72 @@ Ix.Enumerable.switchCase(() => "42", { "42": ax });
 
 Ix.Enumerable.for(ax, a => ax);
 Ix.Enumerable.forIn(ax, a => ax);
+
+// instance
+
+var bx: Ix.Enumerable<string>;
+
+ax.isEmpty();
+
+bx.minBy(b => b.length, c_nn);
+bx.minBy(b => b.length);
+bx.maxBy(b => b.length, c_nn);
+bx.maxBy(b => b.length);
+
+ax.share(ax => bx);
+ax.share();
+
+ax.publish(ax => bx);
+ax.publish();
+
+ax.memoize();
+
+ax.do({ onNext: (a: number) => console.log(a), onError: err => console.log(err), onCompleted: () => console.log("completed") });
+ax.do(a => console.log(a), err => console.log(err), () => console.log("completed"));
+ax.do(a => console.log(a), err => console.log(err));
+ax.do((a: number) => console.log(a));
+ax.doAction({ onNext: (a: number) => console.log(a), onError: err => console.log(err), onCompleted: () => console.log("completed") });
+ax.doAction(a => console.log(a), err => console.log(err), () => console.log("completed"));
+ax.doAction(a => console.log(a), err => console.log(err));
+ax.doAction((a: number) => console.log(a));
+
+ax.bufferWithCount(10, 20);
+ax.bufferWithCount(10);
+
+ax.ignoreElements();
+
+bx.distinctBy(b => b.length, ec_nn);
+bx.distinctBy(b => b.length);
+
+bx.distinctUntilChanged(b => b.length, ec_nn);
+bx.distinctUntilChanged(b => b.length);
+bx.distinctUntilChanged();
+bx.distinctUntilChanged(false, ec_ss);
+
+ax.expand(a => ax);
+
+ax.startWith(10, 20);
+
+ax.scan(0, (acc, a) => acc + a);
+ax.scan((acc, a) => acc + a);
+
+ax.takeLast(10);
+ax.skipLast(10);
+
+ax.repeat(10);
+ax.repeat();
+
+ax.catch(ax, ax, ax);
+ax.catchException(ax, ax, ax);
+ax.catch(ax);
+ax.catchException(ax);
+ax.catch(err => ax);
+ax.catchException(err => ax);
+
+ax.finally(() => { });
+ax.finallyDo(() => { });
+
+ax.onErrorResumeNext(ax);
+
+ax.retry(10);
+ax.retry();
diff --git a/ix.js/ix.d.ts b/ix.js/ix.d.ts
index d138b007d..614a950fb 100644
--- a/ix.js/ix.d.ts
+++ b/ix.js/ix.d.ts
@@ -67,7 +67,7 @@ declare module Ix {
 		finally(finallyAction: () => void): Enumerable<T>;
 		finallyDo(finallyAction: () => void): Enumerable<T>;
 
-		onErrorResumeNext<T>(second: Enumerable<T>): Enumerable<T>;
+		onErrorResumeNext(second: Enumerable<T>): Enumerable<T>;
 
 		retry(retryCount?: number): Enumerable<T>;
 	}

From 68427a3c830d6197c8c526745021031e902265c1 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Sat, 26 Oct 2013 17:10:50 +0400
Subject: [PATCH 12/12] Added tests for Disposable, Enumerator, Dictionary,
 Lookup

- added tests for all functions defined in l2o.d.ts in Disposable,
Enumerator, Dictionary, Lookup
- removed workaround definitions for spec#3.5.2 (it produced more
problems)
- fixed Lookup.toEnumerable
---
 ix.js/l2o-tests.ts | 73 ++++++++++++++++++++++++++++++++++++++++++----
 ix.js/l2o.d.ts     | 21 +------------
 2 files changed, 68 insertions(+), 26 deletions(-)

diff --git a/ix.js/l2o-tests.ts b/ix.js/l2o-tests.ts
index 4be2974b3..2399d4e9f 100644
--- a/ix.js/l2o-tests.ts
+++ b/ix.js/l2o-tests.ts
@@ -96,14 +96,14 @@ ax.singleOrDefault();
 ax.forEach(a => console.log(a));
 ax.forEach(a => console.log(a), cx);
 
-bx.groupBy<number, string>(b => b.length);
+//bx.groupBy(b => b.length);						// spec 3.5.2, waiting for restriction on generative recursion removal
 bx.groupBy(b => b.length, b => "[" + b + "]");
 bx.groupBy(b => b.length, b => "[" + b + "]", (l, values) => l + values.count());
 bx.groupBy(b => b.length, false, (l, values) => l + values.count());
 bx.groupBy(b => b.length, b => "[" + b + "]", (l, values) => l + values.count(), ec_nn);
 bx.groupBy(b => b.length, b => "[" + b + "]", false, (x, y) => x == y);
 bx.groupBy(b => b.length, false, (l, values) => l + values.count(), ec_nn);
-bx.groupBy<number, number>(b => b.length, false, false, ec_nn);
+//bx.groupBy(b => b.length, false, false, ec_nn);	// spec 3.5.2, waiting for restriction on generative recursion removal
 
 ax.groupJoin(bx, a => a, b => b, (a, b) => [a, b], ec_ns);
 ax.groupJoin(bx, a => a, b => b.length, (a, b) => [a, b]);
@@ -142,14 +142,14 @@ ax.takeWhile(a => a > 10);
 ax.toArray();
 
 bx.toDictionary(b => b.length, b => 10, ec_nn);
-bx.toDictionary<number, string>(b => b.length, false, ec_nn);
+//bx.toDictionary(b => b.length, false, ec_nn);	// spec 3.5.2, waiting for restriction on generative recursion removal
 bx.toDictionary(b => b.length, b => 10);
-bx.toDictionary<number, string>(b => b.length);
+//bx.toDictionary(b => b.length);				// spec 3.5.2, waiting for restriction on generative recursion removal
 
 bx.toLookup(b => b.length, b => 10, ec_nn);
-bx.toLookup<number, string>(b => b.length, false, ec_nn);
+//bx.toLookup(b => b.length, false, ec_nn);		// spec 3.5.2, waiting for restriction on generative recursion removal
 bx.toLookup(b => b.length, b => 10);
-bx.toLookup<number, string>(b => b.length);
+//bx.toLookup(b => b.length);					// spec 3.5.2, waiting for restriction on generative recursion removal
 
 ax.where(a=> a > 10, {});
 ax.where(a=> a > 10);
@@ -158,3 +158,64 @@ ax.filter(a=> a > 10);
 
 ax.zip(bx, (a: number, b: string) => [a, b]);
 ax.zip(bx, (a, b) => [a, b]);
+
+// Disposable
+
+{
+	var d: Ix.Disposable;
+
+	d.dispose();
+}
+
+// Enumerator
+
+{
+	var e: Ix.Enumerator<number>;
+
+	try {
+		while (e.moveNext()) { var c = e.getCurrent(); }
+	}
+	finally {
+		e.dispose();
+	}
+}
+
+// Dictionary
+
+{
+	var dic = new Ix.Dictionary<number, string>(0, ec_nn);
+
+	var key = dic.toEnumerable().first().key;
+	var value = dic.toEnumerable().first().value;
+
+	dic.add(1, "1");
+	dic.remove(1);
+	dic.clear();
+	dic.length();
+	dic.tryGetValue(1);
+	dic.get(1);
+	dic.set(1, "1");
+	dic.getValues();
+	dic.has(1);
+}
+
+// KeyValuePair
+
+{
+	var kv: Ix.KeyValuePair<number, string>;
+	var key = kv.key;
+	var value = kv.value;
+}
+
+// Lookup
+
+{
+	var lookup: Ix.Lookup<number, string>;
+
+	var key = lookup.toEnumerable().first().key;
+	lookup.toEnumerable().first().first();
+
+	lookup.has(1);
+	lookup.length();
+	lookup.get(1).first();
+}
\ No newline at end of file
diff --git a/ix.js/l2o.d.ts b/ix.js/l2o.d.ts
index 44a5efda4..c3f3c415e 100644
--- a/ix.js/l2o.d.ts
+++ b/ix.js/l2o.d.ts
@@ -94,8 +94,6 @@ declare module Ix {
 		// spec 3.5.2, waiting for restriction on generative recursion removal
 		/*groupBy<TKey>(
 			keySelector: (item: T) => TKey): Grouping<TKey, T>;*/
-		groupBy<TKey, _T extends T>(
-			keySelector: (item: T) => TKey): Grouping<TKey, _T>;
 
 		// if need to set comparer without resultSelector
 		groupBy<TKey, TElement>(
@@ -116,11 +114,6 @@ declare module Ix {
 			_: boolean,
 			__: boolean,
 			comparer: EqualityComparer<TKey, TKey>): Grouping<TKey, T>;*/
-		groupBy<TKey, _T extends T>(
-			keySelector: (item: T) => TKey,
-			_: boolean,
-			__: boolean,
-			comparer: EqualityComparer<TKey, TKey>): Grouping<TKey, _T>;
 
 		groupJoin<TInner, TOuterKey, TInnerKey, TResult>(
 			inner: Enumerable<TInner>,
@@ -179,18 +172,12 @@ declare module Ix {
 		// spec 3.5.2, waiting for restriction on generative recursion removal
 		/*toDictionary<TKey>(
 			keySelector: (item: T) => TKey): Dictionary<TKey, T>;*/
-		toDictionary<TKey, _T extends T>(
-			keySelector: (item: T) => TKey): Dictionary<TKey, _T>;
 		// if need to set comparer without elementSelector
 		// spec 3.5.2, waiting for restriction on generative recursion removal
 		/*toDictionary<TKey>(
 			keySelector: (item: T) => TKey,
 			_: boolean,
 			comparer: EqualityComparer<TKey, TKey>): Dictionary<TKey, T>;*/
-		toDictionary<TKey, _T extends T>(
-			keySelector: (item: T) => TKey,
-			_: boolean,
-			comparer: EqualityComparer<TKey, TKey>): Dictionary<TKey, _T>;
 
 		toLookup<TKey, TValue>(
 			keySelector: (item: T) => TKey,
@@ -199,18 +186,12 @@ declare module Ix {
 		// spec 3.5.2, waiting for restriction on generative recursion removal
 		/*toLookup<TKey>(
 			keySelector: (item: T) => TKey): Lookup<TKey, T>;*/
-		toLookup<TKey, _T extends T>(
-			keySelector: (item: T) => TKey): Lookup<TKey, _T>;
 		// if need to set comparer without elementSelector
 		// spec 3.5.2, waiting for restriction on generative recursion removal
 		/*toLookup<TKey>(
 			keySelector: (item: T) => TKey,
 			_: boolean,
 			comparer: EqualityComparer<TKey, TKey>): Lookup<TKey, T>;*/
-		toLookup<TKey, _T extends T>(
-			keySelector: (item: T) => TKey,
-			_: boolean,
-			comparer: EqualityComparer<TKey, TKey>): Lookup<TKey, _T>;
 
 		where(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
 		filter(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
@@ -249,7 +230,7 @@ declare module Ix {
 	}
 
 	export interface Lookup<TKey, TValue> {
-		toEnumerable(): Enumerable<Grouping<TKey, any>>;
+		toEnumerable(): Enumerable<Grouping<TKey, TValue>>;
 		has(key: TKey): boolean;
 		length(): number;
 		get(key: TKey): Enumerable<TValue>;