├── src
    ├── logger.clj
    ├── tut001.clj
    ├── tut100.clj
    ├── tut002.clj
    ├── tut003.clj
    ├── tut102.clj
    ├── tut101.clj
    ├── tut106.go
    ├── tut104.clj
    ├── sieve.clj
    ├── tut200.clj
    ├── tut004.clj
    ├── tut105.clj
    ├── tut103.clj
    ├── sieve.go
    ├── tut106.clj
    ├── tuthttp.clj
    ├── tut107.clj
    ├── tut005.clj
    ├── tut006.clj
    ├── tut201.clj
    └── tut300.clj
├── .gitignore
├── README.md
└── project.clj


/src/logger.clj:
--------------------------------------------------------------------------------
1 | (ns logger)
2 | 
3 | (def ^:private log-agent (agent 0))
4 | 
5 | (defn log [& strs]
6 |   (send log-agent (fn [ctr] (println (apply str (interpose " " strs))) (inc ctr))))
7 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | /target
 2 | /lib
 3 | /classes
 4 | /checkouts
 5 | pom.xml
 6 | pom.xml.asc
 7 | *.jar
 8 | *.class
 9 | .lein-deps-sum
10 | .lein-failures
11 | .lein-plugins
12 | .lein-repl-history
13 | .nrepl-port


--------------------------------------------------------------------------------
/src/tut001.clj:
--------------------------------------------------------------------------------
 1 | ;; http://tour.golang.org/#62
 2 | 
 3 | (ns tut1
 4 |   (:require [clojure.core.async :refer [go timeout <!]]))
 5 | 
 6 | (go
 7 |  (dotimes [_ 5]
 8 |    (<! (timeout 100))
 9 |    (println "world")))
10 | 
11 | (println "hello")
12 | 


--------------------------------------------------------------------------------
/src/tut100.clj:
--------------------------------------------------------------------------------
 1 | ;; http://talks.golang.org/2012/concurrency.slide#16
 2 | 
 3 | (ns tut100
 4 |   (:require [clojure.core.async :refer [go timeout]]))
 5 | 
 6 | (def run (atom true))
 7 | 
 8 | (go
 9 |  (while @run
10 |    (println "boring!")
11 |    (<! (timeout (rand-int 1000)))))
12 | 
13 | (Thread/sleep 2000)
14 | (println "You're boring, I'm leaving")
15 | (reset! run false)
16 | 


