Hi, Hoping someone can shed some light on some behaviour I'm observing when using a partially applied map function as the computational function with reg-sub. Example:

(ns me.scribble 
  (:require [re-frame.core :as r]
            [re-frame.db :as rdb]))

(defn x [key items]
  (map key items))

(r/reg-sub
 ::msgs
 (partial map :msg))

(r/reg-sub
 ::msgs2
 (partial x :msg))


(comment
  (defn test-me []
    (reset! rdb/app-db [{:msg "hello"} {:msg "world"}])
    (r/clear-subscription-cache!)

    [(deref (r/subscribe [::msgs]))
     (deref (r/subscribe [::msgs2]))])

  (test-me) ;;  [("hello") ("hello" "world")])

I’ve tried just the functions in a repl and it seems to produce the same result

It might be worth seeing what data

(r/reg-sub
 ::msgs
 (partial map :msg))

Gets and trying it that way too

Hi @guy, I'm not sure I follow your suggested debugging technique?

Sorry i just mean, can you show me the shape of the data you get for ur reg-sub functions

The input data for app-db is : [{:msg "hello"} {:msg "world"}]

because when i try ((partial map :msg) [{:msg "hello"} {:msg "world"}]) i get the same thing as ((partial x :msg) [{:msg "hello"} {:msg "world"}])

yep when you run the functions outside of a subscription handler you get the same result for both functions

Can you try doing (map :msg) and see what happens instead of partial?

as that returns a function

(r/reg-sub
 ::msgs
 (map :msg))

like that i mean sorry

yep tried that and get the following returned from test-me: [#object[G__10856] ("hello" "world")]

lol ok

alright cool

yeah i was wrong sorry

What i find odd is its just returning the “hello” and nothing else

dumb question have you tried killing the repl and restarting it, just incase you had some older functions in it?

(rf/reg-sub
  :time
  (fn [db _]     ;; db is current app state. 2nd unused param is query vector
    (:time db))) ;; return a query computation over the application state

restarted repl: same result

So it looks like in the example they wrap the sub with a (fn [db _] ...)

Maybe you could try that?

In my example I'm using reg-sub with no explicit input signals, which means it will default to app-db

https://github.com/Day8/re-frame/blob/master/src/re_frame/subs.cljc#L235

So I'm registering a computation function that will be automatically passed app-db (a vector in my example)

Sorry then i don’t know 😞 i’ll lurk around to wait to see if someone answers it

@guy appreciate your input!

thanks

The strangest part for me is it consuming just one message from the vector

That to me says its something to do with map and processing a series of collections potentially

BTW - I have observed this behaviour in the browser - so it's not just a REPL related thing

(map :msg [{:msg "hello"} {:msg "hi"}] [:a]) => (“hello”)

So you might be getting this

Where map takes two collections rather than just one

thats the only way i could get it to produce “hello” in a list

((partial map :msg) [{:msg "hello"} {:msg "hi"}] [:a]) => (“hello”)

looks like its the same

but that just assumes the data you get

Yeah - I see your line of thinking

So it might be a red herring 😞

Not sure how to confirm that hypothesis

haha yeah

ok well i’ll go back to lurking

ping me if you find out what was wrong 😄

:thumbsup:

@mf

I think its what i said is happening

try doing

(rf/reg-sub
  ::msgs
  str)

just replace your partial map with str and see what you get back

on my screen i get something like

i changed the example in re-frame and did somestuff to get it but its essentially v similar

So that shows you, that u get given the db and a vector with an event in it

(map :msg [{:msg "hello"} {:msg "hi"}] [:a])

which was just like this (more or less)

So thats why you only get given “hello” back

because the way map works is it only maps over the same number of items in the given collections i believe

As to how to fix it? I think if you wrap it in a fn and destructure it a different way that might work?

(rf/reg-sub
  ::msgs
  (fn [{msgs :msgs :as db} _]
    (map :msg msgs)))

ok so my data structure isnt the same as yours

my db is like

{:time (js/Date.)         ;; What it returns becomes the new application state
     :time-color "#f88"
     :msgs [{:msg "hello"} {:msg "world"}]}

so i use a fn and destructure the mgs out then just map over them and it works

So for your example to get it working in your test-me function you could do something like

(reset! rdb/app-db {:msgs [{:msg "hello"} {:msg "world"}]})

Where you make ur app-db a map instead of a vector, you would need to change both functions i believe

anyways let me know how you get on :thumbsup:

@guy you're onto something - for sure

I confirm that the computational function is receiving both the db and the event-name

and when both are passed to map it behaves as you describe

I can also confirm that my x function also receives the additional argument (as you would expect) - although obviously x doesn't use it as map does (hence x worked!)

:thumbsup:

So i think if you just use the other format you will get the outcome you need

(fn [db _] ...) one

yeah also one thing to note, (reset! rdb/app-db [{:msg "hello"} {:msg "world"}]) I think this is a little unusual

as i think app-db is usually a map

and you are actually creating an atom with a vector in it

also

;; -- Application State  --------------------------------------------------------------------------
;;
;; Should not be accessed directly by application code.
;; Read access goes through subscriptions.
;; Updates via event handlers.
(def app-db (ratom {}))

- yeah I'm just using reset! to enable testing in the REPL - I do use a map in real life 😉

so i’m not even sure you should be calling reset! at all

ah ok cool

😄

(the entire test-me function is to enable me to recreate this issue in the REPL)

ah ok got ya

makes sense :thumbsup:

Still playing with it atm, will let you know more

:thumbsup:

@guy Yep it comes down to the fact that the computational function passed to reg-sub will always receive the event-name as an additional argument.

yeah

The thing that gave it away to me was the single “hello” thing really

I’ve used (map fn col1 col2) before

and it maps over each of the collections and does stuff

but only up the least number of items in each coll i believe

:thumbsup: Using the str function to debug the inputs gave the insight

(good thinking)

haha

thanks

i’m a re-frame noob so i’m still learning

Anyway - really appreciate you helping me get to the bottom of it!

anytime!