Here is how I expected it to work

(def root-uuid (random-uuid))

;; Helper to set uuid and site-id
(defn base [uuid site-id]
  (->  (cause/base)
       (cause/set-uuid uuid)
       (cause/set-site-id site-id)))

;; Create a CausalList for site-id "foo"
(def cb1 (atom (base root-uuid "foo")))
(def starting-data '(1 2 3))
(swap! cb1 cause/transact [[nil nil starting-data]])

;; Get the backing nodes for site-id "foo"
(def cl (cause/get-collection @cb1))
(def nodes (seq cl))

;; Load CausalList from site-id "foo" at site-id "bar"
(def cb2 (atom (base root-uuid "bar")))
(swap! cb2 cause/transact nodes)

; Execution error (ExceptionInfo) at (<cljs repl>:1).
Please transact a root collection first by setting uuid and cause to nil
:repl/exception!

I don’t know the answer to your question but thanks for bringing this to my attention, I didn’t know there was a good clojure CRDT ❤️

I have a sinking suspicion that you can't do it 😞 https://github.com/smothers/cause/issues/10

(ns foo.common.events.visibility
  (:require
   [re-frame.core :as rf]
   [foo.chat.queries.visibility :as visibility-q]
   [foo.entry.queries.authentication :as auth-q]
   [foo.common.funcs :as f-utils]))


(rf/reg-event-db
 ::set-hidden-value
 (fn [db [_ value]]
   (visibility-q/set-hidden-value db value)))

(defn is-hidden? []
  (or (.-hidden js/document)
      (.-msHidden js/document)
      (.-webkitHidden js/document)
      (.-onblur js/document)))

(defn visibility-type []
  (cond
    (exists? (.-hidden js/document))  "visibilitychange"
    (exists? (.-msHidden js/document)) "msvisibilitychange"
    (exists? (.-webkitHidden js/document)) "webkitvisibilitychange"
    :else nil))

;; just a hobby project, so don't care that it doesn't check for android
(defn is-mobile []
  (f-utils/not-nil? (.match (.-userAgent js/navigator) #"(?i)iPhone")))

(defn handle-visibility-change []
  (.log js/console (is-hidden?))
  (rf/dispatch [::set-hidden-value (is-hidden?)])
   (rf/dispatch [::quit-if-visible]))

(rf/reg-event-fx
 ::quit-if-visible
 (fn [cofx]
   (let [db (:db cofx)
         admin? (auth-q/get-admin-status db)]
     (when (and
            (is-hidden?)
            (not admin?)
            (is-mobile))
       (.replace (.-location js/window) "")
     {}))))


(defn set-visibility-listener []
  (.addEventListener js/document
                     (visibility-type)
                     handle-visibility-change
                     false))

(defn remove-visibility-listener []
  (.removeEventListener js/document
                     (visibility-type)
                     handle-visibility-change
                     false))

Would you be able to do something like?

(defn foo* [a]
  `[~a :b])

(defmacro foo [a]
  (foo* a))

(defmacro alet [a body]
 (let [exp (foo* a)]
  `(let ~exp ~body)))

Interesting

Actually, yes, I think that would work here.

I forgot about ClojureScripts phase mixing. 🙂

I often write my macros using that pattern regardless since it's easier to work with functions than macros

Ya, that I have noticed.

I'm used to Racket's more powerful macro system.

Anyway, thanks.