anchor.diff:  The `then` function takes one argument: a callback that will be called when the promise
   is successfully resolved.
   
  -But `then` is not the end, it also returns a promise that will be resolved or rejected depending
  -on return value of the first chain callback. That will allow you to compose async computations
  -in an easy way.
  +But `then` is not the end, it also returns a promise that will be resolved or rejected
  +depending on return value of the first chain callback. That will allow you to compose
  +async computations in an easy way.
   
   [source, clojure]
   ----
  
positive.code:               (.log js/console "The first one finished: " x))))
  ----
  
  === Sugar syntax
  
  Promises are one of the most used primitives for the composition of async functions. 
  However, using promises _as is_ doesn't save you from callback hell.
  
  The upcoming ES7 standard will introduce syntactic sugar for working with promises in a 
  less painful way by introducing the new `async` and `await` keywords. You can read more 
  about them link:http://jakearchibald.com/2014/es7-async-functions/[here] and
  link:http://pouchdb.com/2015/03/05/taming-the-async-beast-with-es7.html[here].
  
  
negative.code: ;; => #<Promise [1]>
  ----
  
  If a `promise` function receives a plain value, it returns a resolved promise with the
  provided plain value. If it receives an instance of `Error`, it returns a rejected
  promise.
  
  And finally it also 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.
  
  [source, clojure]
  ----
  