├── .gitignore
├── LICENSE
├── README.md
├── examples
    ├── css
    │   └── styles.css
    ├── index.html
    └── src
    │   ├── examples.cljs
    │   └── examples
    │       ├── github_search.cljs
    │       └── replicated_search.cljs
├── project.clj
└── src
    └── cljs_promises
        ├── async.clj
        ├── async.cljs
        └── core.cljs


/.gitignore:
--------------------------------------------------------------------------------
 1 | pom.xml
 2 | *jar
 3 | /lib/
 4 | /classes/
 5 | /out/
 6 | /target/
 7 | .lein-deps-sum
 8 | .lein-repl-history
 9 | .lein-plugins/
10 | 
11 | .nrepl-port
12 | 
13 | /examples/out/
14 | /examples/js/
15 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 James MacAulay
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # cljs-promises
  2 | 
  3 | A ClojureScript library for working with JavaScript promises.
  4 | 
  5 | ### Overview
  6 | 
  7 | This library leverages the power of [core.async](https://github.com/clojure/core.async) to let you write promise code like this:
  8 | 
  9 | ```clojure
 10 | (cljs-promises.async/extend-promises-as-pair-channels!)
 11 | 
 12 | (go
 13 |  (let [user-promise (get-user "jamesmacaulay")]
 14 |    (try
 15 |      (println (:blog (<? user-promise)))
 16 |      (catch js/Error e
 17 |        (println (str "Could't get user data: " (ex-message e))))))
 18 | ```
 19 | 
 20 | The first line globally extends `Promise` instances to act like **read-only channels** which, once resolved, **endlessly produce the same value or error to anyone who takes from them**. Because promises have built-in error semantics which don't have any direct corollary in core.async, there are different ways that we can represent promise results. In this example we've extended promises in a way that values taken from them with core.async are actually `[value error]` pairs, where you get `[value nil]` from a fulfilled promise and `[nil error]` from a rejected promise.
 21 | 
 22 | `<?` is a macro provided by `cljs-promises.async` which takes one of these pairs from a promise with core.async's `<!`. If the `error` slot of the pair is non-nil, it throws the error. Otherwise it returns whatever is in the `value` slot.
 23 | 
 24 | If you want to customize how a promise's resolution translates to values you get from `<!`, you can use the more general `extend-promises-as-channels!` which lets you provide your own transform functions for fulfilled values and rejected errors.
 25 | 
 26 | If you don't want to globally extend promises like this at all (a good idea if you're writing a library or for some other reason don't want to mess with the global scope), the `cljs-promises.async` namespace also provides functions which wrap promises on an ad-hoc basis:
 27 | 
 28 | * `cljs-promises.async/pair-port` takes a promise and gives you an object which acts like a read-only channel of `[value error]` pairs as described above.
 29 | * `cljs-promises.async/value-port` gives you a `ReadPort` of only resolved values, or `nil` values if a promise is rejected.
 30 | * `cljs-promises.async/error-port` is the reverse of `value-port` and gives you just the errors.
 31 | 
 32 | ### Requirements
 33 | 
 34 | Some functions in this library require that you've already got an ES6 Promise implementation present, either natively or through a [polyfill](https://github.com/jakearchibald/es6-promise). Other functions only require that you're giving them [Promises/A+](http://promises-aplus.github.io/promises-spec/)-compliant promise objects.
 35 | 
 36 | ### Rationale
 37 | 
 38 | We have [CSP](http://en.wikipedia.org/wiki/Communicating_sequential_processes) with core.async, so [why bother with promises](http://swannodette.github.io/2013/08/23/make-no-promises/)? Promises provide very different concurrency semantics compared with CSP channels. While channels provide a powerful abstraction for _passing messages and synchronizing execution_, a promise simply represents a single "eventual value".
 39 | 
 40 | This means that HTTP and most filesytem operations are very well suited for promises. Meanwhile, promises are _not_ appropriate for coordinating streams of spontaneous events like key presses or data coming in on a WebSocket. Channels are still the bees' knees when it comes to that kind of thing.
 41 | 
 42 | Promises excel at representing single values because they are an **immutable** reference type:
 43 | 
 44 | * after a promise is created, the ability to resolve it to a value is not part of its public interface
 45 | * a promise only ever resolves to a single fulfilled value or rejected error
 46 | * once resolved, a promise will continue to provide its value or error to anyone who asks for it
 47 | 
 48 | (Sounds a lot like [futures](http://clojuredocs.org/clojure_core/clojure.core/future) in Clojure, doesn't it?)
 49 | 
 50 | Channels in core.async are very different: they are inherently mutable. When you take a value from a channel, it is gone from that channel and no one else will see it. Here's how you might do a JSONP request in core.async:
 51 | 
 52 | ```clojure
 53 | ;; jsonp function lifted from http://swannodette.github.io/2013/11/07/clojurescript-101/
 54 | (defn jsonp [uri]
 55 |   (let [out (chan)
 56 |         req (Jsonp. (Uri. uri))]
 57 |     (.send req nil (fn [res] (put! out res)))
 58 |     out))
 59 | 
 60 | (let [uri "http://en.wikipedia.org/w/api.php?action=opensearch&format=json&search=clojure"]
 61 |   (go (println (<! (jsonp uri)))))
 62 | ```
 63 | 
 64 | This is fine, but it means that you have to treat the return value of `jsonp` as a single-use wrapper which becomes useless after its value has been taken from it.
 65 | 
 66 | If you want to be able to _share_ representations of delayed or partially-delayed values (e.g. nested data structures with some values yet to arrive), then promises are a better fit. Because they are immutable, you can share them between different parts of your code and not have to worry about how they'll be used.
 67 | 
 68 | Here's some code which builds a map of promises for different kinds of data about a GitHub user:
 69 | 
 70 | ```clojure
 71 | (defn build-view-context
 72 |   [username]
 73 |   {:user (github-get (str "/users/" username))
 74 |    :gists (github-get (str "/users/" username "/gists"))
 75 |    :repos (github-get (str "/users/" username "/repos?sort=created"))
 76 |    :events (github-get (str "/users/" username "/events"))})
 77 | ```
 78 | 
 79 | This map can be shared among multiple view functions, and each of those functions can depend on any subset of the included promises. The code which builds a context of eventual values doesn't need to know how those values are going to be used.
 80 | 
 81 | I'm sure there are various possibilities available with core.async channels to decouple things in similar ways. There is [mult](http://clojure.github.io/core.async/#clojure.core.async/mult), and [pub](http://clojure.github.io/core.async/#clojure.core.async/pub)/[sub](http://clojure.github.io/core.async/#clojure.core.async/sub), and probably other tools that would help. I would argue, however, that the simplicity of promises makes them a better tool for this particular job.
 82 | 
 83 | One of the great things about core.async, though, is that its channels are based on a simple interface composed of a handful of very granular ClojureScript protocols! This means that it's actually really easy to make custom types which act like channels _just enough_ to play nice with the rest of core.async.
 84 | 
 85 | ### Development
 86 | 
 87 | I've been developing cljs-promises with [Light Table](http://www.lighttable.com/), mostly by playing with the examples:
 88 | 
 89 | * run `lein cljsbuild auto examples` in the project root to watch the filesystem and compile-on-save
 90 | * add a Light Table connection to an external browser and copy the port number from the script tag
 91 | * edit `examples/index.html` so that the script tag matches the port
 92 | * open up `examples/index.html` in a browser
 93 | 
 94 | Then you can eval individual forms from Light Table and save-and-refresh whenever you make big changes.
 95 | 
 96 | ### Thanks
 97 | 
 98 | Special thanks to [David Nolen](http://swannodette.github.io/) for writing so much fantastic code and introductory material for newcomers to ClojureScript and especially core.async. I've adapted or copied some code from his blog in this library (especially the examples), and I've tried to make attribution notes in the code comments wherever appropriate.
 99 | 
100 | ### License
101 | 
102 | This code is released under an MIT license.
103 | 
104 | Copyright 2014 James MacAulay.
105 | 


--------------------------------------------------------------------------------
/examples/css/styles.css:
--------------------------------------------------------------------------------
 1 | body {
 2 |   font-family: Helvetica;
 3 | }
 4 | 
 5 | .example {
 6 |   margin: 10px;
 7 |   padding: 10px;
 8 |   width: 500px;
 9 |   background: #eee;
10 | }
11 | 
12 | .avatar {
13 |   width: 30px;
14 | }
15 | 


--------------------------------------------------------------------------------
/examples/index.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 |     <head>
 3 |         <script type='text/javascript' id='lt_ws' src='http://localhost:54470/socket.io/lighttable/ws.js'></script>
 4 |         <link rel="stylesheet" type="text/css" href="css/styles.css">
 5 |     </head>
 6 |     <body>
 7 | 
 8 |         <div class="example">
 9 |             <h2>replicated_search.cljs</h2>
10 |             <button id="replicated-search">Fake Replicated Search</button>
11 |             <div id="replicated-output"></div>
12 |         </div>
13 | 
14 |         <div class="example">
15 |             <h2>github_search.cljs</h2>
16 |             <label for="github-username">GitHub Username</label>
17 |             <input id="github-username" name="github-username">
18 |             <button id="github-search">Search</button>
19 |             <div id="github-container">
20 |                 <h3 id="github-username-header"></h3>
21 |                 <div id="github-avatar"></div>
22 |                 <div id="github-summary"></div>
23 |                 <div id="github-latest"></div>
24 |             </div>
25 |         </div>
26 | 
27 |         <script src="http://s3.amazonaws.com/es6-promises/promise-0.1.1.js" type="text/javascript"></script>
28 |         <script src="out/goog/base.js" type="text/javascript"></script>
29 |         <script src="js/examples.js" type="text/javascript"></script>
30 |         <script type="text/javascript">goog.require("examples");</script>
31 |     </body>
32 | </html>
33 | 


--------------------------------------------------------------------------------
/examples/src/examples.cljs:
--------------------------------------------------------------------------------
1 | (ns examples
2 |   (:require [examples.github-search]
3 |             [examples.replicated-search]))
4 | 
5 | (enable-console-print!)
6 | 
7 | (cljs-promises.async/extend-promises-as-pair-channels!)
8 | 


--------------------------------------------------------------------------------
/examples/src/examples/github_search.cljs:
--------------------------------------------------------------------------------
  1 | (ns examples.github-search
  2 |   (:require-macros [cljs.core.async.macros :refer [go]])
  3 |   (:require [cljs-promises.core :as p]
  4 |             [cljs-promises.async :refer-macros [<?]]
  5 |             [goog.dom :as dom]
  6 |             [goog.events :as events]
  7 |             [cljs.core.async :refer [put! chan <!]])
  8 |   (:import [goog.net Jsonp]
  9 |            [goog Uri]))
 10 | 
 11 | (defn jsonp
 12 |   "Performs a JSONP request to the given URL and returns a promise of the
 13 |   response."
 14 |   [url]
 15 |   (p/promise (fn [resolve _]
 16 |                (let [req (Jsonp. (Uri. url))]
 17 |                  (.send req nil resolve)))))
 18 | 
 19 | (defn github-get
 20 |   "Performs a JSONP request to the public GitHub API at the given path, and
 21 |   returns a promise of the response's data payload as a ClojureScript map
 22 |   or vector. The promise will reject with an API-specific error if the response
 23 |   status is not 200."
 24 |   [path]
 25 |   (let [url (str "https://api.github.com" path)]
 26 |     (-> (jsonp url)
 27 |         (p/then (fn [response]
 28 |                   (let [response (js->clj response :keywordize-keys true)]
 29 |                     (if (-> response :meta :status (= 200))
 30 |                       (:data response)
 31 |                       (throw (ex-info (-> response :data :message)
 32 |                                       response)))))))))
 33 | 
 34 | (defn build-view-context
 35 |   "Returns a map of promises for various GitHub resources associated with the
 36 |   given user."
 37 |   [username]
 38 |   {:user (github-get (str "/users/" username))
 39 |    :gists (github-get (str "/users/" username "/gists"))
 40 |    :repos (github-get (str "/users/" username "/repos?sort=created"))
 41 |    :events (github-get (str "/users/" username "/events"))})
 42 | 
 43 | (defn link-to [text url]
 44 |   (str "<a href=\"" url "\">" text "</a>"))
 45 | 
 46 | (defn avatar-view
 47 |   "Takes a user map from the GitHub API and returns some HTML for the user's
 48 |   avatar."
 49 |   [user]
 50 |   (-> (str "<img class=\"avatar\" src=\"" (:avatar_url user) "\">")
 51 |       (link-to (:html_url user))))
 52 | 
 53 | (defn summary-view
 54 |   "Takes a user map, a collection of gists, and a collection of repos, and
 55 |   returns a little summary of things."
 56 |   [user gists repos]
 57 |   (let [how-many #(let [n (count %)]
 58 |                     (if (>= n 30)
 59 |                       "lots of"
 60 |                       n))]
 61 |     (str (:login user) " has " (how-many gists) " gists and " (how-many repos) " repos.")))
 62 | 
 63 | (defn latest-view
 64 |   "Returns an HTML list describing the latest gist, repo, and event from the
 65 |   arguments."
 66 |   [gists repos events]
 67 |   (let [[gist repo event] (map first [gists repos events])
 68 |         gist-link (-> (or (:description gist)
 69 |                           (:html_url gist))
 70 |                       (link-to (:html_url gist)))
 71 |         repo-link (-> (:name repo)
 72 |                                  (link-to (:html_url repo)))
 73 |         event-link (if-let [name (-> event :repo :name)]
 74 |                      (link-to name (str "https://github.com/" name)))
 75 |         event-desc (str (:type event) (when event-link
 76 |                                         (str " on " event-link)))]
 77 |     (str "<ul>"
 78 |          "<li>latest gist: " gist-link "</li>"
 79 |          "<li>latest repo: " repo-link "</li>"
 80 |          "<li>latest event: " event-desc "</li>"
 81 |          "</ul>")))
 82 | 
 83 | ;; A map of DOM IDs to view description vectors. The first item of each vector
 84 | ;; is a function which should return HTML or plain text. The second item is a
 85 | ;; vector of functions (here we're using keywords) which can be applied to a
 86 | ;; view context map to provide the arguments to the view function.
 87 | (def views
 88 |   {:github-username-header [:login [:user]]
 89 |    :github-avatar [avatar-view [:user]]
 90 |    :github-summary [summary-view [:user :gists :repos]]
 91 |    :github-latest [latest-view [:gists :repos :events]]})
 92 | 
 93 | (defn render!
 94 |   "Takes a view map of DOM IDs to view description vectors, and a context
 95 |   map whose values may be promises. For each view, its argument-supplying
 96 |   functions are applied to the context map. Any promises returned are waited
 97 |   on, after which their resolved values are passed to the view function and
 98 |   the returned text is set as the HTML of the DOM node identified by the key."
 99 |   [view-map context]
100 |   (doseq [[view-id [view-fn args-fns]] view-map]
101 |     (let [node (dom/getElement (name view-id))
102 |           args-promise (p/all ((apply juxt args-fns) context))]
103 |       (go (->> args-promise
104 |                <?
105 |                (apply view-fn)
106 |                (set! (.-innerHTML node)))))))
107 | 
108 | (defn get-username-from-input []
109 |   (.-value (dom/getElement "github-username")))
110 | 
111 | ;; function copied from http://swannodette.github.io/2013/07/12/communicating-sequential-processes/
112 | (defn listen [el type]
113 |   (let [out (chan)]
114 |     (events/listen el type
115 |       (fn [e] (put! out e)))
116 |     out))
117 | 
118 | ;; Listen to clicks on the Search button and then render the views based on
119 | ;; the username in the input field.
120 | (let [el (dom/getElement "github-output")
121 |       c  (listen (dom/getElement "github-search") "click")]
122 |   (go (while true
123 |         (<! c)
124 |         (->> (get-username-from-input)
125 |              build-view-context
126 |              (render! views)))))
127 | 


--------------------------------------------------------------------------------
/examples/src/examples/replicated_search.cljs:
--------------------------------------------------------------------------------
 1 | (ns examples.replicated-search
 2 |   (:require-macros [cljs.core.async.macros :refer [go]])
 3 |   (:require [cljs-promises.core :as p]
 4 |             [cljs-promises.async :refer-macros [<?]]
 5 |             [goog.dom :as dom]
 6 |             [goog.events :as events]
 7 |             [cljs.core.async :as async :refer [put! chan <!]]
 8 |             [cljs.core.async.impl.protocols :as impl]
 9 |             [cljs.core.async.impl.channels :refer [box]]
10 |             [cljs.core.async.impl.dispatch :as dispatch]))
11 | 
12 | ;; adapted from http://swannodette.github.io/2013/07/12/communicating-sequential-processes/
13 | ;; c.f. http://talks.golang.org/2012/concurrency.slide#50
14 | 
15 | (defn fake-search [kind]
16 |   (fn [query]
17 |     (p/promise (fn [resolve _]
18 |                  (js/setTimeout #(resolve [kind query])
19 |                                 (rand-int 100))))))
20 | 
21 | (def web1 (fake-search :web1))
22 | (def web2 (fake-search :web2))
23 | (def image1 (fake-search :image1))
24 | (def image2 (fake-search :image2))
25 | (def video1 (fake-search :video1))
26 | (def video2 (fake-search :video2))
27 | 
28 | (defn google [query]
29 |   (let [t (p/timeout 80)
30 |         web-search (p/race [t (web1 query) (web2 query)])
31 |         image-search (p/race [t (image1 query) (image2 query)])
32 |         video-search (p/race [t (video1 query) (video2 query)])]
33 |     (-> (p/all [web-search image-search video-search])
34 |         (p/then (partial filter identity)))))
35 | 
36 | (defn listen [el type]
37 |   (let [c (chan)]
38 |     (events/listen el type #(put! c %))
39 |     c))
40 | 
41 | (let [el (dom/getElement "replicated-output")
42 |       c  (listen (dom/getElement "replicated-search") "click")]
43 |   (go (while true
44 |         (<! c)
45 |         (dom/setTextContent el (pr-str (<? (google "clojure")))))))
46 | 


--------------------------------------------------------------------------------
/project.clj:
--------------------------------------------------------------------------------
 1 | (defproject jamesmacaulay/cljs-promises "0.1.0"
 2 |   :description "A ClojureScript library for working with JavaScript promises"
 3 | 
 4 |   :url "https://github.com/jamesmacaulay/cljs-promises"
 5 | 
 6 |   :scm {:name "git"
 7 |         :url "https://github.com/jamesmacaulay/cljs-promises"}
 8 | 
 9 |   :license {:name "MIT License"
10 |             :url "http://opensource.org/licenses/MIT"}
11 | 
12 |   :dependencies [[org.clojure/clojurescript "0.0-2156"]
13 |                  [org.clojure/core.async "0.1.267.0-0d7780-alpha"]]
14 | 
15 |   :plugins [[lein-cljsbuild "1.0.2"]]
16 | 
17 |   :source-paths ["src"]
18 | 
19 |   :cljsbuild {
20 |     :builds [{:id "examples"
21 |               :source-paths ["src" "examples/src"]
22 |               :compiler {
23 |                 :output-to "examples/js/examples.js"
24 |                 :output-dir "examples/out"
25 |                 :optimizations :none
26 |                 :source-map true}}]})
27 | 


--------------------------------------------------------------------------------
/src/cljs_promises/async.clj:
--------------------------------------------------------------------------------
 1 | (ns cljs-promises.async)
 2 | 
 3 | ;; Thanks to David Nolen for the name of this macro! http://swannodette.github.io/2013/08/31/asynchronous-error-handling/
 4 | ;; ...this version works a bit differently, though:
 5 | (defmacro <?
 6 |   "Expects `expr` to be a channel or ReadPort which produces [value nil] or
 7 |   [nil error] pairs, and returns values and throws errors as per `consume-pair`."
 8 |   [expr]
 9 |   `(cljs-promises.async/consume-pair (cljs.core.async/<! ~expr)))
10 | 


--------------------------------------------------------------------------------
/src/cljs_promises/async.cljs:
--------------------------------------------------------------------------------
  1 | (ns cljs-promises.async
  2 |   (:require [cljs.core.async :as async]
  3 |             [cljs.core.async.impl.protocols :as impl]
  4 |             [cljs.core.async.impl.dispatch :as dispatch]
  5 |             [cljs-promises.core]))
  6 | 
  7 | (defn extend-promises-as-channels!
  8 |   "If you want, you can globally extend Promise to act as a one-way channel which
  9 |   can only be taken from, and which starts producing a never-ending stream of constants
 10 |   once the promise resolves. `value-transform` and `error-transform` are functions
 11 |   which are applied to the value or error when the Promise resolves or rejects.
 12 |   Both `value-transform` and `error-transform` default to identity. Takes an optional
 13 |   `promise-constructor` to extend, defaulting to `js/Promise`."
 14 |   ([]
 15 |    (extend-promises-as-channels! identity))
 16 |   ([value-transform]
 17 |    (extend-promises-as-channels! value-transform identity))
 18 |   ([value-transform error-transform]
 19 |    (extend-promises-as-channels! value-transform error-transform js/Promise))
 20 |   ([value-transform error-transform promise-constructor]
 21 |    (extend-type promise-constructor
 22 |      impl/ReadPort
 23 |      (take! [promise handler]
 24 |        (.then promise
 25 |               ;; `cljs.core.async.impl.dispatch/run` runs the handler in the next
 26 |               ;; run of the event loop, making it possible here for errors avoid
 27 |               ;; promises' error capturing. Otherwise, errors from the promise can
 28 |               ;; never escape `go` blocks.
 29 |               (fn [val]
 30 |                (dispatch/run #((impl/commit handler) (value-transform val))))
 31 |               (fn [err]
 32 |                (dispatch/run #((impl/commit handler) (error-transform err)))))
 33 |        nil) ;; return nil to say "we're waiting on the value"
 34 |      impl/Channel
 35 |      (close! [_]))))
 36 | 
 37 | (defn extend-promises-as-pair-channels!
 38 |   "Globally extends Promises with `extend-promises-as-channels!` such that the
 39 |   values taken from them are vector pairs of [value nil] in the case of fulfillment,
 40 |   or [nil error] in the case of rejection. Takes an optional `promise-constructor`
 41 |   to extend, defaulting to `js/Promise`."
 42 |   ([]
 43 |    (extend-promises-as-pair-channels! js/Promise))
 44 |   ([promise-constructor]
 45 |    (extend-promises-as-channels! (fn [val] [val nil])
 46 |                                  (fn [err] [nil err])
 47 |                                  promise-constructor)))
 48 | 
 49 | (defn consume-pair
 50 |   "When passed a [value nil] pair, returns value. When passed a [nil error] pair,
 51 |   throws error. See also `cljs-promises.async/<?`."
 52 |   [[val err]]
 53 |   (if err
 54 |     (throw err)
 55 |     val))
 56 | 
 57 | (defn value-port
 58 |   "Wraps a promise and returns a ReadPort (a read-only channel-like). When the
 59 |   promise fulfills with a value, that value is sent constantly on the channel
 60 |   (the value might be nil). When the promise rejects with an error, nil is sent
 61 |   constantly."
 62 |   [promise]
 63 |   (reify
 64 |     impl/ReadPort
 65 |     (take! [_ handler]
 66 |       (.then promise
 67 |              (fn [val]
 68 |                (dispatch/run #((impl/commit handler) val)))
 69 |              (fn [_]
 70 |                (dispatch/run #((impl/commit handler) nil))))
 71 |       nil)))
 72 | 
 73 | (defn error-port
 74 |   "The reverse of `value-port`, passing along errors when `promise` rejects and sending
 75 |   nils when `promise` fulfills with a value."
 76 |   [promise]
 77 |   (reify
 78 |     impl/ReadPort
 79 |     (take! [_ handler]
 80 |       (.then promise
 81 |              (fn [_]
 82 |                (dispatch/run #((impl/commit handler) nil)))
 83 |              (fn [err]
 84 |                (dispatch/run #((impl/commit handler) err))))
 85 |       nil)))
 86 | 
 87 | (defn pair-port
 88 |   "Returns a ReadPort which sends [value nil] when `promise` fulfills, and [nil error]
 89 |   when `promise` rejects."
 90 |   [promise]
 91 |   (reify
 92 |     impl/ReadPort
 93 |     (take! [_ handler]
 94 |       (.then promise
 95 |              (fn [val]
 96 |                (dispatch/run #((impl/commit handler) [val nil])))
 97 |              (fn [err]
 98 |                (dispatch/run #((impl/commit handler) [nil err]))))
 99 |       nil)))
100 | 
101 | 
102 | (defn take-as-promise!
103 |   "Waits for the next value from `ch` and returns a promise of that value."
104 |   [ch]
105 |   (cljs-promises.core/promise (fn [resolve _]
106 |                                 (async/take! ch resolve))))
107 | 


--------------------------------------------------------------------------------
/src/cljs_promises/core.cljs:
--------------------------------------------------------------------------------
 1 | (ns cljs-promises.core)
 2 | 
 3 | (defn- cast-as-array
 4 |   [coll]
 5 |   (if (or (array? coll)
 6 |           (not (reduceable? coll)))
 7 |     coll
 8 |     (into-array coll)))
 9 | 
10 | ;; the ES6 API:
11 | 
12 | (defn promise
13 |   [resolver]
14 |   (js/Promise. resolver))
15 | 
16 | (defn resolve
17 |   [x]
18 |   (.resolve js/Promise x))
19 | 
20 | (defn reject
21 |   [x]
22 |   (.reject js/Promise x))
23 | 
24 | (defn all
25 |   [coll]
26 |   (.all js/Promise (cast-as-array coll)))
27 | 
28 | (defn race
29 |   [coll]
30 |   (.race js/Promise (cast-as-array coll)))
31 | 
32 | (defn then
33 |   ([promise on-fulfilled]
34 |    (.then promise on-fulfilled))
35 |   ([promise on-fulfilled on-rejected]
36 |    (.then promise on-fulfilled on-rejected)))
37 | 
38 | (defn catch
39 |   [promise on-rejected]
40 |   (.catch promise on-rejected))
41 | 
42 | ;; extras!
43 | 
44 | (defn timeout
45 |   [ms]
46 |   (promise (fn [resolve _]
47 |              (js/setTimeout resolve ms))))
48 | 


--------------------------------------------------------------------------------