--------------------------------------------------------------------------------
/src/tut002.clj:
--------------------------------------------------------------------------------
 1 | ;; http://tour.golang.org/#63
 2 | 
 3 | (ns tut2
 4 |   (:require [clojure.core.async :refer [chan put! <!!]]))
 5 | 
 6 | (defn sum [vals ch]
 7 |   (put! ch (clojure.core/reduce + vals)))
 8 | 
 9 | (let [vals [7 2 8 -9 4 0]
10 |       ch (chan)]
11 |   (sum (take 3 vals) ch)
12 |   (sum (drop 3 vals) ch)
13 | 
14 |   (let [x (<!! ch)
15 |         y (<!! ch)]
16 |     (println x y (+ x y))))
17 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Go Tutorials with Clojure core.async
2 | 
3 | * tut00* from [Go's tutorial page](http://tour.golang.org/)
4 | * tut10* from Rob Pike's 2012 talk [Go Concurrency Patterns](http://talks.golang.org/2012/concurrency.slide)
5 | * tut20* from Sameer Ajmani's 2013 talk [Advanced Go Concurrency Patterns](http://talks.golang.org/2013/advconc.slide)
6 | * tut30* from [Codewalk: Share Memory By Communicating](http://golang.org/doc/codewalk/sharemem/)
7 | 


--------------------------------------------------------------------------------
/project.clj:
--------------------------------------------------------------------------------
 1 | (defproject go-tutorials-core-async "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 |   :dependencies [[org.clojure/clojure "1.5.1"]
 7 |                  [org.clojure/core.async "0.1.242.0-44b1e3-alpha"]
 8 |                  [http-kit "2.1.12"]
 9 |                  [clj-http "0.7.7"]])
10 | 


--------------------------------------------------------------------------------
/src/tut003.clj:
--------------------------------------------------------------------------------
 1 | ;; http://tour.golang.org/#65
 2 | 
 3 | (ns tut3
 4 |   (:require [clojure.core.async :refer [chan <!! close! go-loop]]))
 5 | 
 6 | (defn fib-n [n ch]
 7 |   (go-loop [x 0 y 1 ctr 0]
 8 |            (if (< ctr n)
 9 |              (do
10 |                (>! ch x)
11 |                (recur y (+ x y) (inc ctr)))
12 |              (close! ch))))
13 | 
14 | (let [ch (chan 10)]
15 |   (fib-n 20 ch)
16 |   (loop [v (<!! ch)]
17 |     (when v
18 |       (println v)
19 |       (recur (<!! ch)))))
20 | 


--------------------------------------------------------------------------------
/src/tut102.clj:
--------------------------------------------------------------------------------
 1 | ;; http://talks.golang.org/2012/concurrency.slide#27
 2 | 
 3 | (ns tut102
 4 |   (:require [clojure.core.async :refer [go-loop >! <! <!! chan]]
 5 |             [tut101]))
 6 | 
 7 | (defn fan-in [in1 in2]
 8 |   (let [ch (chan)]
 9 |     (go-loop [] (>! ch (<! in1)) (recur))
10 |     (go-loop [] (>! ch (<! in2)) (recur))
11 |     ch))
12 | 
13 | (let [ch (fan-in (tut101/boring "Joe") (tut101/boring "Ann"))]
14 |   (dotimes [_ 10]
15 |     (println (<!! ch)))
16 |   (println "You're both boring, I'm leaving"))
17 | 


--------------------------------------------------------------------------------
/src/tut101.clj:
--------------------------------------------------------------------------------
 1 | ;; http://talks.golang.org/2012/concurrency.slide#26
 2 | 
 3 | (ns tut101
 4 |   (:require [clojure.core.async :refer [go-loop timeout >! <! <!! chan]]))
 5 | 
 6 | (defn boring [msg]
 7 |   (let [ch (chan)]
 8 |     (go-loop [i 0]
 9 |       (>! ch (str msg i))
10 |       (<! (timeout (rand-int 1000)))
11 |       (recur (inc i)))
12 |     ch))
13 | 
14 | (let [joe-ch (boring "Joe")
15 |       ann-ch (boring "Ann")]
16 |   (dotimes [_ 5]
17 |     (println (<!! joe-ch))
18 |     (println (<!! ann-ch)))
19 |   (println "You're both boring, I'm leaving"))
20 | 


--------------------------------------------------------------------------------
/src/tut106.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 |   "fmt"
 5 |   "time"
 6 | )
 7 | 
 8 | func f(left, right chan int) {
 9 |   left <- 1 + <-right
10 | }
11 | 
12 | func main() {
13 |   const n = 100000
14 |   leftmost := make(chan int)
15 |   right := leftmost
16 |   left := leftmost
17 |   for i := 0; i < n; i++ {
18 |       right = make(chan int)
19 |       go f(left, right)
20 |       left = right
21 |   }
22 | 
23 |   start := time.Now()
24 |   go func(c chan int) { c <- 1 }(right)
25 |   fmt.Println(<-leftmost)
26 |   fmt.Println(time.Now().Sub(start))
27 | }
28 | 


--------------------------------------------------------------------------------
/src/tut104.clj:
--------------------------------------------------------------------------------
 1 | ;; http://talks.golang.org/2012/concurrency.slide#34
 2 | 
 3 | (ns tut104
 4 |   (:require [clojure.core.async :refer [go-loop >! <! <!! alt! chan]]
 5 |             [tut101]))
 6 | 
 7 | (defn fan-in [in1 in2]
 8 |   (let [ch (chan)]
 9 |     (go-loop []
10 |              ;; note alt! result-expr syntax
11 |              (alt! [in1 in2]
12 |                    ([msg _] (>! ch msg)))
13 |              (recur))
14 |     ch))
15 | 
16 | (let [ch (fan-in (tut101/boring "Joe") (tut101/boring "Ann"))]
17 |   (dotimes [_ 10]
18 |     (println (<!! ch)))
19 |   (println "You're both boring, I'm leaving"))
20 | 


