Tiny style fixes

Author: gaearon

docs/basics/DataFlow.md

@@ -18,7 +18,7 @@ The data lifecycle in any Redux app follows these 4 steps:
     { type: 'ADD_TODO', text: 'Read the Redux docs.'};
     ```
 
-  Think of an action as a very brief snippet of news. “Mary liked article 42.” or “'Read the Redux docs.' was added to the list of todos.”
+  Think of an action as a very brief snippet of news. “Mary liked article 42.” or “‘Read the Redux docs.’ was added to the list of todos.”
 
   You can call [`store.dispatch(action)`](../api/Store.md#dispatch) from anywhere in your app, including components and XHR callbacks, or even at scheduled intervals.
 

docs/basics/Reducers.md

@@ -32,7 +32,7 @@ You’ll often find that you need to store some data, as well as some UI state,
 
 ## Handling Actions
 
-Now that we've decided what our state object looks like, we're ready to write a reducer for it. The reducer is a pure function that takes the previous state and an action, and returns the next state.
+Now that we’ve decided what our state object looks like, we’re ready to write a reducer for it. The reducer is a pure function that takes the previous state and an action, and returns the next state.
 
 ```js
 (previousState, action) => newState

docs/basics/UsageWithReact.md

@@ -216,7 +216,7 @@ Footer.propTypes = {
 };
 ```
 
-That's it! We can verify that they work correctly by writing a dummy `App` to render them:
+That’s it! We can verify that they work correctly by writing a dummy `App` to render them:
 
 #### `containers/App.js`
 
@@ -369,7 +369,7 @@ function select(state) {
 export default connect(select)(App);
 ```
 
-That's it! The tiny todo app now functions correctly.
+That’s it! The tiny todo app now functions correctly.
 
 ## Next Steps
 

docs/introduction/Motivation.md

@@ -2,7 +2,7 @@
 
 As the requirements to JavaScript single-page applications get more sophisticated, **more state than ever before needs to be managed by the JavaScript code.** This state may include server responses, cached data, and data created locally, but not yet persisted to the server. It also includes the UI state, such as the active route, the selected tab, whether to show a spinner or pagination controls, and so on.
 
-Managing ever-changing state is hard. If a model can update another model, then a view can update a model that updates another model, and this, in turn, might cause another view to update. At some point you no longer know what happens in your app. **You no longer control when, why, and how the state is updated.** When the system is opaque and non-deterministic, it's hard to reproduce bugs or add new features.
+Managing ever-changing state is hard. If a model can update another model, then a view can update a model that updates another model, and this, in turn, might cause another view to update. At some point you no longer know what happens in your app. **You no longer control when, why, and how the state is updated.** When the system is opaque and non-deterministic, it’s hard to reproduce bugs or add new features.
 
 As if this wasn’t bad enough, consider the **new requirements that are becoming common in front-end product development**, such as handling optimistic updates, rendering on the server, fetching the data before performing route transitions, and so on. We the front-end developers are finding ourselves surrounded by complexity we never had to deal with before. [Is it time we give up?](http://www.quirksmode.org/blog/archives/2015/07/stop_pushing_th.html)
 

docs/introduction/PriorArt.md

@@ -29,7 +29,7 @@ Unlike Redux, Elm is a language, so it is able to benefit from static typing for
 
 Immutable and most similar libraries are orthogonal to Redux. Feel free to use them together!
 
-**Redux doesn’t care *how* you store the state — it can be a plain object, an Immutable object, or anything else.** You’ll probably want a (de)serialization mechanism for writing universal apps and hydrating their state from the server, but other than that, you can use any data storage library *as long as it supports immutability*. For example, it doesn’t make sense to use Backbone for Redux state, because Backbone models are mutable.
+**Redux doesn’t care *how* you store the state—it can be a plain object, an Immutable object, or anything else.** You’ll probably want a (de)serialization mechanism for writing universal apps and hydrating their state from the server, but other than that, you can use any data storage library *as long as it supports immutability*. For example, it doesn’t make sense to use Backbone for Redux state, because Backbone models are mutable.
 
 Note that, even if your immutable library supports cursors, you shouldn’t use them in a Redux app. The whole state tree should be considered read-only, and you should use Redux for updating the state, and subscribing to the updates. Therefore writing via cursor doesn’t make sense for Redux. **If your only use case for cursors is decoupling the state tree from the UI tree and gradually refining the cursors, you should look at selectors instead.** Selectors are composable getter functions. See [reselect](http://github.com/faassen/reselect) for a really great and concise implementation of composable selectors.
 
@@ -61,6 +61,6 @@ function toObservable(store) {
 
 Similarly, you can compose different asynchronous streams to turn them into actions before feeding them to `store.dispatch()`.
 
-The question is: do you really need Redux if you already use Rx? Maybe not. It's not hard to [re-implement Redux in Rx](https://github.com/jas-chen/rx-redux). Some say it's a two-liner using Rx `.scan()` method. It may very well be!
+The question is: do you really need Redux if you already use Rx? Maybe not. It’s not hard to [re-implement Redux in Rx](https://github.com/jas-chen/rx-redux). Some say it’s a two-liner using Rx `.scan()` method. It may very well be!
 
 If you’re in doubt, check out the Redux source code (there isn’t much going on there), as well as its ecosystem (for example, [the developer tools](https://github.com/gaearon/redux-devtools)). If you don’t care too much about it and want to go with the reactive data flow all the way, you might want to explore something like [Cycle](http://cycle.js.org) instead, or even combine it with Redux. Let us know how it goes!

docs/introduction/ThreePrinciples.md

@@ -82,4 +82,4 @@ let reducer = combineReducers({ visibilityFilter, todos });
 let store = createStore(reducer);
 ```
 
-That's it! Now you know what Redux is all about.
+That’s it! Now you know what Redux is all about.