Hmm... can I bug the group with something silly? I'm pretty new to core.async, and I feel like this function is wrong, but I'm not sure why. something about the let and the go...

(defn fetch-binary [url]
  (let [b64 (go (<! (make-req url)))]
    b64))

@gowder: b64 is going to be assigned the go channel

you could simplify this to

(make-req url)

make-req is presumably going to return a channel

so you can just park on that channel

@danielcompton: thanks--- I thought I was confused. yeah, make-req generates a http request and returns a promise-chan that will receive the result of the request. with fetch-binary I'm just trying to call make-req and then return the contents of the channel when they show up

do you want fetch-binary to block until the results come back?

yeah

(defn fetch-binary [url]
  (<!! (make-req url)))

use a blocking take

This is in CLJ right?

CLJS.

ah,

that's part of what's confusing me. I could probably handle jvm threads...

you can’t block in JS

but I'm kind of a js newb

so you’re going to need to do all of the work inside a go block or use callbacks

so it really should be something like

(defn fetch-binary [url]
  (go (<! (make-req url))))

(this will be the second time I've ever used core.async in cljs ever...)

that is equivalent to just returning (make-req url)

the go macro will return a channel which your consuming code will need to park on

so you may as well return the channel from make-req

what does the code calling fetch-binary look like?

hrm. I'm super-confused. I'm trying to actually get the value off the channel, not the channel itself. So fetch-binary is meant to be an entry-point called by arbitrary functions... (The use here is that I'm trying to wrap all kinds of JS encoding horribleness with fetching binary files in browser...)

So the way I thought it would work is that make-req generates a pure javascript interop http request, then handles all the encoding in its own callback, plunks the properly encoded data on a channel, and returns the channel. And then fetch-binary calls make-req, gets the channel, and pulls the properly encoded data off the channel when it's there.

hmm... I think I'm slowly starting to understand. if the go block returns the channel, then what I really need to do is pass the (presumably side-effecting) function that actually makes use of the properly encoded data into fetch-binary, sort of like this:

(defn fetch-binary [func url]
  (go
    (let [b64 (<! (make-req url))]
      (func url))))

(func b64)

haha oops yeah @darwin. that's what happens when I start to think about async code and browsers... my brain stops being able to handle things like remembering what symbol is what.