--------------------------------------------------------------------------------
/src/sieve.clj:
--------------------------------------------------------------------------------
 1 | ;; sieve of eratosthenes
 2 | 
 3 | (ns sieve
 4 |   (:require [clojure.core.async :refer [go-loop >! <! <!! chan]]))
 5 | 
 6 | (defn prime-filter [in out prime]
 7 |   (go-loop [i (<! in)]
 8 |            (when-not (zero? (mod i prime))
 9 |              (>! out i))
10 |            (recur (<! in))))
11 | 
12 | (let [ch (chan)]
13 |   (go-loop [i 2] (>! ch i) (recur (inc i)))
14 | 
15 |   (loop [ch ch, i 100]
16 |     (when (pos? i)
17 |       (let [prime (<!! ch)
18 |             next-ch (chan)]
19 |         (println prime)
20 |         (prime-filter ch next-ch prime)
21 |         (recur next-ch (dec i))))))
22 | 


--------------------------------------------------------------------------------
/src/tut200.clj:
--------------------------------------------------------------------------------
 1 | ;; http://talks.golang.org/2013/advconc.slide#6
 2 | 
 3 | (ns tut200
 4 |   (:require [clojure.core.async :refer [go-loop timeout >! >!! <! <!! chan]]))
 5 | 
 6 | (defn player [name table]
 7 |   (go-loop []
 8 |            (let [ball (<! table)]
 9 |              (println name ball)
10 |              (<! (timeout (rand-int 100)))
11 |              (>! table (inc ball))
12 |              (recur))))
13 | 
14 | (let [table (chan)]
15 |   (player "ping" table)
16 |   (player "pong" table)
17 | 
18 |   (>!! table 0)      ;; go-lang will detect a deadlock if this commented out
19 |   (Thread/sleep 1000)
20 |   (<!! table)  ;; take the ball off the table
21 |   (println "game over"))
22 | 


--------------------------------------------------------------------------------
/src/tut004.clj:
--------------------------------------------------------------------------------
 1 | ;; http://tour.golang.org/#66
 2 | 
 3 | (ns tut4
 4 |   (:require [clojure.core.async :refer [go go-loop <! chan]]))
 5 | 
 6 | (defn fib-q [res-ch quit-ch]
 7 |   (go-loop [x 0 y 1]
 8 |            ;; note we're putting onto res-ch inside the alts!
 9 |            (let [[_ chan] (alts! [[res-ch x] quit-ch])]
10 |              (if (= chan quit-ch)
11 |                (println "quit")
12 |                (recur y (+ x y))))))
13 | 
14 | (let [res-ch (chan)
15 |       quit-ch (chan)]
16 |   (go
17 |    (dotimes [_ 10]
18 |      (println (<! res-ch)))
19 |    (>! quit-ch 0))
20 | 
21 |   ;; note that fib-q go 'process' are created after the consumer above
22 | 
23 |   (fib-q res-ch quit-ch)
24 |   )
25 | 


--------------------------------------------------------------------------------
/src/tut105.clj:
--------------------------------------------------------------------------------
 1 | ;; http://talks.golang.org/2012/concurrency.slide#38
 2 | 
 3 | (ns tut105
 4 |   (:require [clojure.core.async :refer [go-loop timeout >! >!! <!! chan alts!]]))
 5 | 
 6 | (defn boring [msg quit-ch]
 7 |   (let [ch (chan)]
 8 |     (go-loop [i 0]
 9 |              (let [[_ mch] (alts! [(timeout (rand-int 1000)) quit-ch])]
10 |                (if (= mch quit-ch)
11 |                  (>! quit-ch "See you!")
12 |                  (do
13 |                    (>! ch (str msg i))
14 |                    (recur (inc i))))))
15 |     ch))
16 | 
17 | (let [quit (chan)
18 |       joe (boring "Joe" quit)]
19 |   (dotimes [_ 5]
20 |     (println (<!! joe)))
21 |   (println "You talk to much.")
22 |   (>!! quit :stop)
23 |   (println "Joe says" (<!! quit)))
24 | 


