(let [conj! (fn [] (prn 10))]
  (conj!))

(let [set! (fn [] (prn 10))]
  (set!))

first works, second causes syntax error, the reason is because set! is special form ?

i know that we cant do this for if also

we can't ovverride all special forms?

yes

special forms (lists that start with a symbol that the compiler assigns explicit meaning to) will always be compiled as the special form, regardless of any variable shadowing

ok thank you hiredman, i forgot this again and i was stuck sometime

it can be confusing because the line between special form and macro gets a little blurry sometimes, and macros do allow shadowing

for example. the doc string for let and fn both claim to be special forms, but are in fact macros, and the shadowing behavior is the macro one

user=> (let [let (constantly nil)] (let 1))
nil
user=> (let [fn (constantly nil)] (fn 1))
nil
user=> (let [try (constantly nil)] (try 1))
1
user=>

ok thanks, so macro can be shadowed also, if needed i can test it, but those are rarely needed, i am just making DSL thing

so happened

I have an app that uses dependency A, which in turn has a dependency on B-vX, but the app excludes dependency B and declares a dependency on B-vY. The app is also using a library that I am working on, this library also depends on A. Might this cause problems for the app? Specifically in this case A is com.taoensso/timbre and B is com.taoensso/encore. Ideally I'd like for the app to be able to inject a logger, but for now I just want to know what I can do to not mess it up for app while still using timbre in the library.

with-redefs question: i have a function exception-helper which uses timbre/error to print certain information about the exception i'm catching (inside a custom catch* macro). i'd like to silence that logging during certain tests where i deliberately throw an exception to test certain code-paths. in my test, if I write (with-redefs [taoensso.timbre/error (constantly nil)] ...), the error still prints because the with-redefs call didn't bind. If I change the invocation in exception-handler to (#'timbre/error exc "Exception happened"), the with-redefs call binds correctly. is there someway I can do this rebind without modifying the originating call?

I have a require that is executing an IO that interacts with a global state that I'm dealing with, how can I trace the execution inside a (ns ,,, :require [,,,,]) statement to see which one executes the stuff that I'm looking for?

Is there some kind of :verbose for ns statement?

yes

(the docstring for ns says :require supports the same options as require, the docstring for require describes :verbose)

(alter-var-root #'clojure.core/*loading-verbosely* (constantly true)) in the repl while turn it on everywhere

why not just use the :verbose flag in the require?

lazy

I might not know exactly where I need to put the verbose flag

your definition of lazy is weird :)

(:require ...yadayada... :verbose)

or (require ... :verbose) depending on whether you're in ns or repl

I mean, I dunno, it has been a while and I don't entirely recall why I set it the last time I did, but I imagine it was because something else was controlling code loading and I didn't want to add :verbose in every require in a project, I just wanted to see everything load

If you have something blocking the load, you can take a thread dump with jstack or ctrl+\