1. Lambdas (as you mentioned) are not only shortened syntax, but also capture the `this` variable automatically for you. Try typing in the following at the playground in the body of the `greet` method to see what I mean (http://typescriptlang.org/playground):

  var x = a => this.greet();

3. Interfaces with duck typing are very lightweight and easy to use:

  interface IGreeter { greet(); }
  class Greeter /* implements IGreeter */ {
      greet() { ... };
  }

  class Greet {
    greet(x: number) {
        var s = ' greetings';
        return x + s;
    }
  }

5. Javascript is TypeScript, just without typing, so converting your codebase is instance, and then you can begin adding type annotations to get more robust checking

    var names = people.map((p) -> return p.name);

    var names = people.Select(p => p.name);

  from([1,2,3]).select(n => n * n).where(n >=2).toArray()

  [4, 9]

Edit: typo, n * 2 should have been n * n, sorry for the confusion

    _.chain([1,2,3]).map(n => n * n).filter(n => n >= 2).value()

It should be pretty straightforward to provide Underscore bindings for TypeScript.

One big difference in the library I was working on is that it is lazy, and modeled after .NETs IEnumerable. Whether this is a good thing or not, I'm not yet sure.

The problem i had was that the native array methods are rather fast while function calls (for moveNext) are quite slow, so i couldn't get a whole lot of speed out of it.

Newer javascript engines might be sufficient to offset that though.

      names = people.map((p) -> p.name)

[0] http://sixlette.rs/snap/Closure_Compiler_Service-20121003-15...