--------------------------------------------------------------------------------
/src/tut103.clj:
--------------------------------------------------------------------------------
 1 | ;; http://talks.golang.org/2012/concurrency.slide#30
 2 | 
 3 | (ns go-tutorials-core-async.tut103
 4 |   (:require [clojure.core.async :refer [go-loop timeout >! >!! <! <!! chan]]
 5 |             [tut102]))
 6 | 
 7 | (defn boring [msg]
 8 |   (let [ch (chan)
 9 |         wait (chan)]
10 |     (go-loop [i 0]
11 |              (>! ch {:str (str msg i) :wait wait})
12 |              (<! (timeout (rand-int 1000)))
13 |              (<! wait)
14 |              (recur (inc i)))
15 |     ch))
16 | 
17 | (let [ch (tut102/fan-in (boring "Joe") (boring "Ann"))]
18 |   (dotimes [_ 5]
19 |     (let [msg1 (<!! ch)
20 |           msg2 (<!! ch)]
21 |       (println (:str msg1))
22 |       (println (:str msg2))
23 |       (>!! (:wait msg1) :foo)
24 |       (>!! (:wait msg2) :bar)))
25 |   (println "You're both boring, I'm leaving"))
26 | 


--------------------------------------------------------------------------------
/src/sieve.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | // Send the sequence 2, 3, 4, ... to channel 'ch'.
 6 | func Generate(ch chan<- int) {
 7 | 	for i := 2; ; i++ {
 8 | 		ch <- i // Send 'i' to channel 'ch'.
 9 | 	}
10 | }
11 | 
12 | // Copy the values from channel 'in' to channel 'out',
13 | // removing those divisible by 'prime'.
14 | func Filter(in <-chan int, out chan<- int, prime int) {
15 | 	for {
16 | 		i := <-in // Receive value from 'in'.
17 | 		if i%prime != 0 {
18 | 			out <- i // Send 'i' to 'out'.
19 | 		}
20 | 	}
21 | }
22 | 
23 | // The prime sieve: Daisy-chain Filter processes.
24 | func main() {
25 | 	ch := make(chan int) // Create a new channel.
26 | 	go Generate(ch)      // Launch Generate goroutine.
27 | 	for i := 0; i < 100; i++ {
28 | 		prime := <-ch
29 | 		fmt.Println(prime)
30 | 		ch1 := make(chan int)
31 | 		go Filter(ch, ch1, prime)
32 | 		ch = ch1
33 | 	}
34 | }
35 | 


--------------------------------------------------------------------------------
/src/tut106.clj:
--------------------------------------------------------------------------------
 1 | ;; http://talks.golang.org/2012/concurrency.slide#39
 2 | 
 3 | (ns tut106
 4 |   (:require [clojure.core.async :refer [go >! >!! <! <!! chan]]))
 5 | 
 6 | (defn f [left right]
 7 |   (go (>! left (inc (<! right)))))
 8 | 
 9 | (let [leftmost (chan)
10 |       rightmost (loop [n 100000 left leftmost]
11 |                   (if-not (pos? n)
12 |                     left
13 |                     (let [right (chan)]
14 |                       (f left right)
15 |                       (recur (dec n) right))))]
16 |   (time
17 |    (do
18 |      (>!! rightmost 1)
19 |      (println (<!! leftmost)))))
20 | 
21 | ;; "Elapsed time: 1184.47656 msecs"
22 | 
23 | ;; $ go run tut106.go
24 | ;; 67.87ms
25 | 
26 | ;; ---
27 | 
28 | ;; The Clojure timings can be greatly improved by various JVM settings
29 | ;; since this benchmark is GC dominated.
30 | 
31 | ;; I've gotten this snippet down to < 200ms.
32 | 


--------------------------------------------------------------------------------
/src/tuthttp.clj:
--------------------------------------------------------------------------------
 1 | (ns tuthttp
 2 |   (:require [clojure.core.async :refer [go >!]]
 3 |             [clj-http.client]
 4 |             [org.httpkit.client]
 5 |             [clojure.xml :as xml]
 6 |             [clojure.zip :as zip]))
 7 | 
 8 | (defn blocking-get [url]
 9 |   (clj-http.client/get url))
