Grammar fix, replace lets with let's

Author: Andrew Zheng

docs/compiler/binder-functions.md

@@ -9,7 +9,7 @@ Note: `locals` is defined on `Node` and is of type `SymbolTable`. Note that `Sou
 TIP: local functions are used heavily within the TypeScript compiler. A local function very likely uses variables from the parent function (captured by closure). In the case of `bind` (a local function within `bindSourceFile`) it (or function it calls) will setup the `symbolCount` and `classifiableNames` among others, that are then stored on the returned `SourceFile`.
 
 #### `bind`
-Bind takes any `Node` (not just `SourceFile`). First thing it does is assign the `node.parent` (if `parent` variable has been setup ... which again is something the binder does during its processing within the `bindChildren` function), then hands off to `bindWorker` which does the *heavy* lifting. Finally it calls `bindChildren` (a function that simply stores the binder state e.g. current `parent` within its function local vars, then calls `bind` on each child, and then restores the binder state). Now lets look at `bindWorker` which is the more interesting function.
+Bind takes any `Node` (not just `SourceFile`). First thing it does is assign the `node.parent` (if `parent` variable has been setup ... which again is something the binder does during its processing within the `bindChildren` function), then hands off to `bindWorker` which does the *heavy* lifting. Finally it calls `bindChildren` (a function that simply stores the binder state e.g. current `parent` within its function local vars, then calls `bind` on each child, and then restores the binder state). Now let's look at `bindWorker` which is the more interesting function.
 
 #### `bindWorker`
 This function switches on `node.kind` (of type `SyntaxKind`) and delegates work to the appropriate `bindFoo` function (also defined within `binder.ts`). For example if the `node` is a `SourceFile` it calls (eventually and only if its an external file module) `bindAnonymousDeclaration`

docs/enums.md

@@ -39,7 +39,7 @@ col = 0; // Effectively same as Color.Red
 ```
 
 #### Enums and Strings
-Before we look further into enums lets look at the JavaScript that it generates, here is a sample TypeScript:
+Before we look further into enums let's look at the JavaScript that it generates, here is a sample TypeScript:
 
 ```ts
 enum Tristate {
@@ -59,7 +59,7 @@ var Tristate;
 })(Tristate || (Tristate = {}));
 ```
 
-lets focus on the line `Tristate[Tristate["False"] = 0] = "False";`. Within it `Tristate["False"] = 0` should be self explanatory, i.e. sets `"False"` member of `Tristate` variable to be `0`. Note that in JavaScript the assignment operator returns the assigned value (in this case `0`). Therefore the next thing executed by the JavaScript runtime is `Tristate[0] = "False"`. This means that you can use the `Tristate` variable to convert a string version of the enum to a number or a number version of the enum to a string. This is demonstrated below:
+let's focus on the line `Tristate[Tristate["False"] = 0] = "False";`. Within it `Tristate["False"] = 0` should be self explanatory, i.e. sets `"False"` member of `Tristate` variable to be `0`. Note that in JavaScript the assignment operator returns the assigned value (in this case `0`). Therefore the next thing executed by the JavaScript runtime is `Tristate[0] = "False"`. This means that you can use the `Tristate` variable to convert a string version of the enum to a number or a number version of the enum to a string. This is demonstrated below:
 
 ```ts
 enum Tristate {

docs/getting-started.md

@@ -41,4 +41,4 @@ The source for this book is available in the books github repository https://git
 // This will be the code under discussion
 ```
 
-With a dev setup out of the way lets jump into TypeScript syntax.
+With a dev setup out of the way let's jump into TypeScript syntax.

docs/javascript/recap.md

@@ -19,17 +19,17 @@ TypeScript will try to protect you from portions of JavaScript that never worked
 [] + []; // JavaScript will give you "" (which makes little sense), TypeScript will error
 
 //
-// other things that are nonsensical in JavaScript 
+// other things that are nonsensical in JavaScript
 // - don't give a runtime error (making debugging hard)
 // - but TypeScript will give a compile time error (making debugging unnecessary)
 //
 {} + []; // JS : 0, TS Error
