Maybe a silly question, but why does this api use File instead of Pathhttps://clojure.github.io/tools.build/clojure.tools.build.api.html#var-uber

What is the main usage difference between with-redefs with-redefs-fn with-bindings with-bindings* and with-local-vars ? I was trying to provide some logging meta-information, such that I can log anything with a prefixed id without parameter-chaining. But I'm struggling to figure out which would be the most suitable approach to that. I think ideally something like

(def ^:dynamic *id* nil)
(with-redefs {*id* 123}
  (do-stuff))

I'm writing a edn into a file I want to set some custom print-methods, but just locally Like, (pr-str v {:print-methods {java.time.Duration (fn [v] (str v))}}) But I don't want to set a global print-method to Duration How I do this?

you cannot 😞

someone already developed a library to write edn in a more flexible way?! like data.json but for edn

I think that if you want to serialize something differently you should somehow make a custom writer that writes your data with #tag tags. And then during your reading you should specify these tags to be read with your deserializer. I don't know how to exactly do it but it should be this way. #inst works this way.

They are called reader tags I think.

I am not aware of a complete solution, clojure.pprint lets you set a "dispatch" function which can sort of do that

greetings! is there any way to get output of (1) in the (2)?

;; (1)
`[println]
=> [clojure.core/println]

;; (2) I want here the same output as in (1), somehow. (it will not be let, but will be an arg to a macro)
(let [x '[println]]
  `~x)   <--- change this to something, which will return [clojure.core/println]
=> [println] 

depends what you mean

in general the symbol println is not at all the same as the symbol clojure.core/println , there is no connection from them that you can just traverse

if you want to "ns-resolve" the symbol println relative to some namespace, you will get a var, and then you can get the name of the var which will be a namespaced symbol

(I think let does not really illustrate, ... or maybe it does)

what syntax quote is doing to the symbol println when reading is resolving it against the current value (at read time) of *ns*

(I think) I need just fully qualified names of everything in the form I am getting as a n arg to macro

which is how it ends up with clojure.core/println

you can't

the symbol clojure.core/println is a completely different thing from the symbol println

i need to walk the form (inside my macro), and dispatch on symbol to rearrange things, so dispatching on, say, let would work, unless it is used as clojure.core/let or alias/let in the form. so my kneejerk reaction was to just qualify all the things beforehand to avoid issues with aliases, etc.

what are you trying to do?

so what you need is a map somewhere from the symbol println to the symbol clojure.core/println which doesn't exist, but a given namespace might have a map from the symbol println to the var #'clojure.core/println and you can turn the var into a fully qualified symbol

if you are doing code transformation you should also keep in mind that clojure special forms are not namespaced

but within macro, *ns* would be bound to the macro's ns, right? not the call site ns?

yes, but backtick "handles" that for me, I think:

`let
=> clojure.core/let
`let*
=> let*

it will be the ns of the expansion site

which is to say, whatever value *ns* has when the compiler is called to compile the code will be the value it has when macroexpansion happens

so do I just clojure/walk with a manual lookup in *ns* aliases,etc?

depends, clojure.walk will also descend into quoted forms and other kinds of literals

