TypeScript playgrounds

interface IEnumerable<T>
{
    getEnumerator(): IEnumerator<T>;
}


interface IEnumerator<T>
{
    current: T;

    moveNext(): boolean;

    reset(): void;
}


class List<T> implements IEnumerable<T>
{
    constructor(private data?: T[])
    {
    }

    getEnumerator(): IEnumerator<T>
    {
        return new ListEnumerator<T>(this.data);
    }
}


class ListEnumerator<T> implements IEnumerator<T>
{
    private idx: number;

    constructor(private data: T[])
    {
        this.reset();
    }

    moveNext(): boolean
    {
        return ++this.idx < this.data.length;
    }

    reset(): void
    {
        this.idx = -1;
    }

    get current(): T
    {
        return this.data[this.idx];
    }
}

class Enumerable
{
    static forEach<T>(enumerable: IEnumerable<T>, f: (current: T) => void)
    {
        var enumerator = enumerable.getEnumerator();
        while (enumerator.moveNext())
        {
            f(enumerator.current);
        }
    }
}

        var list = new List<number>([1, 2, 3, 4]);
        Enumerable.forEach(list, current =>
        {
            console.log(current.toString());
        });