remove old iterator and utils

src/vs/base/common/iterator.ts

@@ -3,37 +3,6 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-export interface IteratorDefinedResult<T> {
-	readonly done: false;
-	readonly value: T;
-}
-export interface IteratorUndefinedResult {
-	readonly done: true;
-	readonly value: undefined;
-}
-export const FIN: IteratorUndefinedResult = { done: true, value: undefined };
-export type IteratorResult<T> = IteratorDefinedResult<T> | IteratorUndefinedResult;
-
-export interface Iterator<T> {
-	next(): IteratorResult<T>;
-}
-
-interface NativeIteratorYieldResult<TYield> {
-	done?: false;
-	value: TYield;
-}
-
-interface NativeIteratorReturnResult<TReturn> {
-	done: true;
-	value: TReturn;
-}
-
-type NativeIteratorResult<T, TReturn = any> = NativeIteratorYieldResult<T> | NativeIteratorReturnResult<TReturn>;
-
-export interface NativeIterator<T> {
-	next(): NativeIteratorResult<T>;
-}
-
 export namespace Iterable {
 
 	const _empty: Iterable<any> = Object.freeze([]);
@@ -107,184 +76,6 @@ export namespace Iterable {
 	}
 }
 
-export module Iterator {
-	const _empty: Iterator<any> = {
-		next() {
-			return FIN;
-		}
-	};
-
-	export function empty<T>(): Iterator<T> {
-		return _empty;
-	}
-
-	export function single<T>(value: T): Iterator<T> {
-		let done = false;
-
-		return {
-			next(): IteratorResult<T> {
-				if (done) {
-					return FIN;
-				}
-
-				done = true;
-				return { done: false, value };
-			}
-		};
-	}
-
-	export function fromArray<T>(array: ReadonlyArray<T>, index = 0, length = array.length): Iterator<T> {
-		return {
-			next(): IteratorResult<T> {
-				if (index >= length) {
-					return FIN;
-				}
-
-				return { done: false, value: array[index++] };
-			}
-		};
-	}
-
-	export function fromNativeIterator<T>(it: NativeIterator<T>): Iterator<T> {
-		return {
-			next(): IteratorResult<T> {
-				const result = it.next();
-
-				if (result.done) {
-					return FIN;
-				}
-
-				return { done: false, value: result.value };
-			}
-		};
-	}
-
-	export function from<T>(elements: Iterator<T> | T[] | undefined): Iterator<T> {
-		if (!elements) {
-			return Iterator.empty();
-		} else if (Array.isArray(elements)) {
-			return Iterator.fromArray(elements);
-		} else {
-			return elements;
-		}
-	}
-
-	export function map<T, R>(iterator: Iterator<T>, fn: (t: T) => R): Iterator<R> {
-		return {
-			next() {
-				const element = iterator.next();
-				if (element.done) {
-					return FIN;
-				} else {
-					return { done: false, value: fn(element.value) };
-				}
-			}
-		};
-	}
-
-	export function filter<T>(iterator: Iterator<T>, fn: (t: T) => boolean): Iterator<T> {
-		return {
-			next() {
-				while (true) {
-					const element = iterator.next();
-					if (element.done) {
-						return FIN;
-					}
-					if (fn(element.value)) {
-						return { done: false, value: element.value };
-					}
-				}
-			}
-		};
-	}
-
-	export function some<T>(iterator: Iterator<T> | NativeIterator<T>, fn: (t: T) => boolean): boolean {
-		while (true) {
-			const element = iterator.next();
-			if (element.done) {
-				return false;
-			}
-
-			if (fn(element.value)) {
-				return true;
-			}
-		}
-	}
-
-	export function forEach<T>(iterator: Iterator<T>, fn: (t: T) => void): void {
-		for (let next = iterator.next(); !next.done; next = iterator.next()) {
-			fn(next.value);
-		}
-	}
-
-	export function collect<T>(iterator: Iterator<T>, atMost: number = Number.POSITIVE_INFINITY): T[] {
-		const result: T[] = [];
-
-		if (atMost === 0) {
-			return result;
-		}
-
-		let i = 0;
-
-		for (let next = iterator.next(); !next.done; next = iterator.next()) {
-			result.push(next.value);
-
-			if (++i >= atMost) {
-				break;
-			}
-		}
-
-		return result;
-	}
-
-	export function concat<T>(...iterators: Iterator<T>[]): Iterator<T> {
-		let i = 0;
-
-		return {
-			next() {
-				if (i >= iterators.length) {
-					return FIN;
-				}
-
-				const iterator = iterators[i];
-				const result = iterator.next();
-
-				if (result.done) {
-					i++;
-					return this.next();
-				}
-
-				return result;
-			}
-		};
-	}
-
-	export function chain<T>(iterator: Iterator<T>): ChainableIterator<T> {
-		return new ChainableIterator(iterator);
-	}
-}
-
-export class ChainableIterator<T> implements Iterator<T> {
-
-	constructor(private it: Iterator<T>) { }
-
-	next(): IteratorResult<T> { return this.it.next(); }
-	map<R>(fn: (t: T) => R): ChainableIterator<R> { return new ChainableIterator(Iterator.map(this.it, fn)); }
-	filter(fn: (t: T) => boolean): ChainableIterator<T> { return new ChainableIterator(Iterator.filter(this.it, fn)); }
-}
-
-export type ISequence<T> = Iterator<T> | T[];
-
-export function getSequenceIterator<T>(arg: ISequence<T> | undefined): Iterator<T> {
-	if (Array.isArray(arg)) {
-		return Iterator.fromArray(arg);
-	} else if (!arg) {
-		return Iterator.empty();
-	} else {
-		return arg;
-	}
-}
-
 export interface INextIterator<T> {
 	next(): T | null;
 }

src/vs/base/common/map.ts

@@ -369,7 +369,7 @@ export class TernarySearchTree<E> {
 				this._forEach(node, value => data.push(value));
 			}
 			if (idx >= data.length) {
-				return FIN;
+				return { done: true, value: undefined };
 			}
 
 			if (!res) {

src/vs/base/test/common/iterator.test.ts

@@ -4,19 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as assert from 'assert';
-import { Iterator, Iterable } from 'vs/base/common/iterator';
-
-suite('Iterator', () => {
-	test('concat', () => {
-		const first = Iterator.fromArray([1, 2, 3]);
-		const second = Iterator.fromArray([4, 5, 6]);
-		const third = Iterator.fromArray([7, 8, 9]);
-		const actualIterator = Iterator.concat(first, second, third);
-		const actual = Iterator.collect(actualIterator);
-
-		assert.deepEqual(actual, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
-	});
-});
+import { Iterable } from 'vs/base/common/iterator';
 
 suite('Iterable', function () {