anchor.diff:  ----
   
   It there are also circumstances where you only want arbitrary select of the
  -first resolved promise. For this case, you can use the `some` combinator:
  -
  -[source, clojure]
  -----
  -(let [p (p/some 2 [(p/delay 100 1)
  -                   (p/delay 200 2)
  -                   (p/delay 120 3)])]
  -  (p/then p (fn [[x y]]
  -              (.log js/console "The first two finished: " x y))))
  -----
  -
  -There is a helper function called `any` that works very similar to `some` with
  -`1` as the first argument. It returns a promise that will be fulfilled with one
  -value instead of an array with the length of 1.
  +first resolved promise. For this case, you can use the `any` combinator:
   
   [source, clojure]
   ----
  
positive.code:              (resolve 1)))
  ----
  
  
  === Simple chaining
  
  It there different ways to compose/chain computations using promises. We will start
  with the basic: lineal way of chaining computations.
  
  That can be done using `then` or `chain` functions exposed in `promissum.core`
  namespace. Bot them are mainly interchangeable. The main differencia is that
  `chain` is variadic and `then` not.
  
  [source, clojure]
  ----
  
negative.code: git clone https://github.com/funcool/promesa
  ----
  
  
  === Run tests
  
  To run the tests execute the following:
  
  For the JVM platform:
  
  [source, text]
  ----
  lein test
  ----
  
  And for JS platform:
  
  [source, text]
  ----
  ./scripts/build
  node out/tests.js
  ----
  
  You will need to have nodejs installed on your system.
  
  
  === License
  