Hi all. I’m not sure whether this is the right forum to ask this question (this is going to be a long post) so please feel free to point me out to the right place. I was looking for a function to “extract” values from different places deep inside a map, using something that resembles pattern matching (doesn’t need to be pattern matching though). For example suppose you have this map copied from some deps.edn file:

(def deps {:deps {'acme/spaceship {:mvn/version "1.0.0"}
                  'org.clojure/clojure {:mvn/version "1.10.1"}}
           :aliases {:moon {:extra-deps {'moon/lander {:mvn/version "0.8.7"}
                                         'rock/examiner {:mvn/version "4.0.21"}}
                            :override-deps {'foo/bar {:mvn/version "1.2.3"}}}
                     :mars {:extra-deps {'mars/rover {:mvn/version "1.14.9"}
                                         'comms/serial {:mvn/version "2.4.2"}}
                            :default-deps {'hello/world {:mvn/version "9.8.7"}}}}})

(def patterns [[:deps]
               [:aliases keyword? #{:extra-deps :override-deps :default-deps}]])

(extract patterns deps)

({:path [:deps], :val {acme/spaceship {:mvn/version "1.0.0"}, org.clojure/clojure {:mvn/version "1.10.1"}}}
 {:path [:aliases :moon :extra-deps], :val {moon/lander {:mvn/version "0.8.7"}, rock/examiner {:mvn/version "4.0.21"}}}
 {:path [:aliases :moon :override-deps], :val {:foo/bar {:mvn/version "1.2.3"}}}
 {:path [:aliases :mars :extra-deps], :val {mars/rover {:mvn/version "1.14.9"}, comms/serial {:mvn/version "2.4.2"}}}
 {:path [:aliases :mars :default-deps], :val {:hello/world {:mvn/version "9.8.7"}}})

(defn- key-matches?
  [p k]
  (if (or (keyword? p) (not (ifn? p)))
    (= p k)
    (p k)))

(defn- extract-p
  [pattern val path]
  (let [p (first pattern)
        ks (filter #(key-matches? p %) (keys val))]
    (if (seq pattern)
      (map (fn [k]
             (extract-p (rest pattern)
                        (get val k)
                        (conj path k)))
           ks)
      {:path path :val val})))

(defn extract
  ([patterns m]
   (flatten
    (map (fn [pattern] (extract-p pattern m [])) patterns))))

Take a look at Meander and Specter.

https://github.com/noprompt/meander and https://github.com/redplanetlabs/specter

Both of those are designed to help you navigate deeply nested maps.

Thanks a lot, I’ll take a look!

are there some examples of just… really exemplary clojure code that makes a good read?

I don’t know. A lot of library code has to do “weird” stuff (which is why the library exists), so I suspect most of the “exemplary” Clojure code is in proprietary applications…

I certainly wouldn’t say any of my OSS projects are “exemplary” code since they mostly have to jump through hoops to get their jobs done. I’m not sure I’d say our code base at work is “exemplary” either but some parts of it are nice (and some parts are… not so nice) out of 113k lines…

(but then it spans a decade of learning Clojure followed by adopting various idioms over time)

I agree with @seancorfield that it depends on what kind of exemplary you're after, but I will offer an opinion that this library is some of the finest Clojure that I've seen: https://github.com/sicmutils/sicmutils

That does not mean that it is particularly easy to grok, just that it is very well thought out

True, there’s a big difference between “well-designed” and “easy-to-read”.

how to fetch the value from Variadic Functionsin clojure

(defn hello [greeting & who]
  (println greeting who))

how to get individual values from who?

They're regular sequences, you can use any core function like first , rest, nth , or destructure it further, or map over it etc.

You could do something like this: (defn hello [greeting & [firstarg secondarg]] ...)

eg. (doseq [x who] (println x))

ohh got it thanks

@popeyepwr to return a nicely formatted string from a variadic argument, something like this

(defn hello [greeting & who]
  (str greeting ", " (clojure.string/join ", " who)))

(hello "Welcome" "fred" "betty" "wilma")

I am pretty sure clojure.string/join and str will individually use Java's StringBuilder internally, but we still end up creating an intermediate string via (clojure.string/join ", " who). I wonder if there is one efficient string joining library out there. Something like,

(make-string **somehow represent the complex join logic here**)

@hindol.adhya take a look at https://github.com/cgrand/xforms#usage x/str and x/str!

hi! one question about semantics

(merge {:a 1 :b 2 :c 3}{:a 5 :b 6 :c 7})
=> {:a 5, :b 6, :c 7}

Yes. For other kinds of merging, merge-with can be used

How idiomatic would it be to accept required arguments via keywords a-la https://clojure.org/news/2021/03/18/apis-serving-people-and-programs?

depends who you ask :)

I was worried that that might be the response. 😅

And if I’m asking you in particular? 🙂

even I would say it depends on the situation but generally it's ok by me :)

A thought (inspired by Maybe Not I think): what is required now may become optional in the future... and having the required argument positional would make that more difficult (well, you can always pass nil). But making a required argument positional does communicate the intent of required-ness more perhaps.

I want to parse an xml file...

(let [input-xml  (slurp "JMdict_e")]
	(println (parse input-xml))

WARNING: An illegal reflective access operation has occurred
WARNING: Illegal reflective access by clojure.lang.InjectedInvoker/0x0000000800b8c840 (/.m2/repository/org/clojure/clojure/1.10.0/clojure-1.10.0.jar) to method com.sun.xml.internal.stream.XMLInputFactoryImpl.createXMLStreamReader(java.io.Reader)

using clojure.data.xml

@sova That sounds like you’re using clojure.xml, not clojure.data.xml. The former is “built in” to Clojure itself and is deprecated. The latter is org.clojure/data.xml.

I might use into-edn instead https://github.com/thebusby/into-edn

(they both have a parse function so a typo in the :require would easily get you the old/bad version instead of the new one)

org.clojure/data.xml is solid.

[clojure.data.xml :refer :all] ought work?

Caused by: javax.xml.stream.XMLStreamException: ParseError at [row,col]:[1,1]
Message: JAXP00010001: The parser has encountered more than "64000" entity expansions in this document; this is the limit imposed by the JDK.

I switched slurp to .FileReader. and it is working ... 🙂