I'm elbow deep in some re-frame/reagent machinery and could use some insight if anyone has some

what I'm seeing is that when I deref a re-frame subscription, dependent subscriptions are run twice

(rf/reg-sub
  :greeting
  (fn [_ [_ name]]
    (js/console.log "in greeting")
    (str "Hello, " name)))

(rf/reg-sub
  :excited-greeting
  :<- [:greeting]
  (fn [greeting _]
    (str (string/capitalize greeting) "!")))

@(rf/subscribe [:excited-greeting])

now, this changes if I wrap the deref of the subscription in a ratom context:

(binding [reagent.ratom/*ratom-context* #js {}]
  @(rf/subscribe [:excited-greeting]))

now I'm writing a React hook to use with reactions/subscriptions, so this is relevant for app development since there's not a ratom-context set when rendering a plain React component

I could set one like I have, but I really have no idea what effect it has other than not double computing on initial computation

dumb question, but what is the motivation for this?

using reagent reactions in an app that doesn't use reagent for creating components

ah, well

also, initially I wrote the hook to use add-watch & remove-watch to subscribe to the reaction. however, changes were not propagated until I wrapped it in a *ratom-context*

I don't mind wrapping it but I'm worried I may be introducing a memory leak somewhere. the reaction code is such a hairy nest it's hard for me to keep track of what uses which

Regarding double subscription evaluation - probably this? https://github.com/day8/re-frame/issues/657

Hi guys, I am completely beginner with Reagent and I was wondering how do I translate the React props of a component to reagent functions? For example

function MyDialog() {
  let [isOpen, setIsOpen] = useState(true)

  return (
    <Dialog open={isOpen} onClose={() => setIsOpen(false)}>
    </Dialog>
  )
}

Hey folks, I have a question. I'm extending a React library to have a Tooltip and a Button element. The Tooltip documentation says: > Please ensure that the child node of Tooltip accepts onMouseEnter, onMouseLeave, onFocus, onClick events. So, if I wrap the Button in a function to create a Reagent component, the tooltip doesn't work. Does someone know how to explain to me why, please?

;; Here the tooltip work on the button
  [:> Tooltip {:title "Foo Bar"}
   [:> Button "Hover me!"]]

  (defn wrap-button [text]
    [:> Button text])

  ;; But here the tooltip doesn't work
  [:> Tooltip {:title "Foo Bar"}
   [wrap-button "Hover me!"]]

hmm, I cannot think of a way to make reagent reactions work w/ React concurrency w/o introducing the double compute problem w/ re-frame subs, leaking memory or showing an initial nil value

(defn use-reaction2
  [reaction]
  (let [inner-reaction (hooks/use-ref nil)
        cb (hooks/use-ref identity)]
    (hooks/use-subscription
      (hooks/use-memo
        [reaction]
        {:get-current-value
         (fn []
           (if-some [ir @inner-reaction]
             @ir
             (ra/run-in-reaction
               #(deref reaction)
               inner-reaction
               "current"
               (fn [_] (@cb))
               {})))
         :subscribe (fn [callback]
                      (reset! cb callback)
                      #(r/dispose! @inner-reaction))}))))

which will leak memory, since it will persist in the watchers of the reaction passed in

this doesn't happen in the current stable version because it synchronously renders components, but w/ React Concurrency it may interleave renders based on different events and end up throwing away a render that is determined to be unusable after committing a different render

oh also that code is horribly broken hmm

(defn use-reaction
  [reaction]
  (let [inner-reaction (hooks/use-ref nil)
        cb (hooks/use-ref identity)]
    (hooks/use-subscription
      (hooks/use-memo
        [reaction]
        {:get-current-value
         (fn []
           (if (some? @inner-reaction)
             @reaction
             (ra/run-in-reaction
               #(deref reaction)
               inner-reaction
               "current"
               (fn [_] (@cb))
               {})))
         :subscribe (fn [callback]
                      (reset! cb callback)
                      #(r/dispose! @inner-reaction))}))))

the correct thing to do is dereference the original reaction

this essentially replicates what Reagent components do on render within get-current-value

this might be remediated in by using a finalizer to dispose of the reaction on GC

you could have a sentinel object which has a reference to the reaction returned by run-in-reaction, and when that object is GC'd call dispose! on that reaction

oh the reason that the state of the reaction created by run-in-reaction was nil is because it needs to have _run called on it

this is all so confusing 😵