├── .gitignore
├── LICENSE
├── README.md
├── app.js
├── index.html
├── project.clj
└── src
    └── clojure_conj_talk
        └── core.clj


/.gitignore:
--------------------------------------------------------------------------------
 1 | /target
 2 | /classes
 3 | /checkouts
 4 | pom.xml
 5 | pom.xml.asc
 6 | *.jar
 7 | *.class
 8 | /.lein-*
 9 | /.nrepl-port
10 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC
  2 | LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM
  3 | CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
  4 | 
  5 | 1. DEFINITIONS
  6 | 
  7 | "Contribution" means:
  8 | 
  9 | a) in the case of the initial Contributor, the initial code and
 10 | documentation distributed under this Agreement, and
 11 | 
 12 | b) in the case of each subsequent Contributor:
 13 | 
 14 | i) changes to the Program, and
 15 | 
 16 | ii) additions to the Program;
 17 | 
 18 | where such changes and/or additions to the Program originate from and are
 19 | distributed by that particular Contributor. A Contribution 'originates' from
 20 | a Contributor if it was added to the Program by such Contributor itself or
 21 | anyone acting on such Contributor's behalf. Contributions do not include
 22 | additions to the Program which: (i) are separate modules of software
 23 | distributed in conjunction with the Program under their own license
 24 | agreement, and (ii) are not derivative works of the Program.
 25 | 
 26 | "Contributor" means any person or entity that distributes the Program.
 27 | 
 28 | "Licensed Patents" mean patent claims licensable by a Contributor which are
 29 | necessarily infringed by the use or sale of its Contribution alone or when
 30 | combined with the Program.
 31 | 
 32 | "Program" means the Contributions distributed in accordance with this
 33 | Agreement.
 34 | 
 35 | "Recipient" means anyone who receives the Program under this Agreement,
 36 | including all Contributors.
 37 | 
 38 | 2. GRANT OF RIGHTS
 39 | 
 40 | a) Subject to the terms of this Agreement, each Contributor hereby grants
 41 | Recipient a non-exclusive, worldwide, royalty-free copyright license to
 42 | reproduce, prepare derivative works of, publicly display, publicly perform,
 43 | distribute and sublicense the Contribution of such Contributor, if any, and
 44 | such derivative works, in source code and object code form.
 45 | 
 46 | b) Subject to the terms of this Agreement, each Contributor hereby grants
 47 | Recipient a non-exclusive, worldwide, royalty-free patent license under
 48 | Licensed Patents to make, use, sell, offer to sell, import and otherwise
 49 | transfer the Contribution of such Contributor, if any, in source code and
 50 | object code form.  This patent license shall apply to the combination of the
 51 | Contribution and the Program if, at the time the Contribution is added by the
 52 | Contributor, such addition of the Contribution causes such combination to be
 53 | covered by the Licensed Patents. The patent license shall not apply to any
 54 | other combinations which include the Contribution. No hardware per se is
 55 | licensed hereunder.
 56 | 
 57 | c) Recipient understands that although each Contributor grants the licenses
 58 | to its Contributions set forth herein, no assurances are provided by any
 59 | Contributor that the Program does not infringe the patent or other
 60 | intellectual property rights of any other entity. Each Contributor disclaims
 61 | any liability to Recipient for claims brought by any other entity based on
 62 | infringement of intellectual property rights or otherwise. As a condition to
 63 | exercising the rights and licenses granted hereunder, each Recipient hereby
 64 | assumes sole responsibility to secure any other intellectual property rights
 65 | needed, if any. For example, if a third party patent license is required to
 66 | allow Recipient to distribute the Program, it is Recipient's responsibility
 67 | to acquire that license before distributing the Program.
 68 | 
 69 | d) Each Contributor represents that to its knowledge it has sufficient
 70 | copyright rights in its Contribution, if any, to grant the copyright license
 71 | set forth in this Agreement.
 72 | 
 73 | 3. REQUIREMENTS
 74 | 
 75 | A Contributor may choose to distribute the Program in object code form under
 76 | its own license agreement, provided that:
 77 | 
 78 | a) it complies with the terms and conditions of this Agreement; and
 79 | 
 80 | b) its license agreement:
 81 | 
 82 | i) effectively disclaims on behalf of all Contributors all warranties and
 83 | conditions, express and implied, including warranties or conditions of title
 84 | and non-infringement, and implied warranties or conditions of merchantability
 85 | and fitness for a particular purpose;
 86 | 
 87 | ii) effectively excludes on behalf of all Contributors all liability for
 88 | damages, including direct, indirect, special, incidental and consequential
 89 | damages, such as lost profits;
 90 | 
 91 | iii) states that any provisions which differ from this Agreement are offered
 92 | by that Contributor alone and not by any other party; and
 93 | 
 94 | iv) states that source code for the Program is available from such
 95 | Contributor, and informs licensees how to obtain it in a reasonable manner on
 96 | or through a medium customarily used for software exchange.
 97 | 
 98 | When the Program is made available in source code form:
 99 | 
