anchor.diff:  === Scheduling Tasks
   
   In addition to the promise abstraction, this library also comes with a
  -lightweight abstraction for scheduling task to be executed at some
  -time in future:
  +lightweight abstraction for scheduling task to be executed at some time in
  +future:
   
   .Example using the `schedule` function.
   [source, clojure]
  
positive.code: (p/promise (ex-info "error" {}))
  ----
  
  The `promise` consturctor function automatcially coerce the value to
  the approprite promise, returning rejected promises for exceptions and
  resolved promises for the rest of values.
  
  If you already known the value and want to create resolved or rejected
  promise instances, yo can use `resolved` and `rejected` functions:
  
  [source, clojure]
  ----
  (require '[promesa.core :as p])
  
  ;; Create a resolved promise
  (p/resoved 1)
  ;; => #<Promise [~]>
  
  ;; Create a rejected promise
  (p/rejected (ex-info "error" {}))
  ;; => #<Promise [~]>
  ----
  
  They are more performant because they does not perform any polimorphic
  coercion on the value. They create the promise with the provided value
  as-is.
  
  Another option is to create an empty promise using the `deferred` function
  and provide the value asynchronously using `p/resolve!` and `p/reject!`:
  
negative.code: (defn sleep
    [ms]
    (let [p (p/deferred)]
      (future (p/resolve! p))
      p))
  ----
  
  Another option is using a factory function. If you are familiar with JavaScript,
  this is a similar approach.
  
  .Example creating a promise instance using a factory.
  [source, clojure]
  