Clojurians Log v2

I'd just use a map, possibly even just a vector

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.

It's a sequence

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

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

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

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**)

Just a thought but a lot of financial institutions represent currency values using long values by removing the decimal place and using the smallest currency unit i.e. cents instead of dollars or pence instead of pounds.

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

This is excellent! Thanks.

But this is a different kind of optimisation. Not exactly what I described above.

something like this? https://github.com/DotFox/matchete/blob/main/test/dotfox/matchete/ref_test.cljc#L33-L61

Something like that. Thanks!

This library is still under develop but feel free to have a look at implementation

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

I guess I’ll take a bit of both. Thank you both.

@delaguardo Very interesting. I’m trying to understand how the registry works (the first argument passed to m/matcher).

https://github.com/DotFox/matchete/blob/main/src/dotfox/matchete/compiler.cljc#L287-L292 first argument is a map of identifier -> pattern which you can use later in the pattern given as a second argument for m/matcher wrapped as a [:ref id] sorry for such bloated explanation ) I’m still working on proper documentation for the lib

default-registry function places ::custom (atom {}) as a container for every custom patterns you might want to bring in as a first argument for m/matcher. And during compilation every pattern like [:ref id] will use this atom to look up a matcher to use

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.

> But making a required argument positional does communicate the intent of required-ness more perhaps. Yep! That was why I was hesitating.

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 <http://java.io|java.io>.FileReader. and it is working ... 🙂