documented discriminated unions + redux with typescript

closes #166

Author: Basarat Ali Syed

docs/types/discriminated-unions.md

@@ -107,19 +107,83 @@ function area(s: Shape) {
 
 [references-discriminated-union]:https://github.com/Microsoft/TypeScript/pull/9163
 
-### strictNullChecks 
+### strictNullChecks
 
-If using strictNullChecks and doing exhaustive checks you should return the `_exhaustiveCheck` variable (of type `never`) as well, otherwise TypeScirpt infers a possible return of `undefined`. So: 
+If using strictNullChecks and doing exhaustive checks you should return the `_exhaustiveCheck` variable (of type `never`) as well, otherwise TypeScirpt infers a possible return of `undefined`. So:
 
 ```ts
 function area(s: Shape) {
     switch (s.kind) {
         case "square": return s.size * s.size;
         case "rectangle": return s.width * s.height;
         case "circle": return Math.PI * s.radius * s.radius;
-        default: 
+        default:
           const _exhaustiveCheck: never = s;
           return _exhaustiveCheck;
     }
 }
 ```
+
+### Redux
+
+A popular library that makes use of this is redux.
+
+Here is the [*gist of redux*](https://github.com/reactjs/redux#the-gist) with TypeScript type annotations added:
+
+```ts
+import { createStore } from 'redux'
+
+type Action
+  = {
+    type: 'INCREMENT'
+  }
+  | {
+    type: 'DECREMENT'
+  }
+
+/**
+ * This is a reducer, a pure function with (state, action) => state signature.
+ * It describes how an action transforms the state into the next state.
+ *
+ * The shape of the state is up to you: it can be a primitive, an array, an object,
+ * or even an Immutable.js data structure. The only important part is that you should
+ * not mutate the state object, but return a new object if the state changes.
+ *
+ * In this example, we use a `switch` statement and strings, but you can use a helper that
+ * follows a different convention (such as function maps) if it makes sense for your
+ * project.
+ */
+function counter(state = 0, action: Action) {
+  switch (action.type) {
+  case 'INCREMENT':
+    return state + 1
+  case 'DECREMENT':
+    return state - 1
+  default:
+    return state
+  }
+}
+
+// Create a Redux store holding the state of your app.
+// Its API is { subscribe, dispatch, getState }.
+let store = createStore(counter)
+
+// You can use subscribe() to update the UI in response to state changes.
+// Normally you'd use a view binding library (e.g. React Redux) rather than subscribe() directly.
+// However it can also be handy to persist the current state in the localStorage.
+
+store.subscribe(() =>
+  console.log(store.getState())
+)
+
+// The only way to mutate the internal state is to dispatch an action.
+// The actions can be serialized, logged or stored and later replayed.
+store.dispatch({ type: 'INCREMENT' })
+// 1
+store.dispatch({ type: 'INCREMENT' })
+// 2
+store.dispatch({ type: 'DECREMENT' })
+// 1
+```
+
+Using it with TypeScript gives you safety against typo errors, increased refactor-ability and self documenting code .