clojure.core.async/alt!

View this page on ClojureDocs

Type: macro Added: Clojure unknown Examples: 4 Runnable: 0

([& clauses])

Makes a single choice between one of several channel operations, as if by alts!, returning the value of the result expr corresponding to the operation completed. Must be called inside a (go ...) block.

Each clause takes the form of:

channel-op[s] result-expr

where channel-ops is one of:

take-port - a single port to take [take-port | [put-port put-val] ...] - a vector of ports as per alts! :default | :priority - an option for alts!

and result-expr is either a list beginning with a vector, whereupon that vector will be treated as a binding for the [val port] return of the operation, else any other expression.

(alt! [c t] ([val ch] (foo ch val)) x ([v] v) [[out val]] :wrote :default 42)

Each option may appear at most once. The choice and parking characteristics are those of alts!.

Examples

by hlship on 2014-11-11 . May have evaluation errors. ▶

;; attempts to put trade on channel trade-ch within 1 second. ;; yields :timed-out or :sent. (let [timeout-ch (timeout 1000)] (alt! timeout-ch :timed-out ;; note use of double-nested vector; [trade-ch trade] ;; would be interpreted as two channels to take from, resulting ;; in an odd error. [[trade-ch trade]] :sent))

by boxxxie on 2014-12-10 . May have evaluation errors. ▶

(def trade-ch (chan)) (go-loop [] (<! (timeout 1000)) (print (<! trade-ch)) (recur)) (go (let [timeout-ch (timeout 1000) trade 100] (-> (alt! [[trade-ch trade]] :sent timeout-ch :timed-out) print))) ;;eval this at will ;;printout example core.js[38]: :sent core.js[38]: 100 core.js[38]: 100 core.js[38]: :sent core.js[38]: :timed-out core.js[38]: :timed-out core.js[38]: :timed-out core.js[38]: :timed-out core.js[38]: :timed-out core.js[38]: :timed-out core.js[38]: :sent core.js[38]: 100

by spiralman on 2015-01-10 . May have evaluation errors. ▶

;; Reading from multiple channels, handling whichever gets data first (use 'clojure.core.async) (def result-chan (chan)) (def error-chan (chan)) (def dont-care-chan (chan)) (go (alt! result-chan ([result] (println (str "Success: " result))) error-chan ([error] (println (str "Error: " error))) dont-care-chan (println "Don't care about the value!"))) ;; Given (put! result-chan "Some result") ;; Output ;; Success: Some result ;; Given (put! error-chan "Some error") ;; Output ;; Error: Some error ;; Given (put! dont-care-chan "Some value") ;; Output ;; Don't care about the value!

by cstml on 2025-01-21 . May have evaluation errors. ▶

(require [clojure.core.async :as a]) (let [|a (a/chan) |b (a/chan)] (a/go (let [winner (a/alt! |a ([v] (do (println (str v " won!")) v)) |b ([v] (do (println (str v " won!")) v)))] (println winner))) (a/put! |a :a) (a/put! |b :b)) ;; 1st run ;; :a won! ;; :a ;; 2nd run ;; :b won! ;; :b ;; etc.

Note by jzwolak

alt! does not take a vector of ports as per alts!. alts! takes a vector of ports. alt! takes a literal vector of ports only. Any symbol containing a value that is a vector of ports will not work with alt! even though such a value will work with alts!.

(ns examples.failing-async
  (:require [clojure.core.async :refer [chan go alt! >! alts!]]))

(def c1 (chan))
(def c2 (chan))
(def two-chans [c1 c2])

(println (vector? two-chans))

; Fails
(go (loop []
      (alt! two-chans ([v c] (println "got v =" v)))
      (recur)))

(go (>! c1 "hi on alt! two-chans"))

; Succeeds (must comment out above failing code for this to work)
(go (loop []
      (alt! [c1 c2] ([v c] (println "got v =" v)))
      (recur)))

(go (>! c1 "hi on alt! [c1 c2]"))

; Succeeds
(go (loop []
      (let [[v c] (alts! two-chans)]
        (println "got v =" v))
      (recur)))

(go (>! c1 "hi on alts! two-chans"))

See also

• clojure.core.async/alts! (1)

---

Content from the matching ClojureDocs page, with authors credited on each contribution.