This interface allows to retrieve a value from some collection or sequence
    which belongs to the object.

    The is simply a value+done pair: 

    1. interface IteratorResult<T> {
    2.     done: boolean;
    3.     value: T;
    4. }

    Again. Iterator itself is not a TypeScript feature, this code could work without
    implementing Iterator and IteratorResult interfaces explicitly.
    However it is very helpful to use these common
    ES6 for code consistency.

    Ok, Nice, but could be more helpful. ES6 defines the iterable protocol
    which includes [Symbol.iterator] symbol if Iterable interface implemented:

    1. //...
    2. class Frame implements Iterable<Component> {
    4.   constructor(public name: string, public components: Component[]) {}
    6.   [Symbol.iterator]() {
    7.     let pointer = 0;
    8.     let components = this.components;
    10.     return {
    11.       next(): IteratorResult<Component> {
    12.         if (pointer < components.length) {
    13.           return {
    14.             done: false,
    15.             value: components[pointer++]
    16.           }
    17.         } else {
    18.           return {
    19.             done: true,
    20.             value: null
    21.           }
    22.       }
    23.     }
    24.   }
    25. }
    27. let frame = new Frame("Door", [new Component("top"), new Component("bottom"), new Component("left"), new Component("right")]);
    28. for (let cmp of frame) {
    29.   console.log(cmp);
    30. }

    Both frame.next() and for cycle now work fine with IterableIterator interface.

    Iterator does not have to iterate a finite value.
    The typical example is a Fibonacci sequence:

    1. class Fib implements IterableIterator<number> {
    3.   protected fn1 = 0;
    4.   protected fn2 = 1;
    6.   constructor(protected maxValue?: number) {}
    8.   public next(): IteratorResult<number> {
    9.     var current = this.fn1;
    10.     this.fn1 = this.fn2;
    11.     this.fn2 = current + this.fn1;
    12.     if (this.maxValue != null && current >= this.maxValue) {
    13.       return {
    14.         done: true,
    15.         value: null
    16.       } 
    18.       done: false,
    19.       value: current
    20.     }
    21.   }
    23.   [Symbol.iterator](): IterableIterator<number> {
    24.     return this;
    25.   }
    27. }
    29. let fib = new Fib();
    31. fib.next() //{ done: false, value: 0 }
    32. fib.next() //{ done: false, value: 1 }
    33. fib.next() //{ done: false, value: 1 }
    34. fib.next() //{ done: false, value: 2 }
    35. fib.next() //{ done: false, value: 3 }
    36. fib.next() //{ done: false, value: 5 }
    38. let fibMax50 = new Fib(50);
    39. console.log(Array.from(fibMax50)); // [ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 ]
    41. let fibMax21 = new Fib(21);
    42. for(let num of fibMax21) {
    43.   console.log(num); //Prints fibonacci sequence 0 to 21

    Building code with iterators for ES5 target