10 | 
11 | (defn async-get [result url]
12 |   (org.httpkit.client/get url #(go (>! result %))))
13 | 
14 | (defn get-blog-entries [data]
15 |   (letfn [(zip-str [s]
16 |             (zip/xml-zip (xml/parse (java.io.ByteArrayInputStream. (.getBytes s)))))
17 |           (get-data [c]
18 |             (let [get-content (fn [tag] (->> c (filter #(= tag (:tag %))) first :content first))]
19 |               {:id (get-content :id)
20 |                :title (get-content :title)
21 |                :body (get-content :content)}))]
22 |     (->> data
23 |          :body
24 |          zip-str
25 |          zip/children
26 |          (filter #(= :entry (:tag %)))
27 |          (map :content)
28 |          (map get-data))))
29 | 


--------------------------------------------------------------------------------
/src/tut107.clj:
--------------------------------------------------------------------------------
 1 | ;; http://talks.golang.org/2012/concurrency.slide#50
 2 | ;; http://swannodette.github.io/2013/07/12/communicating-sequential-processes/
 3 | 
 4 | (ns tut107
 5 |   (:require [clojure.core.async :refer [go go-loop timeout >! >!! <! <!! chan alt!!]]))
 6 | 
 7 | (defn fake-search [kind]
 8 |   (fn [ch query]
 9 |     (go
10 |      (<! (timeout (rand-int 100)))
11 |      (>! ch [kind query]))))
12 | 
13 | (def web1 (fake-search :web1))
14 | (def web2 (fake-search :web2))
15 | (def image1 (fake-search :image1))
16 | (def image2 (fake-search :image2))
17 | (def video1 (fake-search :video1))
18 | (def video2 (fake-search :video2))
19 | 
20 | (defn fastest [query & replicas]
21 |   (let [ch (chan)]
22 |     (doseq [replica replicas]
23 |       (replica ch query))
24 |     ch))
25 | 
26 | (defn google [query]
27 |   (let [ch (chan)]
28 |     (go (>! ch (<! (fastest query web1 web2))))
29 |     (go (>! ch (<! (fastest query image1 image2))))
30 |     (go (>! ch (<! (fastest query video1 video2))))
31 |     (loop [i 0 ret []]
32 |       (if (= i 3)
33 |         ret
34 |         (recur (inc i) (conj ret
35 |                              (alt!! [ch (timeout 80)]
36 |                                     ([v] v))))))))
37 | 
38 | (dotimes [_ 10]
39 |   (println (google "clojure")))
40 | 


--------------------------------------------------------------------------------
/src/tut005.clj:
--------------------------------------------------------------------------------
 1 | ;;http://tour.golang.org/#68
 2 | 
 3 | (ns tut5
 4 |   (:require [clojure.core.async :refer [go <! chan <!! close!]]))
 5 | 
 6 | (defn walk [tree ch]
 7 |   (letfn [(walker [t]
 8 |             (go
 9 |              (when t
10 |                (<! (walker (:left t)))
11 |                (>! ch (:value t))
12 |                (<! (walker (:right t))))))]
13 |     (go
14 |      (<! (walker tree))
15 |      (close! ch))))
16 | 
17 | (defn same [t1 t2]
18 |   (let [ch1 (chan)
19 |         ch2 (chan)
20 |         drain #(loop [v (<!! %) res []]
21 |                  (if v (recur (<!! %) (conj res v)) res))]
22 | 
23 |     (walk t1 ch1)
24 |     (walk t2 ch2)
25 | 
26 |     (= (drain ch1) (drain ch2))))
27 | 
28 | (defrecord Tree [left value right])
29 | 
30 | (def t1 (Tree.
31 |          (Tree.
32 |           (Tree. nil 1 nil)
33 |           1
34 |           (Tree. nil 2 nil))
35 |          3
36 |          (Tree.
37 |           (Tree. nil 5 nil)
38 |           8
39 |           (Tree. nil 13 nil))))
40 | 
41 | (def t2 (Tree.
42 |          (Tree.
43 |           (Tree.
44 |            (Tree. nil 1 nil)
45 |            1
46 |            (Tree. nil 2 nil))
47 |           3
48 |           (Tree. nil 5 nil))
49 |          8
50 |          (Tree. nil 13 nil)))
51 | 
52 | 
53 | (same t1 t2)
54 | 


--------------------------------------------------------------------------------
/src/tut006.clj:
--------------------------------------------------------------------------------
 1 | ;;http://tour.golang.org/#70
 2 | 
 3 | (ns tut6
 4 |   (:require [clojure.core.async :refer [go chan timeout >! alts!!]]))
 5 | 
 6 | (defprotocol Fetcher
 7 |     (fetch [this url]))
 8 | 
 9 | (defn crawl [url depth fetcher ch]
10 |   (let [seen (atom #{})
11 |         crawler (fn crawler [url depth]
12 |                   (go
13 |                    (when (and (pos? depth) (not (@seen url)))
14 |                      (swap! seen conj url)
15 |                      (when-let [res (fetch fetcher url)]
16 |                        (>! ch (assoc res :url url))
17 |                        (doseq [u (:urls res)]
18 |                          (crawler u (dec depth)))))))]
19 |     (crawler url depth)))
20 | 
21 | (defrecord FakeFetcher []
22 |   Fetcher
23 |   (fetch [_ url]
24 |     ({"http://golang.org/"
25 |       {:body "The Go Programming Language"
26 |        :urls ["http://golang.org/pkg/"
27 |               "http://golang.org/cmd/"]}
28 | 
29 |       "http://golang.org/pkg/"
30 |       {:body "Packages"
31 |        :urls ["http://golang.org/"
32 |               "http://golang.org/cmd/"
33 |               "http://golang.org/pkg/fmt/"
34 |               "http://golang.org/pkg/os/"]}
35 | 
36 |       "http://golang.org/pkg/fmt/"
37 |       {:body "Package fmt"
38 |        :urls ["http://golang.org/"
39 |               "http://golang.org/pkg/"]}
40 | 
41 |       "http://golang.org/pkg/os/"
42 |       {:body "Package os"
43 |        :urls ["http://golang.org/"
44 |               "http://golang.org/pkg/"]}}
45 |      url)))
46 | 
47 | (let [ch (chan)]
48 |   (crawl "http://golang.org/" 4 (->FakeFetcher) ch)
49 |   (loop []
50 |     (let [tmo (timeout 500)
51 |           [msg chan] (alts!! [tmo ch])]
52 |       (if (= chan tmo)
53 |         (println "done")
54 |         (do
55 |           (println "Found" (:url msg) (:body msg))
56 |           (recur))))))
57 | 


--------------------------------------------------------------------------------
/src/tut201.clj:
--------------------------------------------------------------------------------
 1 | ;; http://talks.golang.org/2013/advconc.slide#14 (and later)
 2 | 
 3 | (ns tut201
 4 |   (:require [clojure.core.async :refer [go timeout >! >!! <! <!! chan close!]])
 5 |   (:use [clojure.set]
 6 |         [tuthttp]
 7 |         [logger]))
 8 | 
 9 | (defn subscription [url interval max-pending]
10 |   (let [update-ch (chan)
11 |         quit-ch (chan)
12 |         res-ch (chan)]
13 |     (go
14 |      (log url "started")
15 |      (async-get res-ch url)
16 |      (loop [[fst & rst :as updates] []
17 |             seen-ids (->> updates (map :id) (into #{}))]
18 |        (let [query [res-ch quit-ch (timeout interval)]
19 |              query (if-not (nil? fst) (conj query [update-ch fst]) ;; potentially append the put query
20 |                            query)
21 |              [msg ch] (alts! query)]
22 |          (cond
23 |           (= ch quit-ch) (close! update-ch)
24 |           (= ch update-ch) (recur rst seen-ids)
25 |           (= ch res-ch) (let [entries (get-blog-entries msg)
26 |                               new-entries (remove #(seen-ids (:id %)) entries)]
27 |                           (log "got" (count entries) ": new" (count new-entries) ":" url)
28 |                           (recur (take max-pending (concat updates new-entries))
29 |                                  (union seen-ids (->> new-entries (map :id) (into #{})))))
30 |           :else (do
31 |                   (async-get res-ch url)
32 |                   (recur updates seen-ids)))))
33 |      (log url "subscriber quitting"))
34 |     [update-ch quit-ch]))
35 | 
36 | (defn fan-in [& ins]
37 |   (let [ch (chan)]
38 |     (doseq [i ins]
39 |       (go (loop [v (<! i)]
40 |             (when v (>! ch v))
41 |             (recur (<! i)))))
42 |     ch))
43 | 
44 | (let [feeds ["http://feeds.feedburner.com/GDBcode?format=xml"
45 |              "http://blog.golang.org/feeds/posts/default"
46 |              "http://feeds.feedburner.com/GoogleOpenSourceBlog?format=xml"]
47 |       chs (mapv #(subscription % 1000 500) feeds)
48 |       all-ch (apply fan-in (map first chs))]
49 |   (dotimes [_ 5]
50 |     (log (<!! all-ch))
51 |     (Thread/sleep 1000))
52 |   (close! all-ch)
53 |   (doseq [qc (map second chs)]
54 |     (>!! qc true)))
55 | 


--------------------------------------------------------------------------------
/src/tut300.clj:
--------------------------------------------------------------------------------
 1 | ;; http://golang.org/doc/codewalk/sharemem/
 2 | 
 3 | (ns tut300
 4 |   (:require [clojure.core.async :refer [go go-loop timeout >! >!! <! <!! chan]])
 5 |   (:use [tuthttp]
 6 |         [logger]))
 7 | 
 8 | (defn state-monitor [interval]
 9 |   (let [updates (chan)]
10 |     (go-loop [statuses {}]
11 |              (let [[msg ch] (alts! [updates (timeout interval)])]
12 |                (cond
13 |                 (and msg (= ch updates))
14 |                 (recur (-> statuses
15 |                            (assoc-in [(:url msg) :status] (:status msg))
16 |                            (update-in [(:url msg) :count] (fnil inc 0))))
17 | 
18 |                 (= ch updates) :stop
19 | 
20 |                 :else
21 |                 (do
22 |                   (doseq [s statuses] (log s))
23 |                   (recur statuses)))))
24 |     updates))
25 | 
26 | (defn poller [in out status]
27 |   (go-loop []
28 |            (let [resource (<!! in)
29 |                  res-ch (chan)]
30 |              (when resource
31 |                (log "polling" resource)
32 |                (async-get res-ch (:url resource))
33 |                (let [res (<! res-ch)]
34 |                  (when (:error res)
35 |                    (swap! (:error-count resource) inc))
36 |                  (>! status (assoc res :url (:url resource))))
37 |                (>! out resource)
38 |                (recur)))))
39 | 
40 | (defn wait-and-schedule [resource out]
41 |   (go
42 |    (log "waiting for" (:url resource))
43 |    (<! (timeout (+ 10000 (rand-int 100) (* 10000 @(:error-count resource)))))
44 |    (log "scheduling" (:url resource))
45 |    (>! out resource)))
46 | 
47 | (def run (atom true))
48 | 
49 | (let [urls ["http://www.google.com/"
50 |             "http://golang.org/"
51 |             "http://blog.golang.org/"]
52 |       pending (chan)
53 |       complete (chan)
54 |       status (state-monitor 5000)]
55 | 
56 |   (dotimes [_ 2]
57 |     (poller pending complete status))
58 | 
59 |   ;; create and seed resources
60 |   (go
61 |    (doseq [u urls]
62 |      ;; we use an atom here to simulate handing over mutable state
63 |      (>! pending {:url u :error-count (atom 0)})))
64 | 
65 |   (go-loop []
66 |            (when @run
67 |              (let [[resource ch] (alts! [complete (timeout 1000)])]
68 |                (when (= ch complete)
69 |                  (wait-and-schedule resource pending))
70 |                (recur)))))
71 | 
72 | ;; (reset! run false)
73 | 


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