Awaiting response

[emiln]

At times it would be great to be able to await a response to some emitted event.

(handle :add +)
(println (<!! (emit! :add 1 2 3)))

The idea is that any handler for :do-some-io can return a non-nil value, and this will be put onto the channel awaited by the function that called emit! :do-some-io. This raises a few questions, however, and answering these will be the first task of this story:

• If multiple functions are awaiting feedback on the same topic, should they all be notified separately by all handlers of the topic?

Yes

• When should these feedback channels close?

By the caller of emit!; warrants function split

This is actually a fairly difficult question to answer. It seems unlikely that any one handler will be able to ascertain that no future puts from other handlers could occur to the channel. This leaves the question of whether emit! should be split into two functions: one returning an open channel that handlers may communicate over, and one returning nil, opening no channels. I think this might be preferable as it does not risk leaving open channels everywhere, and does not require the caller of emit! to diligently close all open, unused feedback channels.

• Do emit! and handle at this point provide a genuinely simpler and easier interface to the user, or are they really just reinventing core.async poorly?

They are warranted

If you wanted to do this without handle and emit!, you'd declare the following once:

(def publisher (chan))
(def publication (pub publisher first))

And the following for every pair of handle and emit! calls:

(let [handler (chan)]
  (sub publication :add handler)
  (go (let [[_ return-chan & args] (<! handler)]
        (>! return-chan (apply + args)))))

(let [return-chan (chan)]
  (go (>! publisher [:add return-chan 1 2 3])
  (println (<!! return-chan))))

While this is certainly not a big task, I do think handle and emit! provide an easy as well as simple way to deal with this very topic-centric flow.

• What should happen when a handler returns nil? It is not legal to put on a channel.

Nothing is put

It is not safe to assume you can close the channel as more puts from other handlers may happen in the future. It is not legal to put nil on the channel either, so the sensible and most simple solution is most likely to just don't put anything on at all in this case.

[emiln]

One corner case: What to do when the the handler returns nil?