Hi all! I created a really simple ping-pong simulation: https://gist.github.com/jmglov/8b89fe00aefe3f94f3b904eae9db32c1

It works just fine with blocking puts and gets (`<!!` and >!!).

But when I switch to <! and >! and change my loop to go-loop, my play function simply returns immediately after printing "Ping" once.

Clearly I'm misunderstanding something very fundamental, but I'm not what what. 🙂

Is go-loop ... recur not the way to loop?

@jmglov: go version of your code is non-blocking, that means the function with go-loop “spawns another thread” and returns immediately, (quotes used because in reality is it a bit more complex behind the scenes)

That makes sense, but shouldn't I still see pings and pongs printed from the spawned "thread"?

The go macro basically makes some sort of magic FSM, right?

yes, if the process is still up and running, but if your -main quits after calling the play function, core.async helper threads quit as well I think

I was just doing this in my REPL.

So my main thread is still up.

hmm, that should work, I guess

I guess I should check out the returned channel.

Is there a way to "peek" at a channel without consuming a value?

I think lines #16 and #17 should be wrapped in <!

can you post your non-blocking version?

I could review it

Thanks! Coming right up.

Here it is: https://gist.github.com/jmglov/d75787d31cf7c05fde09c45a01528ef2

Do I need to transduce the channel or something?

Am I effectively getting back a lazy seq from go-loop?

go-loop gives you a normal channel back

it is just a sugar for (go (loop…))

try this version: https://gist.github.com/darwin/bfeb7d25c11692e3f6fd431a7650deab

Interesting. So >! and <! always need to be wrapped in a go form, even when inside a go-loop?

I’m not familiar with Clojure version of core.async, this is how I would write it in ClojureScript

That does work, but my timeout channels don't seem to have any effect, and I get this output:

Ping
Game over!
Pong
Ping
Pong
Ping
Pong
Ping
Pong
Ping
Pong
Ping

<! must be inside go AFAIK, and “inside” means inside current code block, it does not transition across function call boundaries as you wrongly assume

OK, that actually makes sense.

But that still doesn't explain what the timeouts aren't honoured.

Let me try yet another version, but this time without functions.

have to go, will be back in 10mins

And this one works perfectly:

(defn play []
  (let [ch (async/chan 1)]
    (async/go-loop [cnt 0]
      (if (= cnt 0)
        (do
          (>! ch :ping)
          (println "Ping")
          (<! (async/timeout 500)))
        (let [ball (<! ch)]
          (if (= ball :ping)
            (do
              (>! ch :pong)
              (println "Pong")
              (<! (async/timeout 500)))
            (do
              (>! ch :ping)
              (println "Ping")
              (<! (async/timeout 500))))))
      (if (< cnt 10)
        (recur (inc cnt))
        (println "Game over!")))))

Thanks for the help.

Now I'll do a super-yucky one with macros instead of functions.

😉

BTW, what is the best practise for DRYing up core.async code, given that functions are a bit problematic?

I think functions should work as well, no need for macros here

But like you said, go blocks don't carry across function boundaries.

Which seems to be problematic for my timeout channels at the very least.