yes, terms and conditions apply™ but I expected there is already a function for this :( like https://github.com/clojure/tools.reader/blob/6918abc8b3c009228790cf091097eb3037858ad6/src/main/clojure/clojure/tools/reader.clj#L694

Another, sort of related, question: are there any tricks to turn closed predicate based cond into open defmethod?

Unless you can add some kind type kind of tag to the inputs, your "open" defmethod wont actually be open

oh, right, cond is sequential, and defmethod is not, and there would be N matching branches

If you trying to convert a tree walker, it is common to turn a single cond in to two or more defmethods

The first defmethod dispatching on the type: list, symbol, whatever, and those methods call a second defmethod that does type specific dispatch

E g dispatching on the first element of a list

yes, treewalker. actual use case is: I need to collect form's dependencies on locals. for example I need to figure out that nobody here needs x , because x in (fn [x] ...) is different from x in x 1

(let [x 1
      y (fn [x] (inc x))]
  (y 1)) 

Yeah, a double defmethod will do that

It is the same kind of pattern the clojure compiler uses to analyze clojure code. The compiler doesn't use multimethods, but there is a Java method analyze that is passed a form, and it looks at it, and if it is a seq it calls analyzeSeq

I started the way you suggest, but then destructuring [a b & body] gives me body of the ChunkedSeq, which is an implementation detail, and I would not want to depend on it

(let [[a b & body] [1 2 3]]
  (type body))
=> clojure.lang.PersistentVector$ChunkedSeq

(let [[a b & body] (range 10)]
  (type body))
=> clojure.lang.LongRange

It is a seq

clojure.lang.ISeq

Yeah, you won't be able to share type names between clj and cljs, they are different

I am pretty sure if you look at the cljs compiler it does the same double multimethods thing for analysis, but does actually use multimethods for it

still, (instance? clojure.lang.ISeq body) – is a predicate. looking how to turn it into dispatch value

you use type as the dispatch function

Is there an established standard for code generation in Clojure? I would like to create an auto-generated library wrapper for OpenGL in Clojure, but one of my preferences about it is that I do not provide only a macro which does all the expansion at compile time but rather that code generation is an actual step in the build process to allow jump to definition as well as allowing a published artifact to be source-based but not incur the cost of generating the code at startup. I've looked at and used rewrite-clj a little bit for working with clj-kondo hooks, but it adds a lot of complexity over what I think could reasonably just be an equivalent of clojure.pprint/pprint that's slightly smarter about eliding namespaces in the generated data structures to make it more reader-friendly.

> Is there an established standard for code generation in Clojure? Doesn't clojure core already offer enough?

I usually just use pprint

I usually don't do the code generation as part of a build step, I just generate it and check it in, maybe with the code to generate it in a comment at the bottom

there’s a really cool project called Archimedes that uses core.logic and the vendored asm lib to write a class file 🙂

my most recent generated code, it looks like I didn't bother eliding namespaces at all

Yeah, pprint is probably fine

I'm not 100% either way on if I want to check in the generated code. On the one hand it'd be real easy for the version checked in to get out of date with the generator as it's updated, and on the other hand being able to view it in github is useful.

@suskeyhose fwiw, I generate some code for rewrite-clj. A step in my build/ci workflow fails if the generated code is out of date.

That makes sense, but I haven't touched any of github actions' stuff and I'm not really planning on starting now for just an opengl wrapper

For me it is just part of a babashka task. Happens to be also invoked by CI, but also invoked by me.

Right, I'm going for a deps/prep step for git dependencies and hand-invoked by me whenever I want to publish a clojars version

why not check the gen-ed code into source control?

seems easier on the tooling as well (cursive, clj-kondo)

Just to prevent version mismatch between the data spec (which will be in VC) and the generated code.

I'm using clojure.tools.logging, how do I get logs to show up in my repl?

I've tried using log-capture!, but that didn't work.

You need to set a logging implementation and ensure that it has stdout (or whatever your repl is) as one of the appenders.

stdout may not be the same as the repl's out

<root level="INFO">
    <appender-ref ref="STDOUT" />
  </root>

I think I'm using logback classic

So STDOUT must not be the repl's out, but I'm not sure how to figure out what that is

*out* looks like some sort of PrintWriter

if you started your project and hosted like a repl port with nrepl and then did a cider connect or something then the stdout of your program is the stdout of the original process, not the cider connection

This project doesn't have a built-in nrepl server, I've just used cider's jack-in to connect

I recently released cascade, a lib that provides a bunch of CPS versions of Clojure's seq operations. here's a cool example of converting a non-tail recursive algorithm into a tail-recursive trampolined version https://github.com/lilactown/pyramid/commit/21a5829dcb9d912c06bc7aa34decf478c87ed9a3?diff=split it felt quite easy all in all 😄

I’m pretty inexperienced with app deployment and have never done it in Clojure before. I started working on an idea for a language-learning related web app that requires a database (but not user-editable; it’s essentially a dictionary). What is the recommended tech stack & PaaS for something like this, backend-wise? Heroku seems to offer Clojure support out of the box, but prefers/requires(?) lein and MongoDB Atlas. For this project, I’m trying the deps.edn approach for the first time so I kinda groan at the thought of restarting the project with lein. Also, I found XTDB, which seems to be a lot simpler to deal with than MongoDB, but I’m not sure how it would work exactly. Would I generate the data store locally, bundle it with the .jar and deploy that?