anchor.diff:  
   [NOTE]
   ====
  -ClojureScript usage: if you're getting "Should be only used in alet macro." error, perhaps you forgot to add `:include-macros true` to the `require`.
  -====
  -
  -The `alet` macro behaves identical to the `let` with the exception that it
  -always return a promise and allows mark async operations with `await` placeholder
  -making it looks like synchronous opetation.
  +ClojureScript usage: if you're getting "Should be only used in alet macro." error,
  +perhaps you forgot to add `:include-macros true` to the `require`.
  +====
  +
  +The `alet` macro behaves identical to the `let` with the exception that it always
  +return a promise and allows mark async operations with `await` placeholder making it
  +looks like synchronous opetation.
   
   If an error occurs at any step the entire composition will be short-circuited,
   returning exceptionally resolved promise.
   
  -If you are not familiar with `async`/`await` syntax, you can read more
  -about it link:http://jakearchibald.com/2014/es7-async-functions/[here].
  +If you are not familiar with `async`/`await` syntax, you can read more about it
  +link:http://jakearchibald.com/2014/es7-async-functions/[here].
   
   
   === Error handling
   
  -One of the advantages of using promise abstraction is that it natively has
  -a notion of error, so you don't need reinvent it. If some of the computations
  -of the composed promise chain/pipeline raises an exception, that one is
  -automatically propagated to the last promise making the effect of short-circuiting.
  +One of the advantages of using promise abstraction is that it natively has a notion
  +of error, so you don't need reinvent it. If some of the computations of the composed
  +promise chain/pipeline raises an exception, that one is automatically propagated to
  +the last promise making the effect of short-circuiting.
   
   Let see an example:
   
  
positive.code: the provided plain value. If it receives an instance of `Error`, it returns a
  rejected promise.
  
  Also, it accepts a factory callback that receives two callable parameters:
  `resolve` and `reject`. So you can use one or other to resolve or reject the promise
  respectively.
  
  .Example creating promise instance using a factory.
  
negative.code: ----
  
  It there also `mapcat` function that allows remove one neesting level of promises,
  and is pretty useful if the function that you want to apply to promise also return a
  promise instance instead of value:
  
  [source, clojure]
  ----
  