Q:

TypeScript Handbook: class static side example overcomplication

Came across example in Classes -> Advanced Techniques section http://www.typescriptlang.org/Handbook#classes-advanced-techniques
class Greeter {
    static standardGreeting = "Hello, there";
    greeting: string;
    greet() {
        if (this.greeting) {
            return "Hello, " + this.greeting;
        }
        else {
            return Greeter.standardGreeting;
        }
    }
}

var greeter1: Greeter;
greeter1 = new Greeter();
alert(greeter1.greet());

var greeterMaker: typeof Greeter = Greeter;
greeterMaker.standardGreeting = "Hey there!";
var greeter2:Greeter = new greeterMaker();
alert(greeter2.greet());

And explanation:

Next, we then use the class directly. Here we create a new variable called 'greeterMaker'. This variable will hold the class itself, or said another way its constructor function. Here we use 'typeof Greeter', that is "give me the type of the Greeter class itself" rather than the instance type. Or, more precisely, "give me the type of the symbol called Greeter", which is the type of the constructor function. This type will contain all of the static members of Greeter along with the constructor that creates instances of the Greeter class. We show this by using 'new' on 'greeterMaker', creating new instances of 'Greeter' and invoking them as before.

My question: what is the purpose of introducing greeterMaker variable? Ultimately, it just holds the reference to the Greeter class.
We can write code below, 
Greeter.standardGreeting = "Hey there!";
var greeter2:Greeter = new Greeter();
alert(greeter2.greet());

receive same result and not confuse ourselves with strangely looking
var greeterMaker: typeof Greeter = Greeter;

Am I missing something here?
Is construct var maker: typeof Foo = Foo; indeed useful?

A:

I think your code is correct and simpler, but they took the intermediate step of assigning the Greeter type to a variable first before operating on it.
Dissecting that line of code, they are just saying:
var greeterMaker // there is a variable named greeterMaker
                : typeof Greeter // the static type of this variable is a constructor function for the Greeter class;
                                 = Greeter; // Assign the value of Greeter (the constructor function) to the variable greeterMaker

So in the end, greeterMaker and Greeter are the same thing. (because the code is doing var greeterMaker = Greeter;)
I can only assume that their example did it this way just to demonstrate that you can assign the "type of a type" as the static type of a variable.
In other words, var greeterMaker: typeof Greeter; says that the static type of greeterMaker is the constructor function for a Greeter, not an instance of Greeter and that is the value of the example.