100 | a) it must be made available under this Agreement; and
101 | 
102 | b) a copy of this Agreement must be included with each copy of the Program.
103 | 
104 | Contributors may not remove or alter any copyright notices contained within
105 | the Program.
106 | 
107 | Each Contributor must identify itself as the originator of its Contribution,
108 | if any, in a manner that reasonably allows subsequent Recipients to identify
109 | the originator of the Contribution.
110 | 
111 | 4. COMMERCIAL DISTRIBUTION
112 | 
113 | Commercial distributors of software may accept certain responsibilities with
114 | respect to end users, business partners and the like. While this license is
115 | intended to facilitate the commercial use of the Program, the Contributor who
116 | includes the Program in a commercial product offering should do so in a
117 | manner which does not create potential liability for other Contributors.
118 | Therefore, if a Contributor includes the Program in a commercial product
119 | offering, such Contributor ("Commercial Contributor") hereby agrees to defend
120 | and indemnify every other Contributor ("Indemnified Contributor") against any
121 | losses, damages and costs (collectively "Losses") arising from claims,
122 | lawsuits and other legal actions brought by a third party against the
123 | Indemnified Contributor to the extent caused by the acts or omissions of such
124 | Commercial Contributor in connection with its distribution of the Program in
125 | a commercial product offering.  The obligations in this section do not apply
126 | to any claims or Losses relating to any actual or alleged intellectual
127 | property infringement. In order to qualify, an Indemnified Contributor must:
128 | a) promptly notify the Commercial Contributor in writing of such claim, and
129 | b) allow the Commercial Contributor tocontrol, and cooperate with the
130 | Commercial Contributor in, the defense and any related settlement
131 | negotiations. The Indemnified Contributor may participate in any such claim
132 | at its own expense.
133 | 
134 | For example, a Contributor might include the Program in a commercial product
135 | offering, Product X. That Contributor is then a Commercial Contributor. If
136 | that Commercial Contributor then makes performance claims, or offers
137 | warranties related to Product X, those performance claims and warranties are
138 | such Commercial Contributor's responsibility alone. Under this section, the
139 | Commercial Contributor would have to defend claims against the other
140 | Contributors related to those performance claims and warranties, and if a
141 | court requires any other Contributor to pay any damages as a result, the
142 | Commercial Contributor must pay those damages.
143 | 
144 | 5. NO WARRANTY
145 | 
146 | EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON
147 | AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER
148 | EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR
149 | CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A
150 | PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the
151 | appropriateness of using and distributing the Program and assumes all risks
152 | associated with its exercise of rights under this Agreement , including but
153 | not limited to the risks and costs of program errors, compliance with
154 | applicable laws, damage to or loss of data, programs or equipment, and
155 | unavailability or interruption of operations.
156 | 
157 | 6. DISCLAIMER OF LIABILITY
158 | 
159 | EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY
160 | CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
161 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION
162 | LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
163 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
164 | ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
165 | EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY
166 | OF SUCH DAMAGES.
167 | 
168 | 7. GENERAL
169 | 
170 | If any provision of this Agreement is invalid or unenforceable under
171 | applicable law, it shall not affect the validity or enforceability of the
172 | remainder of the terms of this Agreement, and without further action by the
173 | parties hereto, such provision shall be reformed to the minimum extent
174 | necessary to make such provision valid and enforceable.
175 | 
176 | If Recipient institutes patent litigation against any entity (including a
177 | cross-claim or counterclaim in a lawsuit) alleging that the Program itself
178 | (excluding combinations of the Program with other software or hardware)
179 | infringes such Recipient's patent(s), then such Recipient's rights granted
180 | under Section 2(b) shall terminate as of the date such litigation is filed.
181 | 
182 | All Recipient's rights under this Agreement shall terminate if it fails to
183 | comply with any of the material terms or conditions of this Agreement and
184 | does not cure such failure in a reasonable period of time after becoming
185 | aware of such noncompliance. If all Recipient's rights under this Agreement
186 | terminate, Recipient agrees to cease use and distribution of the Program as
187 | soon as reasonably practicable. However, Recipient's obligations under this
188 | Agreement and any licenses granted by Recipient relating to the Program shall
189 | continue and survive.
190 | 
191 | Everyone is permitted to copy and distribute copies of this Agreement, but in
192 | order to avoid inconsistency the Agreement is copyrighted and may only be
193 | modified in the following manner. The Agreement Steward reserves the right to
194 | publish new versions (including revisions) of this Agreement from time to
195 | time. No one other than the Agreement Steward has the right to modify this
196 | Agreement. The Eclipse Foundation is the initial Agreement Steward. The
197 | Eclipse Foundation may assign the responsibility to serve as the Agreement
198 | Steward to a suitable separate entity. Each new version of the Agreement will
199 | be given a distinguishing version number. The Program (including
200 | Contributions) may always be distributed subject to the version of the
201 | Agreement under which it was received. In addition, after a new version of
202 | the Agreement is published, Contributor may elect to distribute the Program
203 | (including its Contributions) under the new version. Except as expressly
204 | stated in Sections 2(a) and 2(b) above, Recipient receives no rights or
205 | licenses to the intellectual property of any Contributor under this
206 | Agreement, whether expressly, by implication, estoppel or otherwise. All
207 | rights in the Program not expressly granted under this Agreement are
208 | reserved.
209 | 
210 | This Agreement is governed by the laws of the State of Washington and the
211 | intellectual property laws of the United States of America. No party to this
212 | Agreement will bring a legal action under this Agreement more than one year
213 | after the cause of action arose. Each party waives its rights to a jury trial
214 | in any resulting litigation.
215 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # clojure-conj-talk
 2 | 
 3 | Here is are the code examples used in the 2013 Clojure Conj talk on core.async. The core.clj
 4 | file in this project contains the examples, and expects that users will eval the forms one 
 5 | at a time, top to bottom.
 6 | 
 7 | ## Usage
 8 | 
 9 | In the talk, I used a binding (CTRL-`) and this emacs code to run each form one at a time in a repl. 
10 | 
11 | 
12 | 	
13 |     (defun nrepl-eval-expression-at-point-in-repl ()
14 |       (interactive)
15 |       (let ((form (nrepl-expression-at-point)))
16 |         ;; Strip excess whitespace
17 |         (while (string-match "\\`\s+\\|\n+\\'" form)
18 |           (setq form (replace-match "" t t form)))
19 |         (set-buffer (nrepl-find-or-create-repl-buffer))
20 |         (goto-char (point-max))
21 |         (insert form)
22 |         (nrepl-return)))
23 | 
24 | If you are using [CIDER](https://github.com/clojure-emacs/cider) below is the equivalent.
25 | 
26 | 
27 | 
28 |     (defun cider-eval-expression-at-point-in-repl ()
29 |       (interactive)
30 |       (let ((form (cider-sexp-at-point)))
31 |         ;; Strip excess whitespace
32 |         (while (string-match "\\`\s+\\|\n+\\'" form)
33 |           (setq form (replace-match "" t t form)))
34 |         (set-buffer (cider-find-or-create-repl-buffer))
35 |         (goto-char (point-max))
36 |         (insert form)
37 |         (cider-repl-return)))
38 | 
39 | 
40 | 
41 | 
42 | 
43 | ## License
44 | 
45 | Copyright © 2013 Timothy Baldridge
46 | 
47 | Distributed under the Eclipse Public License either version 1.0 or (at
48 | your option) any later version.
49 | 


--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 |   <head>
 3 |     <meta charset="UTF-8">
 4 |     <title>Browser-connected REPL through nREPL with Piggieback</title>
 5 |   </head>
 6 |   <body>
 7 |     <div id="content">
 8 |       <script type="text/javascript" src="app.js"></script>
 9 |       <canvas id="canvas" width="800" height="800"></canvas>
10 |       <script type="text/javascript">
11 |         goog.require('piggieback_browser');
12 |       </script>
13 |     </div>
14 |   </body>
15 | </html>
16 | 


--------------------------------------------------------------------------------
/project.clj:
--------------------------------------------------------------------------------
 1 | (defproject clojure-conj-talk "0.1.0-SNAPSHOT"
 2 |   :description "FIXME: write description"
 3 |   :url "http://example.com/FIXME"
 4 |   :license {:name "Eclipse Public License"
 5 |             :url "http://www.eclipse.org/legal/epl-v10.html"}
 6 |   :plugins [[lein-cljsbuild "1.0.0-alpha2"]]
 7 |   :dependencies [[org.clojure/clojure "1.5.1"]
 8 | 		 [org.clojure/core.async "0.1.256.0-1bf8cf-alpha"]
 9 |                  [http-kit "2.1.10"]
10 |                  [cheshire "5.2.0"]
11 |                  [org.clojure/clojurescript "0.0-2014"]
12 |                  [com.cemerick/austin "0.1.3"]]
13 |   :profiles {:dev {:repl-options {:init-ns user}
14 |                    :plugins [[com.cemerick/austin "0.1.0"]
15 |                              [lein-cljsbuild "0.3.2"]]
16 |                    :cljsbuild {:builds [{:source-paths ["src-cljs"]
17 |                                          :compiler {:output-to "app.js"
18 |                                                     :optimizations :simple
19 |                                                     :pretty-print true}}]}}})
20 | 


--------------------------------------------------------------------------------
/src/clojure_conj_talk/core.clj:
--------------------------------------------------------------------------------
  1 | (ns clojure-conj-talk.core
  2 |   (:refer-clojure :exclude [map reduce into partition partition-by take merge])
  3 |   (:require [clojure.core.async :refer :all :as async]
  4 |             [clojure.pprint :refer [pprint]]
  5 |             [cheshire.core :as cheshire]))
  6 | 
  7 | 
  8 | ;; The most basic primitive in Core.Async is the channel
  9 | 
 10 | (def c (chan))
 11 | 
 12 | 
 13 | (chan)
 14 | ;; We can attach listeners via take!
 15 | 
 16 | (take! c (fn [v] (println v)))
 17 | 
 18 | 
 19 | ;; And we can send values via put!
 20 | 
 21 | (put! c 42)
 22 | 
 23 | 
 24 | ;; And in reverse order
 25 | 
 26 | (put! c "Hello World")
 27 | 
 28 | (take! c (fn [v] (println "Got " v)))
 29 | 
 30 | ;; The semantics are simple. Callbacks are one-shot. And you can have
 31 | ;; many readers/writers. Each puts/gets a single value. There is no fan-out
 32 | ;; or fan-in.
 33 | 
 34 | 
 35 | 
 36 | ;; Notice the different location of the output, one
 37 | ;; side or the other dispatches to a threadpool to
 38 | ;; run the attached callback.
 39 | 
 40 | ;; We can wait until the put is finished by passing a callback
 41 | 
 42 | (put! c "Hello World" (fn [] (println "Done putting")))
 43 | 
 44 | 
 45 | (take! c (fn [v] (println "Got " v)))
 46 | 
 47 | ;; Try the above again in reverse order to show dispatching
 48 | 
 49 | 
 50 | 
 51 | ;;;;;;; Introducing <!! and >!! ;;;;;;
 52 | 
 53 | ;; Well that's nice, but it's a pain to write code in that form,
 54 | ;; so let's use something that uses promises:
 55 | 
 56 | 
 57 | (defn takep [c]
 58 |   (let [p (promise)]
 59 |     (take! c (fn [v] (deliver p v)))
 60 |     @p))
 61 | 
 62 | ;; Now we can block the current thread waiting on the promise.
 63 | (future (println "Got!" (takep c)))
 64 | 
 65 | (put! c 42)
 66 | 
 67 | 
 68 | ;; And we can do the reverse with put!
 69 | 
 70 | (defn putp [c val]
 71 |   (let [p (promise)]
 72 |     (put! c val (fn [] (deliver p nil)))
 73 |     @p))
 74 | 
 75 | 
 76 | (future (println "Done" (putp c 42)))
 77 | 
 78 | (future (println "Got!" (takep c)))
 79 | 
 80 | 
 81 | ;; Well, that's exactly what clojure.core.async/<!! and >!! do
 82 | 
 83 | (future (println "Done" (>!! c 42)))
 84 | 
 85 | (future (println "Got! " (<!! c)))
 86 | 
 87 | 
 88 | ;; But future doesn't really fit here, as it returns a promise, why not make
 89 | ;; it return a channel? This is what core.async's thread macro does:
 90 | 
 91 | (thread 42)
 92 | 
 93 | (<!! (thread 42))
 94 | 
 95 | (thread (println "It works!" (<!! (thread 42))))
 96 | 
 97 | ;;;;;;;; The Go Block ;;;;;;;;
 98 | 
 99 | ;; That's all well and good, but who wants to tie up a thread
100 | ;; when we could use simple callbacks. This is what the go macro
101 | ;; does. It lets you write code that looks like the above code,
102 | ;; but it re-writes all your code to use callbacks.
103 | 
104 | (go 42)
105 | 
106 | (<!! (go 42))
107 | 
108 | (go (println "It works!" (<! (go 42))))
109 | 
110 | ;; Wait....why did we use <!! Well <!! is simply a function that uses
111 | ;; blocking promises to wait for channel values. That would mess up the fixed
112 | ;; size thread pool that go blocks dispatch in. So we must define two sets
113 | ;; of operations
114 | 
115 | ;; for thread, use <!! and >!! (blocking)
116 | 
117 | ;; for go, use <! and >! (parking)
118 | 
119 | 
120 | 
121 | ;; How do go blocks work? Let's take a look.
122 | 
123 | (pprint (macroexpand '(go 42)))
124 | 
125 | ;; The code is rewritten as a state machine. Each block ends with a flow
126 | ;; control command to the next block. From this we can start/stop the state
127 | ;; machine as desired.
128 | 
129 | (pprint (macroexpand '(go (>! c (inc (<! c))))))
130 | 
131 | 
132 | ;; You really don't have to worry about most of this. Just accept that it works
133 | ;; and look up clojure core.async state machines on the internet if you want
134 | ;; more information.
135 | 
136 | 
137 | ;;;;; Buffer Types ;;;;;
138 | 
139 | 
140 | ;; Fixed length buffer
141 | (def fbc (chan 1))
142 | 
143 | (go (>! fbc 1)
144 |     (println "done 1"))
145 | (go (>! fbc 2)
146 |     (println "done 2"))
147 | 
148 | (<!! fbc)
149 | (<!! fbc)
150 | 
151 | 
152 | ;; Dropping buffer (aka. drop newest)
153 | 
154 | (def dbc (chan (dropping-buffer 1)))
155 | 
156 | (go (>! dbc 1)
157 |     (println "done 1"))
158 | 
159 | (go (>! dbc 2)
160 |     (println "done 2"))
161 | 
162 | (<!! dbc) ;; returns 1
163 | 
164 | ;; Sliding buffer (aka. drop oldest)
165 | 
166 | (def sbc (chan (sliding-buffer 1)))
167 | 
168 | (go (>! sbc 1)
169 |     (println "done 1"))
170 | 
171 | (go (>! sbc 2)
172 |     (println "done 2"))
173 | 
174 | (<!! sbc) ;; returns 2
175 | 
176 | ;;; Closing a channel
177 | 
178 | (def c (chan))
179 | 
180 | (close! c)
181 | 
182 | (<!! c)
183 | 
184 | ;;;; Alt & Timeout ;;;;
185 | 
186 | ;; Sometimes we want to take the first available item from a bunch
187 | ;; of channels. For this we use alt! and alt!!
188 | 
189 | (def a (chan))
190 | (def b (chan))
191 | 
192 | (put! a 42)
193 | 
194 | (alts!! [a b]) ;; returns [value chan]
195 | 
196 | ;; Timeout is a channel that closes after X ms
197 | ;; (close! (chan 42))
198 | 
199 | (<!! (timeout 2000))
200 | 
201 | ;; Often used with alt
202 | 
203 | (alts!! [a (timeout 1000)])
204 | 
205 | ;; Alts can be used with writes
206 | 
207 | (alts!! [[a 42]
208 |          (timeout 1000)])
209 | 
210 | ;; We can also provide defaults for alts
211 | 
212 | (alts!! [a]
213 |         :default :nothing-found)
214 | 
215 | ;; By default, alts are tried in random order
216 | 
217 | (put! a :a) ;; Do this a few times
218 | (put! b :b) ;; And this
219 | 
220 | (alts!! [a b]) ;; Notice the order
221 | 
222 | 
223 | ;; And again with :priority true
224 | 
225 | (put! a :a)
226 | (put! b :b)
227 | 
228 | (alts!! [a b]
229 |         :priority true)
230 | 
231 | 
232 | ;;;;; Logging Handler ;;;;;
233 | 
234 | (def log-chan (chan))
235 | 
236 | (thread
237 |  (loop []
238 |    (when-let [v (<!! log-chan)]
239 |      (println v)
240 |      (recur)))
241 |  (println "Log Closed"))
242 | 
243 | 
244 | (close! log-chan)
245 | 
246 | (defn log [msg]
247 |   (>!! log-chan msg))
248 | 
249 | (log "foo")
250 | 
251 | ;;;; Thread Pool Service
252 | 
253 | 
254 | (defn thread-pool-service [ch f max-threads timeout-ms]
255 |   (let [thread-count (atom 0)
256 |         buffer-status (atom 0)
257 |         buffer-chan (chan)
258 |         thread-fn (fn []
259 |                     (swap! thread-count inc)
260 |                     (loop []
261 |                       (when-let [v (first (alts!! [buffer-chan (timeout timeout-ms)]))]
262 |                         (f v)
263 |                         (recur)))
264 |                     (swap! thread-count dec)
265 |                     (println "Exiting..."))]
266 |     (go (loop []
267 |           (when-let [v (<! ch)]
268 |             (if-not (alt! [[buffer-chan v]] true
269 |                           :default false)
270 |               (loop []
271 |                 (if (< @thread-count max-threads)
272 |                   (do (put! buffer-chan v)
273 |                       (thread (thread-fn)))
274 |                   (when-not (alt! [[buffer-chan v]] true
275 |                                   [(timeout 1000)] ([_] false))
276 |                     (recur)))))
277 |             (recur)))
278 |         (close! buffer-chan))))
279 | 
280 | (def exec-chan (chan))
281 | (def thread-pool (thread-pool-service exec-chan (fn [x]
282 |                                                   (println x)
283 |                                                   (Thread/sleep 5000)) 3 3000))
284 | 
285 | 
286 | 
287 | (>!! exec-chan "Hello World")
288 | 
289 | 
290 | ;;;;; HTTP Async ;;;;;;
291 | 
292 | 
293 | (require '[org.httpkit.client :as http])
294 | 
295 | (defn http-get [url]
296 |   (let [c (chan)]
297 |     (println url)
298 |     (http/get url
299 |               (fn [r] (put! c r)))
300 |     c))
301 | 
302 | (def key "b4cb6cd7a349b47ccfbb80e05a601a7c")
303 | 
304 | (defn request-and-process [url]
305 |   (go
306 |    (-> (str "http://api.themoviedb.org/3/" url "api_key=" key)
307 |        http-get
308 |        <!
309 |        :body
310 |        (cheshire/parse-string true))))
311 | 
312 | (defn latest-movies []
313 |   (request-and-process "movies/latest?"))
314 | 
315 | (defn top-rated-movies []
316 |   (request-and-process "movie/top_rated?"))
317 | 
318 | (<!! (top-rated-movies))
319 | 
320 | (defn movie-by-id [id]
321 |   (request-and-process (str "movie/" id "?")))
322 | 
323 | (<!! (movie-by-id 238))
324 | 
325 | (defn movie-cast [id]
326 |   (request-and-process (str "movie/" id "/casts?")))
327 | 
328 | (<!! (movie-cast 238))
329 | 
330 | (defn people-by-id [id]
331 |   (request-and-process (str "person/" id "?")))
332 | 
333 | (<!! (people-by-id 3144))
334 | 
335 | (defn avg [col]
336 |   (-> (clojure.core/reduce + 0 col)
337 |       (/ (count col))))
338 | 
339 | (avg [1 2 3 4 5])
340 | 
341 | (defn avg-cast-popularity [id]
342 |   (go
343 |    (let [cast (->> (movie-cast id)
344 |                    <!
345 |                    :cast
346 |                    (clojure.core/map :id)
347 |                    (clojure.core/map people-by-id)
348 |                    (async/map vector)
349 |                    <!
350 |                    (clojure.core/map :popularity)
351 |                    avg)]
352 |      cast)))
353 | 
354 | (<!! (avg-cast-popularity 238))
355 | 
356 | 
357 | (time (do (dotimes [x 10]
358 |             (<!! (http-get "http://www.imdb.com/xml/find?json=1&q=ben+afleck")))
359 |           nil))
360 | 
361 | (time (do (->> (for [x (range 10)]
362 |                  (http-get "http://www.imdb.com/xml/find?json=1&q=ben+afleck"))
363 |                doall
364 |                async/merge
365 |                (async/take 10)
366 |                (async/into [])
367 |                <!!)
368 |           nil))
369 | 
370 | 
371 | 
372 | ;;;; Mult ;;;;
373 | 
374 | ;; Create a mult. This allows data from one channel to be broadcast
375 | ;; to many other channels that "tap" the mult.
376 | 
377 | (def to-mult (chan 1))
378 | (def m (mult to-mult))
379 | 
380 | (let [c (chan 1)]
381 |   (tap m c)
382 |   (go (loop []
383 |         (when-let [v (<! c)]
384 |           (println "Got! " v)
385 |           (recur))
386 |         (println "Exiting!"))))
387 | 
388 | (>!! to-mult 42)
389 | (>!! to-mult 43)
390 | 
391 | (close! to-mult)
392 | 
393 | 
394 | ;;;; Pub/Sub ;;;
395 | 
396 | ;; This is a bit like Mult + Multimethods
397 | 
398 | (def to-pub (chan 1))
399 | (def p (pub to-pub :tag))
400 | 
401 | (def print-chan (chan 1))
402 | 
403 | (go (loop []
404 |       (when-let [v (<! print-chan)]
405 |         (println v)
406 |         (recur))))
407 | 
408 | ;; This guy likes updates about cats.
409 | (let [c (chan 1)]
410 |   (sub p :cats c)
411 |   (go (println "I like cats:")
412 |       (loop []
413 |         (when-let [v (<! c)]
414 |           (>! print-chan (pr-str "Cat guy got: " v))
415 |           (recur))
416 |         (println "Cat guy exiting"))))
417 | 
418 | ;; This guy likes updates about dogs
419 | (let [c (chan 1)]
420 |   (sub p :dogs c)
421 |   (go (println "I like dogs:")
422 |       (loop []
423 |         (when-let [v (<! c)]
424 |           (>! print-chan (pr-str "Dog guy got: " v))
425 |           (recur))
426 |         (println "Dog guy exiting"))))
427 | 
428 | ;; This guy likes updates about animals
429 | (let [c (chan 1)]
430 |   (sub p :dogs c)
431 |   (sub p :cats c)
432 |   (go (println "I like cats or dogs:")
433 |       (loop []
434 |         (when-let [v (<! c)]
435 |           (>! print-chan (pr-str "Cat/Dog guy got: " v))
436 |           (recur))
437 |         (println "Cat/dog guy exiting"))))
438 | 
439 | 
440 | (defn send-with-tags [msg]
441 |   (doseq [tag (:tags msg)]
442 |     (println "sending... " tag)
443 |     (>!! to-pub {:tag tag
444 |                  :msg (:msg msg)})))
445 | 
446 | (send-with-tags {:msg "New Cat Story"
447 |                  :tags [:cats]})
448 | 
449 | (send-with-tags {:msg "New Dog Story"
450 |                  :tags [:dogs]})
451 | 
452 | (send-with-tags {:msg "New Pet Story"
453 |                  :tags [:cats :dogs]})
454 | 
455 | 
456 | (close! to-pub)
457 | 
458 | ;;;; Actors ;;;;
459 | 
460 | 
461 | (defprotocol IActor
462 |   (! [this msg]))
463 | 
464 | (defn spawn [f]
465 |   (let [c (chan Integer/MAX_VALUE)]
466 |     (go (loop [f f]
467 |           (recur (f (<! c)))))
468 |     (reify IActor
469 |       (! [this msg]
470 |         (put! c msg)))))
471 | 
472 | 
473 | (defn spawn-counter []
474 |   (let [counter (fn counter [cnt msg]
475 |                   (case (:type msg)
476 |                     :inc (partial counter (inc cnt))
477 |                     :get (do (! (:to msg) cnt)
478 |                              (partial counter cnt))))]
479 |     (spawn (partial counter 0))))
480 | 
481 | (defn printer []
482 |   (spawn (fn ptr [msg]
483 |            (println "Got:" msg)
484 |            ptr)))
485 | 
486 | (def ptr (printer))
487 | 
488 | (def counter (spawn-counter))
489 | 
490 | (! counter {:type :inc})
491 | 
492 | (! counter {:type :get
493 |             :to ptr})
494 | 
495 | 
496 | ;; This follows the actor model closely
497 | ;; 1) send to other actors
498 | ;; 2) create new actors
499 | ;; 3) specify how to handle the next message
500 | 
501 | 
502 | ;; My critique of this system
503 | ;; 1) unbounded queue (mailbox)
504 | ;; 2) internal mutating state (hidden in function closures)
505 | ;; 3) must send message to deref (mailbox could be backed up)
506 | ;; 4) couples a queue, with mutating state, with a process
507 | ;; 5) basically async OOP
508 | 
509 | ;; </critique>
510 | 
511 | 
512 | 
513 | ;;; Limited rate updates to an atom
514 | 
515 | (def a (atom 1))
516 | (def watch-c (chan (dropping-buffer 1)))
517 | 
518 | (add-watch a :chan-watch
519 |            (fn [k r o n]
520 |                (put! watch-c :ping)))
521 | 
522 | (go (while true
523 |       (let [tout (timeout 100)]
524 |         (when-let [x (<! watch-c)]
525 |           (println "-----> "@a)
526 |           (<! tout)))))
527 | 
528 | (dotimes [x 1000]
529 |   (swap! a inc))
530 | 
531 | ;;;;;; Limited Access to a Shared Resource ;;;;;
532 | 
533 | 
534 | (defn function-service [f num-threads]
535 |   (let [c (chan num-threads)]
536 |     (dotimes [x num-threads]
537 |       (thread
538 |        (loop []
539 |          (when-let [[args ret-chan] (<!! c)]
540 |            (>!! ret-chan (apply f args))
541 |            (recur)))))
542 |     c))
543 | 
544 | (def slurp-service (function-service (comp read-string slurp) 2))
545 | 
546 | 
547 | (defn slurp-async [& args]
548 |   (let [c (chan 1)]
549 |     ;; put! is tied to the take! from chan
550 |     ;; so no unbounded-ness here.
551 |     (put! slurp-service [args c])
552 |     c))
553 | 
554 | 
555 | 
556 | (<!! (slurp-async "project.clj"))
557 | 
558 | (close! slurp-service)
559 | 
560 | 
561 | ;;;; ClojureScript examples ;;;;
562 | 
563 | (require 'cljs.repl.browser)
564 | 
565 | (cemerick.piggieback/cljs-repl
566 |   :repl-env (cljs.repl.browser/repl-env :port 9000))
567 | 
568 | (ns cljs-examples
569 |   (:require [cljs.core.async :refer [chan put! take! timeout] :as async]
570 |             [clojure.walk :refer [prewalk]]
571 |             [goog.net.XhrIo])
572 |   (:require-macros [cljs.core.async.macros :refer [go]]))
573 | 
574 | (js/alert "We're running ClojureScript")
575 | 
576 | (def c (chan))
577 | 
578 | (put! c 42)
579 | 
580 | (take! c (fn [x]
581 |            (println x)))
582 | 
583 | (go 32)
584 | 
585 | (println take!)
586 | 
587 | (def canvas (.getElementById js/document "canvas"))
588 | 
589 | 
590 | (def colors ["#FF0000"
591 |              "#00FF00"
592 |              "#0000FF"
593 |              "#00FFFF"
594 |              "#FFFF00"
595 |              "#FF00FF"])
596 | 
597 | (defn make-cell [canvas x y]
598 |   (let [ctx (-> js/document
599 |                 (.getElementById canvas)
600 |                 (.getContext "2d"))]
601 |     (go (while true
602 |           (set! (.-fillStyle ctx) (rand-nth colors))
603 |           (.fillRect ctx x y 10 10)
604 |           (<! (timeout (rand-int 1000)))))))
605 | 
606 | (defn make-scene [canvas rows cols]
607 |   (dotimes [x cols]
608 |     (dotimes [y rows]
609 |       (make-cell canvas (* 10 x) (* 10 y)))))
610 | 
611 | 
612 | (make-scene "canvas" 100 100)
613 | 
614 | 
615 | ;;; Same HTTP Examples, but in the browser
616 | 
617 | (defn fixup-keys [x]
618 |   (prewalk
619 |    (fn [x]
620 |      (if (map? x)
621 |        (zipmap (map keyword (keys x))
622 |                (vals x))
623 |        x))
624 |    x))
625 | 
626 | ;; IO is a tad different in JS, so this function has to be re-written
627 | ;; for ClojureScript.
628 | (defn http-get [url]
629 |   (let [c (chan 1)]
630 |     (goog.net.XhrIo/send url (fn [e]
631 |                                (->> e
632 |                                     .-target
633 |                                     .getResponseJson
634 |                                     js->clj
635 |                                     fixup-keys
636 |                                     (put! c))))
637 |     c))
638 | 
639 | 
640 | 
641 | (def key "b4cb6cd7a349b47ccfbb80e05a601a7c")
642 | 
643 | (defn request-and-process [url]
644 |   (go
645 |    (-> (str "http://api.themoviedb.org/3/" url "api_key=" key)
646 |        http-get
647 |        <!
648 |        )))
649 | 
650 | (defn latest-movies []
651 |   (request-and-process "movies/latest?"))
652 | 
653 | (defn top-rated-movies []
654 |   (request-and-process "movie/top_rated?"))
655 | 
656 | (go (println (<! (top-rated-movies))))
657 | 
658 | 
659 | 
660 | (defn movie-by-id [id]
661 |   (request-and-process (str "movie/" id "?")))
662 | 
663 | (go (println (<! (movie-by-id 238))))
664 | 
665 | (defn movie-cast [id]
666 |   (request-and-process (str "movie/" id "/casts?")))
667 | 
668 | (go (println (<! (movie-cast 238))))
669 | 
670 | (defn people-by-id [id]
671 |   (request-and-process (str "person/" id "?")))
672 | 
673 | (go (println (<! (people-by-id 3144))))
674 | 
675 | (defn avg [col]
676 |   (-> (clojure.core/reduce + 0 col)
677 |       (/ (count col))))
678 | 
679 | (avg [1 2 3 4 5])
680 | 
681 | (defn avg-cast-popularity [id]
682 |   (go
683 |    (let [cast (->> (movie-cast id)
684 |                    <!
685 |                    :cast
686 |                    (clojure.core/map :id)
687 |                    (clojure.core/map people-by-id)
688 |                    (async/map vector)
689 |                    <!
690 |                    (clojure.core/map :popularity)
691 |                    avg)]
692 |      cast)))
693 | 
694 | (go (js/alert (pr-str (<! (avg-cast-popularity 238)))))
695 | 
696 | 
697 | (defn omdb-by-title [q]
698 |   (go
699 |    (-> (str "http://www.omdbapi.com/?t=" q)
700 |        http-get
701 |        <!
702 |        :body
703 |        (cheshire/parse-string true))))
704 | 
705 | (defn omdb-item [id]
706 |   (go
707 |    (-> (str "http://www.omdbapi.com/?tomatoes=true&i=" id)
708 |        http-get
709 |        <!
710 |        :body
711 |        (cheshire/parse-string true))))
712 | 
713 | (<!! (omdb-by-title "the+matrix"))
714 | (<!! (omdb-item "tt1285016"))
715 | 
716 | 
717 | 
718 | (go
719 |  (time (dotimes [x 10]
720 |          (<! (people-by-id 3144)))))
721 | 
722 | (go
723 |  (time (let [chans (doall (for [x (range 10)]
724 |                             (people-by-id 3144)))]
725 |          (doseq [c chans]
726 |            (<! c)))))
727 | 


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