Merge branch 'master' of https://github.com/microsoft/TypeScript-Handbook

Author: orta

pages/Advanced Types.md

@@ -813,7 +813,7 @@ let carProps: keyof Car; // the union of ('manufacturer' | 'model' | 'year')
 ```
 
 `keyof Car` is completely interchangeable with `'manufacturer' | 'model' | 'year'`.
-The difference is that if you add another property to `Car`, say `ownersAddress: string`, then `keyof Person` will automatically update to be `'manufacturer' | 'model' | 'year' | 'ownersAddress'`.
+The difference is that if you add another property to `Car`, say `ownersAddress: string`, then `keyof Car` will automatically update to be `'manufacturer' | 'model' | 'year' | 'ownersAddress'`.
 And you can use `keyof` in generic contexts like `pluck`, where you can't possibly know the property names ahead of time.
 That means the compiler will check that you pass the right set of property names to `pluck`:
 

pages/Compiler Options.md

@@ -98,5 +98,5 @@ Option                                         | Type      | Default
 
 ## Related
 
-* Setting compiler options in [`tsconfig.json`](./tsconfig.json.md) files.
+* Setting compiler options in [`tsconfig.json`](./tutorials/tsconfig.json.md) files.
 * Setting compiler options in [MSBuild projects](./Compiler%20Options%20in%20MSBuild.md).

pages/Enums.md

@@ -58,7 +58,7 @@ In other words, the following isn't allowed:
 ```ts
 enum E {
     A = getSomeValue(),
-    B, // error! 'A' is not constant-initialized, so 'B' needs an initializer
+    B, // Error! Enum member must have initializer.
 }
 ```
 
@@ -174,8 +174,7 @@ interface Square {
 }
 
 let c: Circle = {
-    kind: ShapeKind.Square,
-    //    ~~~~~~~~~~~~~~~~ Error!
+    kind: ShapeKind.Square, // Error! Type 'ShapeKind.Square' is not assignable to type 'ShapeKind.Circle'.
     radius: 100,
 }
 ```
@@ -194,7 +193,7 @@ enum E {
 function f(x: E) {
     if (x !== E.Foo || x !== E.Bar) {
         //             ~~~~~~~~~~~
-        // Error! Operator '!==' cannot be applied to types 'E.Foo' and 'E.Bar'.
+        // Error! This condition will always return 'true' since the types 'E.Foo' and 'E.Bar' have no overlap.
     }
 }
 ```

pages/Mixins.md

@@ -37,23 +37,17 @@ class Activatable {
     }
 }
 
-class SmartObject implements Disposable, Activatable {
+class SmartObject {
     constructor() {
         setInterval(() => console.log(this.isActive + " : " + this.isDisposed), 500);
     }
 
     interact() {
         this.activate();
     }
-
-    // Disposable
-    isDisposed: boolean = false;
-    dispose: () => void;
-    // Activatable
-    isActive: boolean = false;
-    activate: () => void;
-    deactivate: () => void;
 }
+
+interface SmartObject extends Disposable, Activatable {}
 applyMixins(SmartObject, [Disposable, Activatable]);
 
 let smartObj = new SmartObject();
@@ -105,29 +99,19 @@ Next, we'll create the class that will handle the combination of the two mixins.
 Let's look at this in more detail to see how it does this:
 
 ```ts
-class SmartObject implements Disposable, Activatable {
-```
+class SmartObject {
+    ...
+}
 
-The first thing you may notice in the above is that instead of using `extends`, we use `implements`.
-This treats the classes as interfaces, and only uses the types behind Disposable and Activatable rather than the implementation.
-This means that we'll have to provide the implementation in class.
-Except, that's exactly what we want to avoid by using mixins.
+interface SmartObject extends Disposable, Activatable {}
+```
 
-To satisfy this requirement, we create stand-in properties and their types for the members that will come from our mixins.
-This satisfies the compiler that these members will be available at runtime.
-This lets us still get the benefit of the mixins, albeit with some bookkeeping overhead.
+The first thing you may notice in the above is that instead of trying to extend `Disposable` and `Activatable` in `SmartObject` class, we extend them in `SmartObject` interface. `SmartObject` interface will be mixed into the `SmartObject` class due to the [declaration merging](./Declaration%20Merging.md).
 
-```ts
-// Disposable
-isDisposed: boolean = false;
-dispose: () => void;
-// Activatable
-isActive: boolean = false;
-activate: () => void;
-deactivate: () => void;
-```
+This treats the classes as interfaces, and only mixes the types behind Disposable and Activatable into the SmartObject type rather than the implementation. This means that we'll have to provide the implementation in class.
+Except, that's exactly what we want to avoid by using mixins.
 
-Finally, we mix our mixins into the class, creating the full implementation.
+Finally, we mix our mixins into the class implementation.
 
 ```ts
 applyMixins(SmartObject, [Disposable, Activatable]);