-[] + {}; // JS : "[object Object]", TS Error 
+[] + {}; // JS : "[object Object]", TS Error
 {} + {}; // JS : NaN, TS Error
 "hello" - 1; // JS : NaN, TS Error
 
 function add(a,b) {
- return 
+ return
  a + b; // JS : undefined, TS Error 'unreachable code detected'
 }
 ```
@@ -38,4 +38,4 @@ Essentially TypeScript is linting JavaScript. Just doing a better job at it than
 
 ## You still need to learn JavaScript
 
-That said TypeScript is very pragmatic about the fact that *you do write JavaScript* so there are some things about JavaScript that you still need to know in order to not be caught off-guard. Lets discuss them next.
+That said TypeScript is very pragmatic about the fact that *you do write JavaScript* so there are some things about JavaScript that you still need to know in order to not be caught off-guard. Let's discuss them next.

docs/options/intro.md

@@ -2,7 +2,7 @@
 
 There are a few things that TypeScript prevents you from doing out of the box e.g using a variable that *isn't ever declared* (of course you can use a *declaration file* for external systems).
 
-That said, traditionally programming languages have a hard boundary between what is and isn't allowed by the type system. TypeScript is different in that it gives you control on where you put the slider. This is really to allow you to use the JavaScript you know and love with as much safety as **you** want. There are lot of compiler options to control exactly this slider so lets have a look.
+That said, traditionally programming languages have a hard boundary between what is and isn't allowed by the type system. TypeScript is different in that it gives you control on where you put the slider. This is really to allow you to use the JavaScript you know and love with as much safety as **you** want. There are lot of compiler options to control exactly this slider so let's have a look.
 
 
 ### Boolean Options
@@ -25,4 +25,4 @@ tsc --someBooleanOption
 
 > All of these are `false` by default.
 
-Click [here](https://www.typescriptlang.org/docs/handbook/compiler-options.html) to see all compiler options. 
+Click [here](https://www.typescriptlang.org/docs/handbook/compiler-options.html) to see all compiler options.

docs/promise.md

@@ -4,7 +4,7 @@ The `Promise` class is something that exists in many modern JavaScript engines a
 
 ### Callback style code
 
-In order to fully appreciate promises lets present a simple sample that proves the difficulty of creating reliable Async code with just callbacks. Consider the simple case of authoring an async version of loading JSON from a file. A synchronous version of this can be quite simply
+In order to fully appreciate promises let's present a simple sample that proves the difficulty of creating reliable Async code with just callbacks. Consider the simple case of authoring an async version of loading JSON from a file. A synchronous version of this can be quite simply
 
 ```ts
 import fs = require('fs');
