do you have an example of what you're trying to do?

(def config {:namespace "clojure.string"})
(let [n (:namespace config)]
  (when (n) (:require [n :as module])))

n is a var, require wants a list/vec of literals

n is "local" not a var

not sure what you're actually trying to do, but requiring-resolve might help

fwiw, the following works:

(let [config {:namespace "clojure.string"}
      n (:namespace config)]
  (when n (require [(symbol n) :as 'module])))
(module/lower-case "CLOJURE")

thanks for the feedback

im looking for behavior parity between an existing python code base and what can be accomplished here. The python project leverages importlib and dynamic loading in a fashion somewhat similar to java spring ioc, interfaces, and varying implementations.

repl testing looks as if requiring-resolve can provide at least the edn config ->conditional import path here.

@U020G9UCM1N In case you're not familiar with this domain, you can find a plethora of stuff to read about searching for internationalization and localization (abbreviated as i18n and l10n ). There is a lot of nuance to doing this well at scale. But if you're just looking for something quick to get you started grab an existing i18n library (e.g. https://github.com/ptaoussanis/tempura) and try not to go down the rabbit hole of learning everything about this - the well runs very deep. :)

That looks nice, thanks!

there has to be a better and safer way than (keyword (str "example." (name :foo)) "bar") (with :foo coming from a parameter). to give more context, I want to put all item names for my game into that dictionary, nested under :item - so for example :item {:sword {:name "Sword", :description "A Sword with a sharp blade."}} and when outputting the name of the item, I would have :sword and want to call tr with :item.sword/name - is this a valid approach or should I rethink it?

Usually, keyword namespaces are not meant to be programmatically manipulated and interpreted in "parts". This is a subject that comes up once in a while e.g. in clojure.spec discussions, but my understanding is that this is not something the Clojure Core team feels is a good practice, so you won't find a lot of clojure.core functions to manipulate the namespace as a hierarchy of segments. To not go against the grain, you can ask yourself if your request should be asking for the name of item :sword or simply should be asking for the :item.sword/name? The latter would make it unambiguous and no need for the monkeying around with strings; the former and writing some helper function to hide (keyword (str/join "." ["item" (name item)]) "name") is probably as good as it gets.

Thanks again! I think I'll avoid nesting too deep, then. Maybe even use a separate dictionary for each category, like one for item names, one for item descriptions. Then I can use the keyword for the item as resource id (in this example, :sword).

My gut reaction would be to have :item/sword or even :item.weapon/sword wherever you're dealing with the thing and then use the keyword/string logic to map all translations (so you automatically map :item/sword to {:item.sword/name ".." :item.sword/description ".."})

Having unambiguous full-qualified keywords as identifiers means you can mix-and-match maps easier and pass things around without nesting for context. It seems like a small difference, but it has some nice long-term benefits that are not easy to articulate until you start growing bigger systems with it.

Check out https://www.youtube.com/watch?v=IS3i3DTUnAI if you want to learn more about the perks of fully-qualified keywords

{:item/id :magic-sword-of-parens ;; or more unique ala :
 :item/kind :item.kind/weapon
 :item/weapon :item.weapon/sword
 :item/name "this is dynamically generated based on translation, but is generic key for UI"
 :item/description "same here"} 

I load a few files using io/resource, they all are in the resources folder

I can use io/resources in a newly created project. There is something strange in this legacy project that is messing with the class path I think.

try lein with-profile +repl cp to get the classpath a repl would use

you can swap in other profiles of course

also for io/resource to work, the document shouldn't be on classpath, its parent folder or zip file / other container should be

nb. "." shouldn't be on classpath, you should have specific subdirectories of the project like src and resources that are on classpath

What I use most often is cider-open-classpath-entry There's also a system property for this:

(System/getProperty "java.class.path")

Hmm, this just shows the leiningen jar as the class path. very strange.

It works fine for me. I’ve been using it for a long time from jdk 8 to jdk 16. Note that your code fails completely on modern JDKs

Yes, the code does work correctly in a new project. It gives the leinigen path in the older project, I think because something is failing... Thanks.

Just in case: it’s always good to try lein clean if you experience weird issues

if it was "failing to build a class path" java wouldn't even be able to run anything. what is happening is you are asking for a different classpath than you think you are.

> it seems Leinigen was not downloading all dependencies. that makes me think that something replaced the classpath / dep vector where it should have been adding to it (look for the ^:replace metadata in a profile for example)

The project does something intricate with project.clj and profiles.clj (which is also in the root of the project). I commented out all the bits I didnt understand and at least I have a proper class path now. I also decided to add a deps.edn file and use Clojure CLI tools. This showed some issues with transitive dependencies which I've now resolved.

$ lein deps :tree also helps diagnose transative dep problems, and $ lein help sample has example based docs of most of lein's weird features

I found an issue with a transitive dependency of a transitive dependency. There were also issues with a user.clj file, which was automatically loaded on startup by Leiningen. The repl runs now, thanks all.

leiningen does not autoload user.clj, but clojure does (if it's seen on classpath) - perhaps the difference was lein putting the file on classpath

a transitive dep of a transitive dep is a transitive dep (by the transitive property :D)

I think typical default max JVM stack depth is on the order of a few thousand calls (it can be configured larger when you start the JVM via command line options). If you expect the DFS to traverse more nodes than that at maximum depth, then you should consider whether you might want to use a method that manages the DFS control flow via a data structure, vs. consuming call stack.

Thank you folks

I'm not sure I would write it the same as their example, but there's a difference in behavior. Eg:

(defn contextual-eval [ctx expr]
  (eval
   `(let [~@(mapcat (fn [[k v]] [k `'~v]) ctx)]
      ~expr)))


(defn contextual-eval-mead [ctx exp]
    (eval `(let [~@(mapcat (fn [[k v]] [k v]) ctx)]
             ~exp)))

(contextual-eval '{a (+ 0 1) b 2} '(+ a b)) ;; exception
(contextual-eval-mead '{a (+ 0 1) b 2} '(+ a b)) ;; 3

I haven't read the book and maybe it makes sense for their example, but calling eval in a macro seems super weird to me

Oh it’s not a macro yet — just a regular fn being used to introduce the concept of macros

ohhh, right. duh. nvmd

Thanks for your response earlier, walking through it now

it's a little easier to see what's going on if you just show the code being passed to eval:

(defn contextual-eval-form [ctx expr]
  (let [form `(let [~@(mapcat (fn [[k v]] [k `'~v]) ctx)]
                ~expr)]
    form))

(defn contextual-eval-mead-form [ctx exp]
  (let [form `(let [~@(mapcat (fn [[k v]] [k v]) ctx)]
                ~exp)]
    form))

(contextual-eval-form '{a (+ 0 1) b 2} '(+ a b))
;; (clojure.core/let [a '(+ 0 1) b '2] (+ a b))

(contextual-eval-mead-form '{a (+ 0 1) b 2} '(+ a b))
;; (clojure.core/let [a (+ 0 1) b 2] (+ a b))

It makes sense why the book version breaks, but I’m still confused as to why it might be the preferred/idiomatic version vs. the simpler one. Trying to think of an example where contextual-eval-mead would be worse…

well, for the purposes of introducing macros, their version is closer to how a macro works

a macro gets unevaluated forms which is what their version is doing

ah ok. maybe that’s the use of having it in there then.

thanks

I recently came across a use of this in the malli codebase: https://github.com/metosin/malli/blob/master/src/malli/core.cljc#L1969

I usually would write that as:

(list 'quote (symbol (str name)))

interesting, it's good to have the comparison - thanks!

the '~` idiom is a neat trick though. Might be worth getting used to.

They are not strictly speaking

A less opaque version of what the book is doing would be to replace `'~v with (list 'quote v)

Why quote it though? Why not just use ~` ?

`~x is just x

`'~x is the value of x but quoted

Oh, right.

In that particular case, I would never write it like that, but using '~ to embed quoted values in a syntax quote form is very useful

Thanks. I think now I understand what's going on in this code even if I don't understand what they're trying to get across. I'll keep reading.

Thanks again!

Ah I think I have it, should have been

(defne nevero [] ([] (nevero)))

..but thinking about it I'm still not entirely sure why

For an in-depth look at problem solving techniques, G. Polya's "How to Solve It" is great, http://www.math.utah.edu/~pa/math/polya.html

The overview is a good starting point: 1. Understanding the problem 2. Devising a plan 3. Carrying out the plan 4. Looking back (eg. testing)

looks ok to me. Maybe it's some other issue. What's the error you're getting? What's the symbol alias you're trying to use?

1. Caused by java.lang.IllegalStateException
   Alias model already exists in namespace
   neuromancer.core.pay.invoice, aliasing
   neuromancer.models.pay.account

If I change the alias for one of them, it compiles w/o error

is there another require in the same namespace using model?

what do you mean by compile?

using cider’s hot key C-c c-k to compile the current namespace

and no I just have 3 requires in this namespace, only one aliasing :as model

ah, I'm guessing there's some persistent state which won't let you change it

you can either restart your repl or run

(ns-unalias *ns* 'model)

for each namespace before trying again

Cool let me give that a shot

there's probably a better way to reload each namespace without restarting the repl, but my repl workflow is fairly basic

Yeah there’s something weird going on with my repl. I restarted it, and it stopped giving me that error, but now It’s giving some other error that also looks like a caching problem

progress!

Ah nah figured it out, now everything’s compiling! just needed to restart the repl, thank you 🙂

Most likely you have evaled one in a namespace already and so now there was already an alias in that namespace.