task.clj

;; testing task impl on dev-vthreads branch
;; requires JDK 21+ 

(ns c.c.async
  (:require [clojure.core.async :as ca]))

(set! *warn-on-reflection* true)

(let [c (ca/chan)]
  (ca/task (ca/>!! c "hello"))
  (assert (= "hello" (ca/<!! (ca/task (ca/<!! c)))))
  (ca/close! c))

(def echo-chan (ca/chan))
(ca/task (println (ca/<!! echo-chan)))
(ca/>!! echo-chan "task ketchup")

(def echo-chan (ca/chan))
(ca/go (println (ca/<!! echo-chan)))
(ca/>!! echo-chan "go ketchup")

(macroexpand '(ca/task (println (ca/<!! echo-chan))))
(macroexpand '(ca/go (println (ca/<!! echo-chan))))
(macroexpand '(ca/go-loop [a 42] (println (ca/<!! echo-chan))))

(def hi-chan (ca/chan))
(doseq [n (range 1000)]
  (ca/task (ca/>!! hi-chan (str "hi " n))))

(defn hot-dog-machine
  []
  (let [in (ca/chan)
        out (ca/chan)]
    (ca/task (ca/<! in)
             (ca/>! out "hot dog"))
    [in out]))

(let [[in out] (hot-dog-machine)]
  (ca/>!! in "pocket lint")
  (ca/<!! out))

(let [c1 (ca/chan)
      c2 (ca/chan)
      c3 (ca/chan)]
  (ca/task (ca/>! c2 (clojure.string/upper-case (ca/<! c1))))
  (ca/task (ca/>! c3 (clojure.string/reverse (ca/<! c2))))
  (ca/task (println (ca/<! c3)))
  (ca/>!! c1 "redrum"))

#_(ca/>! (ca/chan) 42)

(defn upload
  [headshot c]
  (ca/task (^[long] Thread/sleep (rand 100))
           (ca/>! c headshot)))

(let [c1 (ca/chan)
      c2 (ca/chan)
      c3 (ca/chan)]
  (upload "serious.jpg" c1)
  (upload "fun.jpg" c2)
  (upload "sassy.jpg" c3)
  (let [[headshot channel] (ca/alts!! [c1 c2 c3])]
    (println "Sending headshot notification for" headshot)))

(defn upper-caser
  [in]
  (let [out (ca/chan)]
    (ca/task (while true (ca/>! out (clojure.string/upper-case (ca/<! in)))))
    out))

(defn reverser
  [in]
  (let [out (ca/chan)]
    (ca/task (while true (ca/>! out (clojure.string/reverse (ca/<! in)))))
    out))

(defn printer
  [in]
  (ca/task (while true (println (ca/<! in)))))

(def in-chan (ca/chan))
(def upper-caser-out (upper-caser in-chan))
(def reverser-out (reverser upper-caser-out))
(printer reverser-out)

(ca/>!! in-chan "redrum")
(ca/>!! in-chan "repaid")
(ca/>!! in-chan "loop")

;; pipeline
;; currently throwing in vthread, but result is correct
;; i.e. Can't put nil on channel

(let [cout (ca/chan 1)]
  (#'ca/pipeline* 5 cout (map identity) (ca/to-chan! [1]) true nil :compute)
  (ca/<!! cout))

(let [cout (ca/chan 1)
      res (atom nil)]
  (#'ca/pipeline* 5 cout (map identity) (ca/to-chan! [1]) false nil :compute)
  (reset! res (ca/<!! cout))
  (ca/>!! cout :foo)
  [@res (ca/<!! cout)])