anchor.diff:  ----
   
   The `then` function takes one argument: a callback that will be called when the promise
  -successfully resolved.
  -
  -But `then` is not the end, it also returns a promise that will resolved or rejected depending
  -on return value of the first chain callback. That will allow compose async computations
  +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.
   
   [source, clojure]
  
positive.code: Behind the scenes, the _promise_ library implements and uses monadic abstractions. And in this
  case, the _Promise_ type implements a _Functor_ and _Monad_ abstractions.
  
  This part of documentation, requires a minimal knowledge about that concepts but is not mandatory
  to kwnon and read this part for use the library.
  
  Previously we have seen the `mlet` macro that does very similar things to the ES7 `async`
  and `await` sugar syntax.
  
  The main difference with ES7 syntax is that is not bound only to promises, is a generic and
  extensible abstraction that allows work with different kind of types and different types of
  logic for composition of computations.
  
  Please, read the link:http://funcool.github.io/cats/latest/[cats documentation] for see other types and other abstractions.
  
  
  == Contribute
  
  **promesa** unlike Clojure and other Clojure contrib libs, does not have many
  restrictions for contributions. Just follow open a issue or pull request.
  
  
  == Run tests
  
  For run tests just execute this:
  
  [source, text]
  ----
  lein cljsbuild test
  ----
  
  You should have nodejs or iojs installed in your system or any node version manager
  like **nvm**.
  
  
  
negative.code:               (.log js/console "Result: " result))))
  ----
  
  The standard promise library and JavaScript do not offer a standard way of chaining
  promises in sequence in that situation we use the _cats_ library `>>=` function.
  
  The _cats_ library offers monad abstractions and helpers to work with them, but do not worry,
  you don't need to understand anything related to monads. Just use the `>>=` function as a helper
  to chain together a sequence of promises.
  
  
  === Parallelism
  
  JavaScript environments like browsers or nodejs are pretty good at parallelizing IO operations
  like downloading content, using ajax or reading a file in nodejs.
  
  [source, clojure]
  ----
  