Is there an EDN parser that can output a full AST including line and column numbers?

I am trying to optimize a clojure function. When I use Java VisualVM to look at the running process. I see low CPU utilization, however, about 1000 classes are created per call. The function in question is recursive (non-tail), is that the likely culprit? Or is there another known reason why crap tons of classes would be created? Thanks in advance for any advice!

Classes created or instances created?

Classes

Share raw data if possible

Sources/ graphs

graph coming…

The function in question would be really useful too

I can share that but not the data (without obfuscating it). one sec. thanks!

Green circles are func in question, when run from repl

(defn- process-message
  [hl7 parsed segment-defs func]
  (let [_ nil]
    (loop [parsed (remove-unknown parsed (all-known-segments segment-defs))
           remaining segment-defs
           result {}
           lines-read 0]
      (if-let [seg-def (first remaining)]
        (if-let [seg (first parsed)]
          (cond
            (some? (seg-def :pea.hl7/id)) (let [seg-def-id (seg-def :pea.hl7/id)
                                                seg-details (get-in hl7 [:pea.hl7/segments seg-def-id])
                                                ;_ (println (str "seg-details: " seg-details))
                                                title-key (keyword (.replace (.toLowerCase (seg-details :pea.hl7/desc)) " " "-"))
                                                seg-id (select-first [0 0 0 0] seg)
                                                not-repeating (= :pea.hl7/none (seg-def :pea.hl7/repeatability))
                                                _ nil]
                                            (if (= seg-def-id seg-id)
                                              (if not-repeating
                                                (recur (rest parsed) (rest remaining) (assoc result title-key (func seg seg-def)) (+ lines-read 1))
                                                (let [previous (or (result title-key) [])
                                                      value (func seg seg-def)
                                                      values (conj previous value)]
                                                  (recur (rest parsed) remaining (assoc result title-key values) (+ lines-read 1))))
                                              (recur parsed (rest remaining) result lines-read)))
            (some? (seg-def :pea.hl7/segments)) (let [title-key (keyword (.replace (.toLowerCase (seg-def :pea.hl7/segment-group)) " " "-"))
                                                      segments (seg-def :pea.hl7/segments)
                                                      not-repeating (= :pea.hl7/none (seg-def :pea.hl7/repeatability))
                                                      sub-proc (process-message hl7 parsed segments func)
                                                      sub-group (sub-proc 0)
                                                      lines-to-drop (sub-proc 1)
                                                      _ nil]
                                                  (if not-repeating
                                                    (recur (drop lines-to-drop parsed) (rest remaining) (assoc result title-key sub-group) (+ lines-read lines-to-drop))
                                                    (let [previous (or (result title-key) [])
                                                          values (conj previous sub-group)
                                                          the-remaining (if (= 0 lines-to-drop) (rest remaining) remaining)]
                                                      (recur (drop lines-to-drop parsed) the-remaining (assoc result title-key values) (+ lines-read lines-to-drop)))))
            :default (throw (Exception. (str "Don't really know how we got here: " remaining))))
          [result lines-read])
        [result lines-read]))))

use a snippet if possible (CMD-Shift-Enter, you can even have it highlight clojure syntax)

the intention here is to take a list like [{},{},{},{},{},{},{},{}] and turn it into this: [{}, {}, [{} {}], {:a {} :c [{} {}]}] based on some rules

I posted this a few weeks back, but since we're still looking for more responses, I'll post it here one more time for those who missed it: The Programing Research Laboratory at Northeastern University is conducting a study on the usability of visual and interactive syntax for ClojureScript. Participation involves filling out a questionnaire and is expected to take about 30 minutes. The questionnaire consists of multiple choice and free form responses. All questions are optional and responses are anonymous. If you are interested in participating, please visit: https://study.visr.pl (Chrome Recommended) To learn more about visual and interactive syntax for ClojureScript, please visit: https://prl.ccs.neu.edu/blog/2022/01/06/introducing-visual-and-interactive-syntax-realized-visr-for-clojurescript-and-javascript If you have any questions, please contact: <mailto:[email protected]|[email protected]>

@lucasjordan another thing you can do is turn on logging when classes are loaded: -Xlog:class+load=info

Working on finally updating the https://github.com/jarcane/clojurice template, and running into the dreaded "illegal reflective access operation" errors, and even after updating pretty much every dependency possible in the entire application I'm still getting it. It's not even the same one all the time: in local dev, I get the error on the XNIO library, while on Travis, the CI logs show an error in dynapath. I managed to find an old issue about the latter but it indicated it should've been fixed years ago. Will attach boot show -d in the thread, would welcome any ideas; I've scared up and down the tree and I'm not sure where the culprit is or if I can fix it.