Quick hacky idea for generating maps with refs (still has bugs)

ex.clj

(require '[clojure.test.check.generators :as gen2])
(require '[clojure.spec.alpha :as s])

(s/def :aero/path (s/coll-of simple-keyword? :kind vector? :min-count 1 :max-count 3))

(defn aero-map [paths vals-or-refs backups]
  (->> (map vector paths vals-or-refs backups)
       (reduce
        (fn [m [p [t v] [_ backup-v]]]
          (case t
            :aero/scalar
            (assoc-in m p v)
            :aero/ref
            ;; refs should not refer to themselves
            (if (= p v)
              (assoc-in m p backup-v)
              (assoc-in m p [t v]))))
        {})))
  
(gen/sample (gen2/let [paths (s/gen (s/coll-of :aero/path :min-count 1))
                       ;; "scalars" is only strings right now,
                       ;; but of course could be expanded to other scalar types
                       scalars (s/gen (s/coll-of
                                       (s/tuple
                                        #{:aero/scalar}
                                        string?)
                                       :count (count paths)))
                       refs (gen/vector (gen/elements
                                         (map (fn [r] [:aero/ref r]) paths))
                                        (count paths))
                         vals-or-refs (gen/vector (gen/elements
                                                   (concat
                                                    scalars
                                                    refs))
                                                  (count paths))]
              (aero-map paths vals-or-refs scalars)
              ) 3)

There is a bug where assoc-in isn't always safe, depending on the old state of map. What we need is a "safe" version of assoc-in that only inserts the value if there is a valid path so far.