@conaw FWIT, I once wrote a tutorial about syntax quote http://blog.klipse.tech/clojure/2016/05/05/macro-tutorial-3.html

if anybody wants to have fun with instaparse, regular expressions, and property-based testing, doing a totally-achievable and well-defined thing, you could work on making this code as robust as the clj-jvm version: https://github.com/gfredericks/test.chuck/pull/54

I asked this yesterday afternoon but I don't think I did a good job of describing the question/issue, so I'mma try again but with actual examples this time. I have a macro that accepts an atom (and some other parameters), and binds a lot of helper variables for use in the macro:

(defmacro req [& expr]
  `(fn ~['state 'side 'eid 'card 'targets]
     (let ~['runner '(:runner @state)
            'corp '(:corp @state)
            'run '(:run @state)
            'run-server '(when (:run @state)
                           (get-in @state (concat [:corp :servers] (:server (:run @state)))))
            'servers '(zones->sorted-names (get-zones state))
            etc... ]
        ~@expr)))

its anaphoric and you want to only create the binding if you can find a usage in the body?

I'm unfamiliar with "anaphoric" in this setting. What do you mean?

the macro creates a symbol for the body to use seemingly without a binding creating it

the old common lisp ones would introduce a symbol it by convention

Isn't let a binding?

yes but its created at macroexpansion time and therefore not visible in the code you actually write

Ah yes, that's correct

(req (run-server)) is an example. you create the symbol run-server that expr can use without itself creating that binding.

You are correct, yes

i bet @bronsa has an easy way to do this with t.a.jvm. I'm thinking a naive version of walk your expr for the first form might work in practice but would miss things in let bindings, doseq bindings, etc. You don't care if someone shadows since you would create an extra unused binding in a few rare cases. I'm guessing you could run the analyzer over the form, find which things are used and intersect that with the few you have here

Interesting idea, thanks!

its also possible you'll do a lot of work, hit rough edge cases, and after some tedious coding, realize you don't get any measurable performance difference.

That's what I suspected, which is why I haven't worked very hard at finding a solution, lol

so if i'm reading the AST stuff correctly, you could perhaps figure out how to collect all vars (http://clojure.github.io/tools.analyzer.jvm/spec/quickref.html#var) from the AST of expr and then find which ones are your bindings

and tools.analyzer has an ast namespace with a nodes function to give a lazy sequence of nodes in the AST

there's also a really cool looking ast->eav function so you could do this in datalog.

that's amazing that you can query the AST of clojure code. like that's really cool

if you want to go down this route, you'd need to collect local bindings that can't be resolved, there's a hook for that

I'm a bit busy right now but I can show you how to do that later

I do agree with @dpsutton though that it sounds like it could be just premature optimization

> The analyze function can take an environment arg (when not provided it uses the default empty-env) which allows for more advanced usages, like injecting locals from an outer scope: this style?

also thanks for this huge amount of work @bronsa

honestly, I haven't used/worked on t.a.jvm in anger in years so I can't remember off the top of my head how to do it, just that it's possible :)

This is probably an unnecessary optimization (seeing as nearly every binding is either grabbing data from the map atom or performing minor calculations on the atom), but it's currently used 2344 times in the codebase, so it seemed worth at least peeking into

You could do something like

(defn seq-has? [form namespace-qualified-quoted-sym]
  (when (seq? form)
    (not
      (empty?
        (filter #(= % namespace-qualified-quoted-sym) form)))))

(defn expr-has? [expr namespace-qualified-quoted-sym]
  (when (coll? expr)
    (not
      (empty?
        (->> expr
             (tree-seq coll? seq)
             (filter #(seq-has? % namespace-qualified-quoted-sym)))))))

You just call expr-has? in your macro. You may need to check for both the namespace qualified and non-namespace qualified version of the symbol. But that's extra macro stuff.

in your example if you use (find-undefined-locals expr) you should be able to find the set of locals that you need

it's quite the hammer though :)

if I had a timemachine I would rename that node type to :undefined-symbol but alas

With something like this, is it happening at compile time or run-time? heh cuz I suspect the overall performance cost of doing this at runtime will overshadow the performance gain from skipping the unused variables

you're invoking it from a macro

so compile time

this is assuming that you do something like (defmacro whatever [body] (let [neded-locals (find-undefined-locals body)] (emit-only needed-locals body)))

which afaict is the only way to do what you want anyway

Where is emit-only coming from?

that's what you write to create only the binding forms that are in the set needed-locals

it's the binding forms of your let form in the original macro, moved to a function to make it easier to test and the macro easier to reason about

Ah okay, thanks, that's cool

I'll mess around and hopefully make it work!

just added a slightly more performant version of find-undefined-locals to https://github.com/Bronsa/tools.analyzer.jvm.deps/commit/8c7c3936e6f73e85f9e7cc122a2142c43d459c12

if you're gonna bump some stuff, the project.clj version is out of date with the pom. little confusing

project.clj is 0.6.9 snapshot or something? and released is 0.7.0

this is t.a.jvm.deps

but I can fix that in t.a.jvm

i think that might just be t.analyzer

ok

i had to read t.a.jvm to see what version was actually out

ouch

the stuff in the readme should be correct

it's just project.clj that sometimes gets out of sync because I forget, I think

I'll double check both and update though, thanks

I've never needed to have a caching in my Clojure program before, so I need some guidance. I have a collection of entities (maps), that are calculated via some expensive functions using data-fetching from the database. Basically, I want to have it in cache as a big map with entity-id as keys and corresponding hash-map as values. I looked up idiomatic ways to handle caching in Clojure, it's suggested to use clojure.core.cache and atoms. It seems to me that none of eviction policies are suitable for my case, so I resorted to use BasicCache. Additional to my "main" cache, implemented as an atom which contains plain entries, I want to have a nested lookup map with same entities grouped in keys for fast access. I want to store this derived lookup map in some atom for future uses, rather than calculating it every time (it's ~ over a million values). I have two questions: 1) Should I use clojure.core.cache's BasicCache? It seems to me that it's just a wrapper over regular map, what benefits do I get using it? 2) Is it ok or idiomatic to use add-watch as a way to keep in sync two atoms? So that my derived-lookup-map in second atom is always relevant and in sync whenever plain data in first atom changes?

@alisher.atantayev Not sure about BasicCache, but for 2, on the client a lot of people would just use re-frame subscriptions for that, which lets you achieve the same with more precision and less imperative code. Not sure if anyone uses that on the server, though

Keeping atoms in sync is a domain error - it's not what atoms are for. You can synchronize changes to refs to ensure that they stay coherent, but it's not something you can do generally / safely with atoms.

the advantage of BasicCache is that it uses the cache protocols, so you can swap in other caches with other behaviors without changing surrounding code

eg. you thought you needed a TTL cache, but now product says no more time outs, BasicCache is a simple change without rewriting surrounding code

or, you know you want a cache, but specific behaviors are going to be elaborated as needed, so you start with a BasicCache so you don't need to rewrite code to get the new caching behaviors in the final result

if a second atom is always tied to the state of a first atom, and isn't changed itself, you can replace it with a function on the first atom, or added fields in a map in one atom

Is it possible to add a Java annotation to a Clojure function?

I've seen this: https://clojure.org/reference/datatypes#_java_annotation_support which sounds like the answer is no.

I am finding this: https://github.com/clojurebook/ClojureProgramming/blob/master/ch09-annotations/src/main/clojure/com/clojurebook/annotations/junit.clj

it looks pretty magical tho

What do people think is the oldest clojure version a library should support?

For a brand new library, Clojure 1.9.0 would seem reasonable.

The latest Clojure survey results show that 97% of respondents were using Clojure 1.8.0 and later: https://www.surveymonkey.com/results/SM-S9JVNXNQV/

Well that was a multi select question so careful with the number