@@ -129,7 +129,7 @@ loadJSON('good.json', function (err, data) {
 
  if (err) console.log('Error:', err.message);
  else {
- // lets simulate an error by trying to access a property on an undefined variable
+ // let's simulate an error by trying to access a property on an undefined variable
  var foo;
  // The following code throws `Error: Cannot read property 'bar' of undefined`
  console.log(foo.bar);
@@ -176,7 +176,7 @@ A promise can be either `pending` or `resolved` or `rejected`.
 
 ![](https://raw.githubusercontent.com/basarat/typescript-book/master/images/promise%20states%20and%20fates.png)
 
-Lets look at creating a promise. Its a simple matter of calling `new` on `Promise` (the promise constructor). The promise constructor is passed `resolve` and `reject` functions for settling the promise state.
+Let's look at creating a promise. Its a simple matter of calling `new` on `Promise` (the promise constructor). The promise constructor is passed `resolve` and `reject` functions for settling the promise state.
 
 ```ts
 const promise = new Promise((resolve, reject) => {
@@ -255,7 +255,7 @@ Promise.reject(new Error('something bad happened'))
  return 123;
  })
  .catch((err) => {
- console.log(err.message); // something bad happened 
+ console.log(err.message); // something bad happened
  });
 ```
 
@@ -344,7 +344,7 @@ Just wrap the function call in a promise and
 - `reject` if an error occurs,
 - `resolve` if it is all good.
 
-E.g. lets wrap `fs.readFile`
+E.g. let's wrap `fs.readFile`
 
 ```ts
 import fs = require('fs');
@@ -414,7 +414,7 @@ function loadItem(id: number): Promise<{id: number}> {
  console.log('loading item', id);
  setTimeout(() => { // simulate a server delay
  resolve({ id: id });
- }, 1000); 
+ }, 1000);
  });
 }
 
@@ -434,7 +434,7 @@ loadItem(1)
 Promise.all([loadItem(1),loadItem(2)])
  .then((res) => {
  [item1,item2] = res;
- console.log('done') 
+ console.log('done')
  }); // overall time will be around 1s
 ```
 

docs/tips/defaultIsBad.md

@@ -1,6 +1,6 @@
 ## `export default` can lead to problems
 
-Lets go with an example. Consider you have a file `foo.ts` with the following contents:
+Let's go with an example. Consider you have a file `foo.ts` with the following contents:
 
 ```ts
 class Foo {

docs/types/ambient/variables.md

@@ -34,4 +34,4 @@ process.exitWithLogging = function() {
 }
 ```
 
-Lets look at interfaces in a bit more detail next.
+Let's look at interfaces in a bit more detail next.

docs/types/index-signatures.md

@@ -49,7 +49,7 @@ let foo = ['World'];
 console.log(foo[0]); // World
 ```
 
-So that's JavaScript. Now lets look at TypeScript graceful handling of this concept.
+So that's JavaScript. Now let's look at TypeScript graceful handling of this concept.
 
 ## TypeScript Index Signature
 
@@ -100,7 +100,7 @@ So lesson 1:
 
 > TypeScript index signatures must be either `string` or `number`
 
-Quick note: `symbols` are also valid and supported by TypeScript. But lets not go there just yet. Baby steps.
+Quick note: `symbols` are also valid and supported by TypeScript. But let's not go there just yet. Baby steps.
 
 
 ### Declaring an index signature

docs/types/lib.d.ts.md

@@ -17,7 +17,7 @@ You can exclude this file from the compilation context by specifying the `--noLi
 
 ### Example Usage
 
-As always lets look at examples of this file being used in action.
+As always let's look at examples of this file being used in action.
 
 ```ts
 var foo = 123;
@@ -39,7 +39,7 @@ The contents of `lib.d.ts` are primarily a bunch of *variable* declarations e.g.
 
 The simplest way to discover what is what is to type in code *that you know works* e.g. `Math.floor` and then F12 (go to definition) using your IDE (atom-typescript has great support for this).
 
-Lets look at a sample *variable* declaration, e.g. `window` is defined as:
+Let's look at a sample *variable* declaration, e.g. `window` is defined as:
 ```ts
 declare var window: Window;
 ```
@@ -223,24 +223,24 @@ However if you want finer grained control of your environment you should use the
 
 Sometimes (many times) you want to decouple the relationship between the compile target (the generates JavaScript version) and the ambient library support. A common example is `Promise`, e.g today (in June 2016) you most likely want to `--target es5` but still use latest stuff like `Promise`. To support this you can take explicit control of `lib` using the `lib` compiler option.
 
-> Note: using `--lib` decouples any lib magic from `--target` giving you better control. 
+> Note: using `--lib` decouples any lib magic from `--target` giving you better control.
 
-You can provide this option on the command line or in `tsconfig.json` (recommended): 
+You can provide this option on the command line or in `tsconfig.json` (recommended):
 
 **Command line**:
 ```
 tsc --target es5 --lib dom,es6
-``` 
-**tsconfig.json**: 
+```
+**tsconfig.json**:
 ```json
 "compilerOptions": {
  "lib": ["dom", "es6"]
 }
 ```
 
-The libs can be categorized into categories: 
+The libs can be categorized into categories:
 
-* JavaScript Bulk Feature: 
+* JavaScript Bulk Feature:
  * es5
  * es6
  * es2015
@@ -268,11 +268,11 @@ The libs can be categorized into categories:
 
 > NOTE: the `--lib` option provides extremely fine tuned control. So you most likey want to pick an item from the bulk + enviroment categories.
 
-My Personal Recommentation: 
+My Personal Recommentation:
 
 ```json
 "compilerOptions": {
  "target": "es5",
  "lib": ["es6", "dom"]
 }
-``` 
+```