(m/ap (m/? (m/?> (m/seed (repeat (m/sp (cb (rand-int 1000))))))))

(m/ap (loop [] (m/amb (cb (rand-int 1000)) (recur)))

thanks!

I mean how to invoke this function and get the value passed to cb as the flow value

I’m trying to poll an async browser api

btw if you're struggling with this in photon there's already poll-task in the repo

I’ll have a look

what about the cb part

how to turn an async (cb-based fn) into a flow?

observe is generally a good fit for callback based apis

this is actually passive (promise) based

I see I misunderstood your question, sorry about that. Can you provide a more concrete example? Which API are we talking about?

I just can’t figure out how to plug missionary in as the cb/consumer of the value

location api

(defn location
  ([]
   #?(:cljs
      (p/promise [resolve reject]
        (location resolve))))
  ([cb]
   #?(:cljs
      (when-let [gl (j/get js/navigator :geolocation)]
        (j/call gl :getCurrentPosition
                (fn [pos]
                  (let [{:keys [accuracy altitude latitude longitude]}
                        (j/lookup (j/get pos :coords))]
                    (cb
                      {:accuracy  accuracy
                       :altitude  altitude
                       :latitude  latitude
                       :longitude longitude}))))))))

this returns a promise on arity 0 or takes a callback on arity 1

ideally I’d have a p/def in photon that updates once 1 minute with the users current location

e.g.

(p/def user-location (new ...))

At the call site you'd just (new get-location)

it renders but does not update

simplified to

(defn cb-fn [cb]
  (cb (rand-int 1000)))

(p/def get-location
  (m/observe (fn [!]
               (cb-fn !)
               ((m/sp (loop []
                        (m/? (m/sleep 10))
                        (m/amb (cb-fn !) (recur)))) {} {}))))


(p/defn App [route]
  (p/server
    (binding [db (p/watch db/conn)]
      (p/server
        #_(dom/div "route: " route)
        ;(Home.)
        (p/client
          (dom/div
            (new get-location)))
        ))))

are a few things missing here? there are some empty maps in the fn body https://clojurians.slack.com/archives/CL85MBPEF/p1673385114656969?thread_ts=1673383809.732179&cid=CL85MBPEF

change p/def to def

same

now it does not render

fixing, give me a min

this works

(p/def t
  (m/observe
    (fn [!]
      (cb-fn !)
      ((m/sp (loop []
               (m/? (m/sleep 1000))
               (sdom/location !)
               (recur)))
       {} {}))))

I'm sorry I'm too tired at this point

all good, I got it to work somewhat well

however:

(p/def user-location-working
  (new
    (m/observe
      (fn [!]
        ;; this works
        (! nil)
        ((m/sp
           (loop []
             (m/? (m/sleep 1000))
             (sdom/location !)
             (recur)))
         {} {})))))

(p/def user-location-breaking
  (new
    (m/observe
      (fn [!]
        ;; this breaks
        (sdom/location !)
        ((m/sp
           (loop []
             (m/? (m/sleep 1000))
             (sdom/location !)
             (recur)))
         {} {})))))

i think that loop can crash if it is faster than the consumer backpressure

right, it would be better to have a flow-like abstraction that lazily gets the location when sampled

I just couldn’t figure out how to do that, especially with a callback based api

ok clearly you understand, we can improve it later i’m afk

it might be complex you can see the photon dom/clock if you are interested i believe it schedules next sample as a side effect of sampling or something like that

hmm, I’m not sure it even needs to do that

could still use m/sample with dom/<clock to get the values at certain times

just need location as a flow

you’re right i think

here's an implementation of a task that returns the result of running a callback and a flow wrapper around that task. You'll need to sample it with a clock. (see Leo's answer below)

it's a discrete flow, to use it in photon you'll need to wrap it e.g. (m/reductions {} nil location>) to provide an initial value

> it would be better to have a flow-like abstraction that lazily gets the location when sampled This is not possible because sampling is synchronous and the location api is asynchronous. @U09FL65DK’s approach is correct, first build a discrete flow that eagerly polls the api at regular intervals then turn that into a continuous flow with reductions + relieve

thank you all

@U09FL65DK I tried your impl but cannot get a value to render

the following renders a single value that does not update. the other permutations froze up the browser tab

(p/defn MockLoc []
  (p/client
    (let [location (->> location>
                        (m/eduction (take 1))
                        (m/reductions {} nil)
                        #_(throttle 1000)
                        #_(m/latest identity)
                        new)]
      (dom/div
        "value " (pr-str location)))))

a sleep in the flow prevents the tab from freezing

(def location>
  (m/ap (loop []
          (m/? (m/sleep 100))
          (m/amb (m/? (get-location)) (recur)))))

however, can it sleep after returning the first value?

okay, got it:

(def location>
  (m/ap (loop []
          (m/amb (m/? (get-location))
                 (do (m/? (m/sleep 2000)) (m/amb))
                 (recur)))))

(p/defn MockLoc []
  (p/client
    (let [location (->> location>
                        (m/reductions {} nil)
                        new)]
      (println location)
      (dom/div
        "value " (pr-str location)))))

the missionary learning curve is no joke!

Leo's going to have to write a book 🙂

well, missionary is aptly named. I’m getting converted!

glad to hear that !