Current documentation for any type does not reflect the difference between any and Object.

If you take a look here, you may find following example:

var notSure: any = 4;
notSure = "maybe a string instead";
notSure = false; // okay, definitely a boolean

But this example shows only one part of the any nature: an ability to assign anything to the variable of type any. Looking into this example it is really hard to understand the difference between any and Object, because following code would behave in the same way:

var notSure: Object = 4;
notSure = "maybe a string instead";
notSure = false; // okay, definitely a boolean

Proper example should show that the TypeScript type checker gives up and allows to call any method or access any properties on the variable of type any without any errors:

var notSure: any = 4;
notSure.weCanCallAnyMethodWithoutAnError();
notSure = "maybe a string instead";
var f = notSure.andAccessSomeFields;
notSure = false; // okay, definitely a boolean

The Handbook currently uses both single and double quotes, sometimes even in the same example:

var name: string = "bob";
name = 'smith';

Settling on just one style would look better.

Basically explain the exception for assignability in this area.

When reading through the "namespaces and modules" section, I noticed that links to modules and namespaces were dead.

https://github.com/Microsoft/TypeScript-Handbook/blob/master/pages/Namespaces%20and%20Modules.md

Declarations with destructuring, assignments, and samples.

Spell out contribution guidelines, style guide, PR process, etc.

Define the rules for when we do and don't elide module imports, and write guidance on how to use this effectively (type, etc)

Given a project written with internal modules and --out, how do I turn this into an ES6-module project?

Given a TypeScript project using old-style import x = require('foo');, export class Bar, or export =, how do I transition these to equivalent ES6 module import/exports?

also discuss how this affects the output order

Update this file so that it is up-to-date with regard to new language features, especially around union types and ES6 features

Iterables in ES6, Symbol.iterator, for..of, using iterators, generators

This page: https://github.com/Microsoft/TypeScript/wiki/'this'-in-TypeScript really belongs to the handbook and not the wiki.

Scoping rules, differences between var, let and const.

Update this file so that it is up-to-date with regard to new language features, especially around union types and ES6 features

Update this file so that it is up-to-date with regard to new language features, especially around union types and ES6 features

Write up best practices for how to structure medium and large projects, especially in light of ES6 Modules

Update this file so that it is up-to-date with regard to new language features, especially around union types and ES6 features

What are decorators? How do they work? What can/should I use them for? What is the codegen, and how are they typechecked?

Contingent on #6.

Update this file so that it is up-to-date with regard to new language features, especially around union types and ES6 features

Integrate contribution information into this repo so we can properly credit any external contributors

Possibly lumped with spread

We need to cover this typing.

I was having a hard time understanding how one would create a class implementing a hybrid type, and then ran across this posting which explained this issue:
http://stackoverflow.com/questions/25340601/typescript-hybrid-type-implementation

It would be nice of the Hybrid Types section could include an example function returning the hybrid type as was done in the posting, and further explain that one cannot create a TypeScript class that implements a hybrid type interface.

function getCounter():Counter{
var counter = function(start:number){};
counter.interval = 123;
counter.reset = function(){};
return counter;
}

var c: Counter = getCounter();
...

regular enums, Const enums, different in lining rules

Update this file so that it is up-to-date with regard to new language features, especially around union types and ES6 features

Update this file so that it is up-to-date with regard to new language features, especially around union types and ES6 features

This could go on the 'basic types' page.

I did a rough transition from CodePlex wiki to Markdown, but we need to do a detailed scan of each page to look for any formatting problems.

• Two spaces after periods
• Language tags after triple-ticks (need a bunch of these)
• Headings level (standardize on one-hash as top-level heading size)
• Fix link formatting

Figure out how to merge in our .md files the way we did the CodePlex wiki content, host a 'master' MD page that links everything together, or some other way to let people read all the content in an organized fashion.

There should be some tools out there for this already.

Link to handbook -- Explicitly mentions 2 arguments and then only shows the use of 2 arguments in the example as well.

From the lib.d.ts (I checked 1.6.2 & 1.8.0 versions) it seems like propertyKey is the one missing from the documentation:

declare type ParameterDecorator = (target: Object, propertyKey: string | symbol, parameterIndex: number) => void;

I first had a read through the above mentioned website before looking in the language spec and then realised that a lot of the syntax and concepts described on the above mentioned website is out-of-date, already deprecated respectively. For instance, it does still use the term internal module instead of namespace or uses the import ... require instead of import ... from.
IMO the website should either be updated or a notice should be shown that it is outdated and one should have a look at the language spec

Update this file so that it is up-to-date with regard to new language features, especially around union types and ES6 features

Update this file so that it is up-to-date with regard to new language features, especially around union types and ES6 features

See title

The handbook currently doesn't mention things like tuples, and this makes it confusing if you learn about tuples from a different source and then try to look them up in the handbook. The handbook is also the main form of documentation in the TS website, so it's natural to expect it being up to date, which is an another reason to add a notice that it doesn't cover all the TS features.

Update this file so that it is up-to-date with regard to new language features, especially around union types and ES6 features

Templates, escaping rules, diffrences from string literals and tagged templates

Somewhat related is @drudru's issue filed here: microsoft/TypeScript#3660.

Possibly lumped with interfaces.

Cover abstract classes

Update this file so that it is up-to-date with regard to new language features, especially around union types and ES6 features

It's okay to say this is behind an experimental flag, but it needs to be covered.

• Union types
• type guards