When I define a channel and use it directly, how can I close the channel later?

(let [view-chan (chan 1)]

  (go-loop []
    (let [response (<! view-chan)]
        (println response)
        )
      (recur))
    )

with clojure.core.async/close!

i.e.

(let [view-chan (async/chan 5)]
  (async/put! view-chan "a")
  (async/put! view-chan "b")
  (async/put! view-chan "c")

  (async/go-loop []
    (when-let [response (async/<! view-chan)]
      (println response))
    (recur))
  
  (async/close! view-chan)
  view-chan)

when reading from a channel in a loop, you should presume the channel will return nil at some point (when some other process closes it and the channel is exhausted), and loop no more.

What is the best explanation of the alts! function you've seen?

think of it as choosing exactly one of N possible futures

I don’t think I’ve ever seen an explanation other than the docs, but I think of alts! as kind of like a cond where the clauses are the channels’ next value, and the conditions are whichever channel sends that value “first”.

(Scare quotes since the notion of order in the context of multiple threads is kind of ambiguous)

I think of it as alt! + cond

I learned alt! much later than alts! (and, initially, found it harder to get an intuition for)

alexmiller: you got it backwards

sorry, yes

alt! == alts! + cond

I don't love the similarity of those names

I think codemartin is looking for just the intuition of what the operation means

I liked your first answer too

N things can possibly happen, but you only have to deal with one of them happening, and the operation tells you exactly which happened. Handling that is up to you