bump microsite version, update tuts

Author: jcouyang

build.sbt

@@ -1,4 +1,4 @@
-lazy val docs = (project in file("./docs"))
+lazy val docs = project
   .enablePlugins(MicrositesPlugin)
   .settings(
     micrositeName := "xReact",

docs/src/main/tut/index.md

@@ -19,21 +19,21 @@ npm install xreact --save
 yarn add xreact
 ```
 
-- Come from redux? :point_right: <https://xreact.oyanglul.us/Get-Started.html>
-- Come from fantasy land? :rainbow: <https://xreact.oyanglul.us/Fantasy.html>
-- Examples :point_down:
+- Come from redux? 👉 <https://xreact.oyanglul.us/Get-Started.html>
+- Come from fantasy land? 🌈 <https://xreact.oyanglul.us/Fantasy.html>
+- Examples 👇
   - <https://github.com/reactive-react/xreact/tree/master/examples>
   - <https://xreact.oyanglul.us/Examples.html>
 
 ## Features
 
 ### Purely Functional, Declarative, and Monadic
-In imperatively written code, you describe step-by-step how to process data.  With `xreact`, we simply define data transformations, then compose them to form our data flow. There are no variables, no intermediate state, and no side effects in your data flow's data composition!
+In imperatively code, you have to describe verbose of how to process data.  With `xreact`, we simply define data transformations, then compose them to form data flow. There are no variables, no intermediate state, and no side effects in your data flow's data composition!
 
 ### Typesafe and scalable
-xReact is 100% Typescript!, abstract Stream as Higher Kind type so easier to bring new FRP lib to integrete with xreact.
+xReact is 100% Typescript! Turn your runtime bugs into compile time errors, fail and fix early.
 
-### Composable and Reusable `Plan`
+### High level but 0 cost abstraction
 In Redux, reducers' use of `switch` statements can make them difficult to compose. Unlike reducers, the function `x` return is simply a function which can easily compose.
 
 ```js
@@ -43,25 +43,22 @@ const plan1_x_plan2_x = compose(x(plan1), x(plan2))
 const Counter = plan1_x_plan2_x(CounterView)
 ```
 
-what really happen behind compose is actually ES6 style mixin, so there won't be any extra layer of HoC and no any performance overhead.
+What really happen behind compose is actually ES6 style mixin, so there won't be any extra layer of HoC and no any performance overhead.
 
-### Easy to test, no need for mocks
-Because UI and UI behavior are loosely coupled, you can test a React component by just passing it data. Behaviors can be tested by calling actions and then verifying the state.
-
-### Async actions made easy
+### Asynchronous made easy
 Asynchronous functions, such as Promises, can be converted to a stream and then flat-mapped.
 
 ```js
 intent$.filter(x=>x.kind=='rest')
-  .flatMap(({url}) => Observable.fromPromise(fetch(url)))
+  .flatMap(({url}) => fromPromise(fetch(url)))
 ```
 
-where `fetch(url)` will return a `Promise`,
+where `fetch(url)` will return a `Promise`, and fromPromise will transform a `Promise` into `Observable`, so you can flat it in intent stream which is also a `Observable`.
 
 ### Reactive libs of your choice
-xReact came with 2 FRP libs of choices, rxjs and mostjs, for any new lib you only need to implement the `StaticStream` with your prefered lib as Higher Kind Type.
+xReact came with 2 FRP libs of choices, rxjs and mostjs, for any new libs you only need to implement the `StaticStream` with your preferred lib as Higher Kind Type, just like how we done for [mostjs](https://github.com/reactive-react/xreact/blob/master/src/xs/most.ts).
 
-more details about HKT implementation in TypeScript is [here](https://github.com/gcanti/fp-ts)
+More details about HKT implementation in TypeScript is [here](https://github.com/gcanti/fp-ts), but you don't really need to know this.
 
 ## Copyright and License
 All code is available to you under the MIT license. The design is informed by many other projects:

project/plugins.sbt

@@ -1 +1 @@
-addSbtPlugin("com.47deg"  % "sbt-microsites" % "0.6.1")
+addSbtPlugin("com.47deg"  % "sbt-microsites" % "0.6.3")