Clojure Q&A - Recent questions and answers in Compiler

Answered: Changing type tags can lead to cryptic errors

Fri, 03 Jul 2026 00:06:18 +0000

It might be useful for the compiler to give a warning when a var is redefined such that it loses a primitive interface.

We could still detect these changes without compiler changes like this:

Clojure 1.12.5
user=> (defn f ^long [^long a] a)
#'user/f
user=> (add-watch #'f ::undo-prim (fn [_ _ old new] (when (and (instance? clojure.lang.IFn$LL old) (not (instance? clojure.lang.IFn$LL new))) (println "WARNING: removed clojure.lang.IFn$LL from f"))))
#'user/f
user=> (defn f [a] a)
WARNING: removed clojure.lang.IFn$LL from f
#'user/f

Possibly avoidable identity call to force instance method on Class literals

Thu, 02 Jul 2026 23:47:10 +0000

As of Clojure 1.13.0-alpha2, (.method ClassName) expands to (.method ^Class (identity ClassName)).

This is to force (.method ClassName) to always be an instance method. Without this, it would expand to (. ClassName method), which may instead be interpreted as a static method.

For example, (.getMethods String) expands to (.getMethods ^Class (identity String)).

This was introduced in these two commits:
- force instance member interpretation of (.method ClassName), e.g. (.getMethods String) works
- added autohinting to Class in macroexpansion of (.instanceMethodOfClass Classname) calls

Since then, Clojure has added support for qualified methods which we can use to reliably propagate the tag without any runtime changes. For example, expanding to (Class/.getMethods String) is now equivalent to (.getMethods ^Class (identity String)) in terms of tag propagation.

I have a proof-of-concept here that includes disassembled and decompiled output before and after the change. The net effect of using qualified methods in this case under direct linking is a removal of a single method call to identity:

   3: invokestatic  #20                 // Method clojure/core$identity.invokeStatic:(Ljava/lang/Object;)Ljava/lang/Object;

The effect is more substantial without direct linking (not included in the PR), with clojure.core/identity also being added to the static initializer.

I've also experimented with expanding to (. (do String) getMethods) (see earlier commits in that PR), which seems to also work and might be another approach.

Feature Request:Make anonymous fn/reify class name IDs per namespace instead of one global counter

Wed, 18 Feb 2026 15:34:38 +0000

Compiled anonymous functions and reify classes get names like ns$fn__4532, where the numeric suffix comes from a global AtomicInteger counter
(RT.nextID()).

This counter is shared across the entire runtime and is consumed by fn classes, reify classes, constants tables, gensyms, etc.

The problem is that because the counter is global, any code change shifts the IDs for everything compiled after it. This makes profiling across builds
really painful, you can't meaningfully compare flame graphs because all the class names change even in code you didn't touch.

I'd like to propose scoping the ID counter per-namespace instead. Since the namespace is already part of the class name prefix, uniqueness is still
guaranteed. This would eliminate the cascading effect across unchanged namespaces and make profiling diffs actually useful.

I'm not sure what's the downsides of this, but from what I saw of AtomicInteger, it isn't used a lot to break things.

Thank you!

Answered: bit-count in cljs but not clj

Fri, 30 Jan 2026 14:20:06 +0000

Logged as https://clojure.atlassian.net/browse/CLJ-2937

Answered: Why is `list` defined with a RestFn instead of `create` method?

Tue, 09 Dec 2025 22:44:08 +0000

Probably only known to Rich, don't think these inconsistencies are important.

Answered: cannot call Java Constructor overload

Mon, 03 Nov 2025 18:35:22 +0000

That constructor is private, you can't call it.

Answered: Macro expansion lose type hints

Mon, 03 Nov 2025 14:30:41 +0000

I believe this is the same general problem as https://clojure.atlassian.net/browse/CLJ-865, which has been long-debated in the core team.

Unwrapped do is treated as a special form in let and fn bodies

Fri, 24 Oct 2025 17:30:35 +0000

when a let or fn body begins with the bare symbol do (not in list head position) it is treated as a do-block wrapper for the rest of the body

Clojure 1.12.0
user=> (let [] do)
nil
user=> (let [] do 123)
123
user=> (let [] 123 do)
Syntax error compiling at (REPL:1:1).
Unable to resolve symbol: do in this context
user=> ((fn [] do))
nil

Aside from being unexpected, it also has the effect of appearing to override any local binding named 'do':

user=> (let [do :something] do)
nil

Note that Clojurescript treats all the above cases 'correctly':

ClojureScript 1.11.132
cljs.user=> (let [] do)
                    ^
WARNING: Use of undeclared Var cljs.user/do at line 1
nil
cljs.user=> (let [do :something] do)
:something

The community guide at https://clojure-doc.org/articles/language/macros/
has pointed out this exact edge case (since 2013?) and recommends to 'Never use special names as local binding or global variable names'. However it seems like a bug worth addressing given the discrepancy between JVM/CLJS outputs

Compiler-generated `foo__init.class` files lack `SourceFile` attribute

Thu, 31 Jul 2025 22:21:18 +0000

Most .class files generated by Clojure contain the expected SourceFile attribute (you can verify with javap -v). But __init classfiles lack this metadata. I asked @alexmiller on Slack, and he suggested I bring it up here.

The same appears to be true of classes generated via proxy.

Answered: Using letfn* for defining corecursive reified implementations

Fri, 18 Jul 2025 19:28:59 +0000

letfn* and reify* are low-level undocumented implementation parts of letfn and reify. One of letfn's features (by design) is to support corecursive implementations ala:

(defn is-even? [n]
  (letfn [(neven? [n] (if (zero? n) true (nodd? (dec n))))
          (nodd? [n] (if (zero? n) false (neven? (dec n))))]
    (neven? n)))

I'm not really sure what your actual intent is but I would try to use letfn first (and not reify IFn at all).

Answered: Consider documenting usage of `do` for the Gilardi scenario

Fri, 18 Jul 2025 19:14:01 +0000

Logged as https://github.com/clojure/clojure-site/issues/723

Answered: Is the ant build broken in Clojure 1.12.1?

Tue, 03 Jun 2025 16:45:07 +0000

Hey Steve, the official build for Clojure is the Maven build (it does actually call out to the ant build for parts of its work but it uses the maven classpaths when doing so). To run the Clojure tests you should do mvn clean test and to package you can do mvn clean package (or install to make a local version).

The Ant build is as I mentioned still wrapped for some parts of the Maven build (some day maybe that will eventually get cleaned up).

Can custom literal collections reach parity with clojure's built in collections?

Thu, 20 Mar 2025 21:46:42 +0000

Teaching Old `eval` New Tricks

Tagged Literals Promise Extensibility

EDN and Tagged Literals:
- In EDN, tagged literals deliver complete extensibility.
- When processing EDN data, custom types created with tagged readers achieve parity with built-in literals.
Clojure’s Syntax and Tagged Literals:
- Clojure's syntax, as a superset of EDN, includes tagged literals.
- Key Differences:
- EDN is for reading data, while Clojure's syntax is expected to be eval'ed.
- Tagged literals in Clojure code are treated as second-class citizens compared to built-in types because:
```
1. The compiler inherently knows how to compile built-in types,
   but it does not understand other types returned by tagged
   readers.
```
Compiler Behavior and Challenges:
- By default:
- The compiler embeds the instance as a string in the emitted bytecode, recreating the instance at runtime via the reader.
- Issues with Collections:
- Container types like third party collections are problematic because their interior data is not evaluated.
- Common advice suggests returning a form that, when evaluated, creates an instance of the type. However:
```
- This makes the result no longer a literal, as:
  - The reader does not produce the expected type.
  - Macros don't see the expected type
  - You only get the expected type after eval.
- For mixed environments (EDN without eval vs. Clojure with
  eval), separate tagged readers for the same tag may be
  required.
```

Towards a Solution

Compiler Extensions:
- A potential solution involves creating an extension point to teach the compiler how to compile new types.
- Special care is required for cross-compiling dialects, such as ClojureScript.
- JVM collections might need to self-compile for ClojureScript.
Backward Compatibility:
- Ideally, any solution would:
- Retain the existing "self-quoting" behavior.
- Allow types to opt into new functionality.

Answered: Breaking change in 1.12.0 - a static field is always preferred to a static function with the same name

Tue, 04 Mar 2025 13:37:44 +0000

Created CLJ-2899.

Answered: Comparing ratios with BigDecimals can throw

Fri, 21 Feb 2025 21:27:28 +0000

Separating these a little bit:

= will return false if two numbers are compared across different numeric partitions (int+ratio+bigint, float, bigdec). This one is kind of special. You say "= works" above but I don't think it works presumably meaning it does not throw, but it will always return false for cross-partition, e.g. (= 1/2 0.5M).

Other numeric comparison operators coerce args to matching type, then compare. This includes == which thus does = across partitions. There are some cases where the coercion cannot occur - I think maybe irrational fraction to bigdecimal is the obvious (only?) case and in that case there is available coercion.

I consider this expected behavior, not sure where we could document it but open to ideas. Maybe bigdec docstring, or at https://clojure.org/reference/data_structures#Numbers ? Where did you look first?

Incorrect result when evaluating `not=` on `##NaNs`

Sun, 08 Dec 2024 21:14:02 +0000

Alex Miller asked me to write this up here. I found a bug in clojure.core yesterday that involves not= when used to compare NaNs. This was reported on Slack and the discussion is here:
https://clojurians.slack.com/archives/C03S1KBA2/p1733612992809069

Here is a more highly summarized version of the discussion from Slack (at least from my perspective). If we fire up the Clojure CLI, we can evaluate the following.

 Clojure 1.12.0
 user=> (= ##NaN ##NaN)
 false
 user=> (not= ##NaN ##NaN)
 false
 user=> (not (= ##NaN ##NaN))
 true

The problem here is that =, not, and not= have a relationship between them. Specifically, for any x and y, if (= x y) returns a boolean, then (not (= x y)) should return the opposite boolean, and since not= is defined as (not (= x y)), it should return the same value as (not (= x y)) for all x and y. This doesn't happen if x and y are both ##NaN.

Note that there were a lot of calories burned on Slack with suggestions that doubles should never be compared for equality, that NaNs are shifty, not-quite-value objects and should be avoided, that anybody who wants to test for the presence of a NaN should use NaN? which is already in clojure.core, and that the documentation around equality should be updated to say some of those things. Many of those statements are true or good practice. But all of them miss the broader point.

This bug has nothing to do specifically to do with NaNs. It just seems that NaNs expose the bug. The real issue is with the contractual relationship between =, not, and not= which appears to be violated in the presence of NaNs. Specifically, not= is no longer referentially transparent with respect to (not (= ...)).

On Slack, @potetm decompiled the code generated for these cases and found the following.

For (not= ##NaN ##NaN) :

(clj-java-decompiler.core/decompile
  (not= ##NaN ##NaN))

// Decompiling class: cjd__init
import clojure.lang.*;

public class cjd__init
{
    public static final Var __not_EQ_;
    public static final Object const__1;
    
    public static void load() {
        ((IFn)cjd__init.__not_EQ_.getRawRoot()).invoke(cjd__init.const__1, cjd__init.const__1);
    }
    
    public static void __init0() {
        __not_EQ_ = RT.var("clojure.core", "not=");
        const__1 = Double.NaN;
    }
    
    static {
        __init0();
        Compiler.pushNSandLoader(RT.classForName("cjd__init").getClassLoader());
        try {
            load();
            Var.popThreadBindings();
        }
        finally {
            Var.popThreadBindings();
        }
    }
}

And then for (not (= ##NaN ##NaN)):

(clj-java-decompiler.core/decompile
  (not (= ##NaN ##NaN)))

// Decompiling class: cjd__init
import clojure.lang.*;

public class cjd__init
{
    public static final Var __not;
    
    public static void load() {
        ((IFn)cjd__init.__not.getRawRoot()).invoke(Util.equiv(Double.NaN, Double.NaN) ? Boolean.TRUE : Boolean.FALSE);
    }
    
    public static void __init0() {
        __not = RT.var("clojure.core", "not");
    }
    
    static {
        __init0();
        Compiler.pushNSandLoader(RT.classForName("cjd__init").getClassLoader());
        try {
            load();
            Var.popThreadBindings();
        }
        finally {
            Var.popThreadBindings();
        }
    }
}

It appears that the compiler optimizes the call to = and does not box the ##NaN values when compiling (not (= ##NaN ##NaN)), whereas the call to not= receives the ##NaNs boxed as Doubles. This then causes a subsequent call to clojure.lang.Util/equiv (after following the call chain through not= -> = -> clojure.lang.Util/equiv) to return true improperly (since NaNs are never equal to anything, even themselves).

IMO, this is a bug, albeit a low priority one. Most programmers successfully use floating point math without ever having to deal with NaNs. While NaNs seem to trigger the bug, there may be other cases that also trigger it. I can't speak to that.

Answered: Is there any possibility of a Clojure Android port?

Mon, 11 Nov 2024 15:14:59 +0000

What I mean is that it has compatibility with Android and Termux, and is on the repos (it currently isn't)

Answered: What are the system requirements for Clojure?

Thu, 07 Nov 2024 19:29:28 +0000

Clojure (the language) is distributed as a Java archive and runs on the JVM, thus you will need Java installed. If you don't have specific Java requirements, we recommend Java 21, the latest LTS release.

The installation links are here for the Clojure CLI which can be used to manage dependencies, run a REPL, etc:
https://clojure.org/guides/install_clojure#_windows_instructions

If you are using WSL, then you'll want to follow the Linux instructions. If no WSL, use the clj-msi installer.

Answered: issue using new functional interface sugar with log4j

Mon, 14 Oct 2024 22:58:43 +0000

(~/clojure)-(!2011)-> clj -Sdeps '{:deps {org.apache.logging.log4j/log4j-api {:mvn/version "2.23.1"}}}'
Clojure 1.12.0
user=> (.isAnnotationPresent org.apache.logging.log4j.util.MessageSupplier java.lang.FunctionalInterface)
false
user=>

(~/clojure)-(!2012)-> clj -Sdeps '{:deps {org.apache.logging.log4j/log4j-api {:mvn/version "2.24.0"}}}'
Clojure 1.12.0
user=> (.isAnnotationPresent org.apache.logging.log4j.util.MessageSupplier java.lang.FunctionalInterface)
true

So, I would expect this to fail with 2.23.1 but work with 2.24.0.

Answered: The new array class syntax in 1.12 doesn't seem to be supported by definterface meta tags

Sat, 24 Aug 2024 20:14:53 +0000

Thanks for helping post the question!

For additional context, I noticed that defprotocol generates a valid interface given the same metadata tags, because the generated methods are dynamically typed, with the tags only being placed as type hints in the protocol map.

user=> (defprotocol PFoo (^String/1 bar [this]))
PFoo
user=> (reify user.PFoo (bar [this] :ok))
#object[user$eval196$reify__197 0x64a9d48c "user$eval196$reify__197@64a9d48c"]
user=> (bar *1)
:ok
user=> (first (.getMethods (:on-interface PFoo)))
#object[java.lang.reflect.Method 0x35178483 "public abstract java.lang.Object user.PFoo.bar()"]

Although the fact that it produces an unreadable symbol feels just as wrong:

user=> (:sigs PFoo)
{:bar {:tag [Ljava.lang.String;, :name bar, :arglists ([this]), :doc nil}}
user=> (get-in PFoo [:sigs :bar :tag])
[Ljava.lang.String;
user=> (class *1) ; oh no
clojure.lang.Symbol

Answered: Inconsistencies between Clojure's new functional interface conversion and Java's

Mon, 10 Jun 2024 13:24:23 +0000

1) Our goal here was to find places where Clojure functions have a semantic match to Java constructs and make their use in that place implicit. Functional interfaces marked as such must have a single method and have clearly stated that intent. SAM interfaces, while structurally similar, do not have that stated intent and may not be a semantic match to Clojure functions (instead being "procedures" or some non-functional idea).

That said, the combination of SAMs and method values is an interesting convergence point that we are still working on. If you are passing a method value to a method taking a SAM, that is a point where we can directly adapt (as Java does with method references) without creating a method value wrapper and adapting that. That is a use where there is no Clojure function and no need for a semantic match and we may support that, still TBD.

2) maybeFIMethod checks that the class has the @FunctionalInterface annotation, which can only exist on interfaces, and thus it is redundant to check if it is an interface.

Answered: More customizable elide meta?

Sun, 02 Jun 2024 20:31:27 +0000

No, that level of customization is not available currently. Can you say more about what problem you're trying to solve?

Answered: Locals clearing + forcing a delay recursively results in NPE

Thu, 30 May 2024 21:26:20 +0000

Seems like a bug to me. Logged as https://clojure.atlassian.net/browse/CLJ-2861

Answered: Why does running an uberjar reload namespaces?

Thu, 25 Apr 2024 19:21:38 +0000

There's no double loading or reloading. Code compilation in Clojure actually runs that code (meaning, it runs all the top-level forms, it won't actually run your -main function unless it's called at the top level). And running the code in an uberjar, well, also runs the code. It's a completely separate step, separate loading.

what are the implications of this double loading?

The main one is that a namespace declaration should be free of side-effects and referentially transparent (barring implicitly changing the current namespace by all the defs).

What if I had some very expensive computation in a def, and really wanted to pre-compute it once (and only once)?

If you don't want for the expensive computation to be run at compile time, you can use delay.
If you want to inline the results of a computation during compilation, you can use a macro.

Answered: Compiler exception caused by dynamically created :arglists metadata + recursive call in defn body

Mon, 22 Apr 2024 17:28:03 +0000

Var arglists should be a literal list of vectors, like:

:arglists '([shape] [shape shape-attrs])

Cannot invoke "clojure.lang.Var.isBound()" because "clojure.lang.Compiler.LOADER" is null, potential bug?

Thu, 18 Apr 2024 16:11:35 +0000

As per discussion on slack I'm posting here the findings regarding clojure.lang.Compiler.LOADER being null during the analysis phase of GraalVM native-image run.

The full reproduction can be found here and the link to issue on Oracle GraalVM side here.

What is this issue about?

Native Image cannot be produced and throws an error during analysis phase when Clojure 1.11.2 (although the previous version of Clojure might be also affected) is used and reflection entries for java.lang.UUID and clojure.lang.Keyword are present in reflectionconfig.json.

I can't however reproduce the error prior to Clojure 1.9.0. For more information please kindly take a look into a repro.

Answered: Why does compilation of fn fail when referencing a class with a failing static field initializer?

Mon, 08 Apr 2024 16:51:12 +0000

Almost certainly the compiler is emitting a Class.forName() somewhere instead of the variation of that with initialize=false, causing the static initializer to run before its needed.

Logged as https://clojure.atlassian.net/browse/CLJ-2842

Answered: Can direct-linking be enabled for my own code and not for libraries?

Tue, 27 Feb 2024 16:12:47 +0000

can break libraries

How so?

What matters is what those compiler bindings are set to when compiling happens. Compiling happens during load, so it should be possible to be clever about this, but it would be clever. I think there is another ask question somewhere about giving more control around where to direct link.

Answered: In 1.12, use arity for method selection disambiguation where possible

Sun, 11 Feb 2024 21:46:13 +0000

This is by design - in qualified constructor, instance method, and static method symbols in invocation or value position require you to specify exactly one method arity/overload via if param-tags. No inference is done, no reflection occurs, and you wll get a compiler exception if the method is ambiguous.

The one special case is static methods in invocation position, as this was the only pre-existing place where qualified methods were allowed, and inference was previously used. For backwards compatibility, inference will still be used in this case (if no param-tags are provided).

Answered: Validation that next Clojure version has no regression in language semantics with previous version

Tue, 30 Jan 2024 19:17:24 +0000

In general, we do not change semantics, so they don't break. :)

We do add new semantics and sometimes change error cases into new working semantics. The #1 way we avoid breakage is that we think really hard about what we're doing, which I know is out of fashion in software development, but we have a pretty good track record.

From a binary compatibility perspective, there are a few policies we follow. We never make changes in Java implementation classes that may be invoked by compiled Clojure code (this is primarily code in RT and Reflector) - although we do add new methods or arities as needed. We also have similar policies around serialization changes, and around macros that introduce calls to new functions. We do not guarantee binary or serialization compatibility across versions (but we try hard to maintain that as much as possible).

And also there are tests of course, although there are not a ton of those that directly check compilation for example, although all Clojure code is compiled so this is kind of implicitly checked in all tests.

Executable 'java' not found on system path.

Wed, 03 Jan 2024 19:38:51 +0000

Hi guys I,m basically trying to run a clojure script app using a shadow file, to be honest i don't really know too much about clojure since this is a project that i downloaded, but i need it to make it run locally on windows 11 and i'm receiving the following error

shadow-cljs - config: C:\Appsmiths\i\src\winglue\webglue\shadow-cljs.edn
===== ERROR =================

Executable 'java' not found on system path.

I have java on my system of course and my environment variables are well configured, so i think it could be something inside of the shadow file, but i cannot identify what it is, if you can help me out with this it would be really helpful

this is basically all the shadow config:

;; shadow-cljs configuration
{:dependencies [
                [akiroz.re-frame/storage "0.1.3"]
                [bidi "2.1.5"]
                [com.cemerick/url "0.1.1"]
                [binaryage/devtools "1.0.2"]
                [binaryage/oops "0.7.1"]
                [com.cognitect/transit-cljs "0.8.256"]
                [com.rpl/specter "1.1.3"]
                [com.taoensso/timbre "4.10.0"]
                [cljs-http "0.1.46"]
                [day8.re-frame/async-flow-fx "0.1.0"]
                [day8.re-frame/http-fx "0.1.6"]
                [day8.re-frame/re-frame-10x "1.5.0"]
                [day8.re-frame/tracing "0.5.1"]
                [day8.re-frame/undo "0.3.2"]
                [district0x/graphql-query "1.0.6"]
                [district0x/re-frame-interval-fx "1.0.2"]
                [expound "0.8.5"]
                [funcool/cuerdas "2021.05.29-0"]
                [funcool/promesa "2.0.1"]
                [juji/editscript "0.4.6"]
                [maximgb/re-state "1.5.0"]
                [medley "1.2.0"]
                [metosin/spec-tools "0.10.4"]
                [org.clojure/data.json "0.2.6"]
                [org.clojure/spec.alpha "0.2.187"]
                [pez/clerk "1.0.0"]
                [prismatic/schema "1.1.12"]
                [re-frame "1.3.0"]
                [re-graph "0.1.15" :exclusions [cljs-http]]
                [com.andrewmcveigh/cljs-time "0.5.2"]
                [reagent "1.1.1"]
                [spyscope "0.1.6"]
                [venantius/accountant "0.2.5"]
                [lambdaisland/regal "0.0.143"]
                [cheshire "5.11.0"]
                [camel-snake-kebab "0.4.3"]
                [garden/garden-units "1.0.0-RC2"]
                [cljs-bean "1.8.0"]]

 :source-paths ["lib" "graphql" "src" "C:/Appsmiths/i/src/winglue-artifact/webglue" "test"]
 :nrepl {:port 41002}
 :open-file-command ["idea " :pwd " --line " :line :file]
 ;; webglue artifact are in /i/src/winglue-artifact/webglue/js
 :builds {:app {:output-dir "C:/Appsmiths/i/src/winglue-artifact/webglue/js"
                :asset-path "/js"
                :compiler-options
                {:optimizations :none
                 ;; use es2018 for recat-markdown-editor
                 :output-feature-set :es2018
                 :main webglue.core
                 :closure-warnings {:global-this :off}
                 :closure-defines {re-frame.trace/trace-enabled? true
                                   day8.re-frame-10x.debug?             true
                                   day8.re-frame.tracing.trace-enabled? true}
                 :external-config {:devtools/config {:features-to-install    [:formatters :hints]
                                                     :fn-symbol              "Fn"
                                                     :print-config-overrides true}}}
                :target :browser
                :js-options {:ignore-asset-requires true}
                :module-loader true
                :modules {:webglue
                          {:entries [webglue.core]}
                          :ag-grid
                          {:entries [webglue.components.ag-grid]
                           :depends-on #{:webglue}}
                          :dev
                          {:entries [webglue.pages.component-show-case webglue.pages.dev]
                           :depends-on #{:webglue}}
                          :plot
                          {:entries [webglue.component-generator.graph
                                     webglue.component-generator.ivsp-plot
                                     webglue.component-generator.pie-chart
                                     webglue.component-generator.bar-chart
                                     webglue.component-generator.bubble-chart]
                           :depends-on #{:webglue}}}
                :devtools {:repl-pprint true
                           :after-load webglue.core/reload!
                           :loader-mode :eval
                           :http-root "C:/Appsmiths/i/src/winglue-artifact/webglue"
                           :http-port 3333
                           :http-handler shadow.http.push-state/handle
                           :preloads [devtools.preload
                                      ; use only for debug re-frame, this option wil take 300 ms to reload and 330 file to watch
                                      ; run by uncomment next line, and save. shadow-cljs will do the rest
                                      day8.re-frame-10x.preload]}}
          :win-app {:output-dir "C:/Appsmiths/i/src/winglue-artifact/webglue"
                    :asset-path "/js"
                    :compiler-options
                    {:optimizations :none
                     :output-feature-set :es2018
                     :main webglue.core
                     :closure-warnings {:global-this :off}
                     :closure-defines {re-frame.trace/trace-enabled? true
                                       day8.re-frame-10x.debug?             true
                                       day8.re-frame.tracing.trace-enabled? true}
                     :external-config {:devtools/config {:features-to-install    [:formatters :hints]
                                                         :fn-symbol              "Fn"
                                                         :print-config-overrides true}}}
                    :target :browser
                    :js-options {:ignore-asset-requires true}
                    :modules {:webglue {:entries [webglue.core]}}
                    :devtools {:http-port 3434
                               :http-root "C:/Appsmiths/i/src/winglue-artifact/webglue"
                               :http-handler shadow.http.push-state/handle
                               :after-load webglue.core/reload!
                               :loader-mode :eval
                               :preloads [devtools.preload
                                          day8.re-frame-10x.preload]}}
          :test {:target :browser-test
                 :test-dir "test-assets"
                 :devtools {:http-port 9100
                            :http-root "test-assets"}
                 :runner-ns main-test-initial
                 :js-options {:ignore-asset-requires true}
                 :ns-regexp "-test$"}

          :app-release {:target :browser
                        :modules {:webglue
                                  {:entries [webglue.core]}}
                        :js-options {:ignore-asset-requires true}
                        :compiler-options {:source-map false
                                           :output-feature-set :es2018
                                           :main  webglue.core
                                           :closure-defines {}}
                        :release  {:output-dir "C:/Appsmiths/i/src/winglue-artifact/webglue/js"}}

          :tao2py-release {:target :browser
                           :js-options {:ignore-asset-requires true}
                           :compiler-options
                           {:source-map false
                            :output-feature-set :es2018
                            :main  webglue.core
                            :closure-defines {webglue.config/tao2py-release true
                                              ;; landing page is page key in webglue.route_pages
                                              webglue.config/landing-page "field-overview"}}
                           :release  {:output-dir "C:/Appsmiths/i/src/winglue-artifact/webglue/js"
                                      :asset-path "/js"}
                           :module-loader true
                           :modules {:webglue
                                     {:entries [webglue.core]}
                                     :ag-grid
                                     {:entries [webglue.components.ag-grid]
                                      :depends-on #{:webglue}}
                                     :dev
                                     {:entries [webglue.pages.component-show-case webglue.pages.dev]
                                      :depends-on #{:webglue}}
                                     :plot
                                     {:entries [webglue.component-generator.graph
                                                webglue.component-generator.ivsp-plot
                                                webglue.component-generator.pie-chart
                                                webglue.component-generator.bar-chart
                                                webglue.component-generator.bubble-chart]
                                      :depends-on #{:webglue}}}}

          :tao2py-testing {:target :browser
                           :modules {:webglue
                                     {:entries [webglue.core]}}
                           :js-options {:ignore-asset-requires true}
                           :compiler-options {:source-map false
                                              :output-feature-set :es2018
                                              :main  webglue.core
                                              :closure-defines {}}
                           :release  {:output-dir "C:/Appsmiths/i/src/winglue-artifact/webglue/js"}}

          :budger-release {:target :browser
                           :modules {:webglue {:entries [webglue.core]}}
                           :release {:output-dir "release/js"}
                           :js-options {:ignore-asset-requires true}
                           :compiler-options {:source-map false
                                              :output-feature-set :es2018
                                              :main       webglue.core
                                              :closure-defines {}}}}}

Answered: Is clojure.lang.Compiler/analyze safe to use?

Mon, 20 Nov 2023 14:04:27 +0000

It's not considered part of the public API and will return internal classes in the Compiler, which may not be fully accessible in some cases (it has not been designed for this). Those classes also change regularly between releases.

Depending on your needs, you might want to consider https://github.com/clojure/tools.analyzer and https://github.com/clojure/tools.analyzer.jvm.

Answered: 'Method size too large!' compiling a `case` expression with unfortunate clause hashes

Thu, 26 Oct 2023 20:49:54 +0000

Logged as https://clojure.atlassian.net/browse/CLJ-2808

Answered: Compiler bug with lazy-seq getting quoted

Tue, 05 Sep 2023 23:31:17 +0000

Is there some scenario where this is relevant?

Answered: Special symbols can be shadowed inconsistently

Wed, 30 Aug 2023 18:02:13 +0000

Writing a "fix" for this, to throw if a var or local would shadow a special was surprisingly not too bad. However, just in clojure itself there are many instances of var and new and others used in let bindings.

Maybe instead of throwing an error it could print something: "WARNING: shadowing a special symbol is naughty and should not be done!" That's already done in a couple places when defining new vars or in let binds.

Answered: Why gen-class does not generate default interface methods?

Mon, 21 Aug 2023 19:51:35 +0000

That repro doesn't run for me (from the linked branch), I get "Namespace could not be loaded: lint".

I think the actual problem is the reverse of the title - the whole point of default methods is that the implementing class doesn't have to implement the interface's default method. What's actually happening though is that the genclass is generating a method implementation of the default method otherthing that calls through to the Clojure var -otherthing (which is how genclass works but retains the dynamic nature of Clojure).

You can infer this from the error message: "UnsupportedOperationException: otherthing (clojure-sample.foo/-otherthing not defined?)". In "otherthing", it's trying to call "-otherthing".

Logged as https://clojure.atlassian.net/browse/CLJ-2794

Answered: Create/get symbol of class instance?

Tue, 04 Jul 2023 01:26:37 +0000

The easiest way to do this is:

(case (.getName (class c))
  "java.lang.String" "We got a string!"
  "[[I"              "An array of arrays of int.")

I suggest just using strings rather than trying to make them symbols because Java class names can get funky, with leading square brackets if it is an array, and embedded dollar signs if it is a nested class.

Also keep in mind that just a name is not enough to uniquely identify a class; you may have classes with the same name loaded by different class loaders which are not mutually compatible with each other. For most situations where you are thinking about this kind of a case expression, however, this probably won’t be an issue.

Answered: Is a bytecode file generated after the Clojure code compilation?

Tue, 27 Jun 2023 22:24:50 +0000

In general, all Clojure code is compiled to bytecode in classes. If running from source, this is done dynamically and loaded using a custom classloader. Optionally you can compile code "ahead of time" and produce .class files on disk using the compile function.

Some simple top-level expressions evaluated at the repl are simply evaluated without compiling and loading classes.

Answered: Macro-expansion hooks similar to clojure spec

Tue, 30 May 2023 04:58:53 +0000

Logged as https://clojure.atlassian.net/browse/CLJ-2780

Answered: Why does the Clojure compiler give different output for the same input?

Mon, 08 May 2023 14:58:10 +0000

There are a few different reasons this can happen, but two of the main reasons are state being held in unordered Clojure collections (sets or maps) during compilation, or relying on the (arbitrary) result order returned from Java reflection APIs.

We do not consider it a priority to make Clojure builds repeatable, but we are happy to evaluate such issues and fix when it makes sense. (Example from 1.11: https://clojure.atlassian.net/browse/CLJ-1973).

Working with a whole Docker thing is a lot - if you can narrow this down to a specific problem, I'm happy to file a jira with it.

Answered: Macro symbols in &env don't get updated when shadowed, still contain the outer symbol instead.

Mon, 30 Jan 2023 19:45:38 +0000

Logged as https://clojure.atlassian.net/browse/CLJ-2745

Answered: let binding does not infer primitive type of type hinted global var

Mon, 30 Jan 2023 19:04:28 +0000

Regardless of the type hint here, vars are always Objects and it will be a boxed value in the example usage (so not a primitive). However, if marked as a ^:const AND a primitive, the compiler will inline the var in the let with a primitive long and in that case it will be a primitive.

(set! *unchecked-math* :warn-on-boxed)

(def ^{:tag 'long :const true} k 100)

(let [i k] (+ i 10)))

will not warn. :const is often used incorrectly, but this is a good usage for it.

Answered: Finer-grained control over direct-linking

Wed, 21 Dec 2022 19:11:22 +0000

On some particular points:

Would someone want to redefine a clojure.core function for the code they run while being content with an old version still being used by some other code?

People do do this, whether it's a good idea or not. https://github.com/generateme/fastmath is one example.

My second point is that a blanket DL usually brings quite unsubstantial performance improvements

There's more to direct linking than just the perf improvements (which, as you say, are usually not significant other than hot loop code). In particular, not needing to load a var for linking significantly reduces the static initializer and constant pool size, resulting in smaller class sizes and reduced load times. Doing DL on a broad basis makes that significant (clojure.core is particularly big so this is magnified there). If we added lazy var loading, that plus DL would additionally improve that.

All that said, I think there are probably ways that DL could be open to more targeted use, and signalling to consumers of a function might be helpful (kind of the opposite of ^:redef - "please direct link me"). But I think it would be best to work this from the angle of "I am trying to do X and can't", and I'm not hearing that kind of a request here. Or alternately - why is DL not used when it could be? Maybe it's just a lack of awareness or maybe it's because it does not work well with other features or workflows.

Answered: volatile-mutable not recognized in some deftype method subforms

Wed, 21 Dec 2022 19:01:12 +0000

Logged as https://clojure.atlassian.net/browse/CLJ-2743

Answered: How to solve the error I get in the console? - Clojure

Fri, 09 Dec 2022 11:36:08 +0000

You should have inspected & included the stack traces in /tmp/clojure-4521524603536338044.edn (the file path is in the error message).
The problem might be in the cond statement:

(cond
     (= input_ "1") 
     ((println "Table of customers: ")
     (run! println (load-data "cust.txt"))))

If input_ is "1", then the clause ((println "Table of customers: ") (run! println (load-data "cust.txt"))) runs. If we expand the parenthesis slowly, that becomes:

(nil nil)

(println evaluates to nil), which Clojure interprets as a function call, executing nil with 1 argument. Since nil isn't a function, it throws an exception. I ran that in Clojure 1.11.1 though and got a slightly different error message though.

The fix is to have a `(do ...) loop around the printing in the cond.

You look like you are learning Clojure. As a point of advice, the language is designed to use (let) instead of (def input_ (readline)) and recur instead of the recursive call to menu. Well done on finding cond that is a good function here.

Answered: Bytecode not 100% deterministic given identical inputs?

Tue, 27 Sep 2022 15:52:15 +0000

This is not a high priority goal for us. Which is not to say we wouldn't consider a change if it was solving an actual problem for someone.

Answered: Why does Clojure generate too many .class files?

Sun, 18 Sep 2022 13:40:46 +0000

I am curious as to what concrete side effect of 'too many class files' you are seeing? Larger jars, long require times, etc?

Which aspect of the large number of class files are you seeking to optimize?

How many class files are too many?

Answered: How to require a symbol from within a function?

Wed, 01 Jun 2022 16:33:43 +0000

Why not just use requiring-resolve?

Edit, for more detail:

(comment
  (->> [1 2]
       (reduce (fn [acc v]
                 ((requiring-resolve 'clojure.set/union) acc #{v}))
         #{}))
  ;;=> #{1 2}
  )

As I learned talking to Peter (op) offline, the reason that specific piece of code doesn't work is named the Gilardi scenario. An extended description of the problem is available at ClojureDocs.

Another reason to prefer requiring-resolve when possible is that require is not thread-safe as of Clojure 1.11.1. More details about this can be found (among others) in this question, and on ClojureDocs here and here.

need help with compiler error "unresolved symbol"

Fri, 11 Feb 2022 17:59:34 +0000

Hi
I cloned this project, and used VScode to open it. I added Calva, and am half way through the tutorial. I do know what "unresolved symbol" means, but do not know how to fix in a Clojure project especially that this was a working project. I know that the author used Intellij, and I believe it was the ultimate edition. I have the community ( I am ware of the eval, and will use it if I do not have other option. I just like to know how to fix this myself). I am able to run the fire-up tutorial that Calvo comes with, but the compiler error is still there.

VerifyError caused by combination of protocols, primitive type hints, `min`

Tue, 08 Feb 2022 13:41:54 +0000

(defprotocol P
  (^double p1 [p a])
  (^double p2 [p a]))

(let [p (reify P)]
  (min 0.0
       (case :p1
         :p1 (p1 p :foo)
         Double/MAX_VALUE)))

yields

Execution error (VerifyError) at java.lang.Class/getDeclaredConstructors0 (Class.java:-2).
Inconsistent stackmap frames at branch target 121
Exception Details:
  Location:
    user$eval1401301.invokeStatic()Ljava/lang/Object; @115: goto
  Reason:
    Current frame's stack size doesn't match stackmap.
  Current Frame:
    bci: @115
    flags: { }
    locals: { null, 'clojure/lang/Keyword' }
    stack: { double, double_2nd, 'java/lang/Object' }
  Stackmap Frame:
    bci: @121
    flags: { }
    locals: { 'clojure/lang/IObj', 'clojure/lang/Keyword' }
    stack: { double, double_2nd, top, top }
  Bytecode:
    0000000: bb00 0f59 01b7 0012 c000 14b2 0018 c000
    0000010: 1ab9 001e 0200 4b0e b200 224c 2bb8 0028
    0000020: aa00 0000 0000 0056 3c72 5a61 3c72 5a61
    0000030: 0000 0014 2bb2 0022 a600 3e2a 014b 59b8
    0000040: 002c b200 2ea5 0011 59c1 0030 9a00 1c59
    0000050: b800 2cb3 002e b200 34b6 0039 5fb2 003c
    0000060: b900 4203 00a7 000e c000 30b2 003c b900
    0000070: 4602 00a7 0006 b200 4cb8 0054 b800 58b0
    0000080:                                        
  Stackmap Table:
    full_frame(@52,{Object[#20],Object[#91]},{Double})
    full_frame(@86,{Null,Object[#91]},{Double,Object[#20]})
    full_frame(@104,{Null,Object[#91]},{Double,Object[#20]})
    full_frame(@115,{Null,Object[#91]},{Double,Object[#93]})
    full_frame(@118,{Object[#20],Object[#91]},{Double})
    full_frame(@121,{Object[#20],Object[#91]},{Double,Top,Top})

Repro'd against 1.10.3 and 1.11.0-beta1

Let me know if you'd like me to submit this to JIRA :)

James

Clojure Q&A - Recent questions and answers in Compiler

Answered: Changing type tags can lead to cryptic errors

Possibly avoidable identity call to force instance method on Class literals

Feature Request:Make anonymous fn/reify class name IDs per namespace instead of one global counter

Answered: bit-count in cljs but not clj

Answered: Why is `list` defined with a RestFn instead of `create` method?

Answered: cannot call Java Constructor overload

Answered: Macro expansion lose type hints

Unwrapped do is treated as a special form in let and fn bodies

Compiler-generated `foo__init.class` files lack `SourceFile` attribute

Answered: Using letfn* for defining corecursive reified implementations

Answered: Consider documenting usage of `do` for the Gilardi scenario

Answered: Is the ant build broken in Clojure 1.12.1?

Can custom literal collections reach parity with clojure's built in collections?

Teaching Old eval New Tricks

Tagged Literals Promise Extensibility

Towards a Solution

Answered: Breaking change in 1.12.0 - a static field is always preferred to a static function with the same name

Answered: Comparing ratios with BigDecimals can throw

Incorrect result when evaluating `not=` on `##NaNs`

Answered: Is there any possibility of a Clojure Android port?

Answered: What are the system requirements for Clojure?

Answered: issue using new functional interface sugar with log4j

Answered: The new array class syntax in 1.12 doesn't seem to be supported by definterface meta tags

Answered: Inconsistencies between Clojure's new functional interface conversion and Java's

Answered: More customizable elide meta?

Answered: Locals clearing + forcing a delay recursively results in NPE

Answered: Why does running an uberjar reload namespaces?

Answered: Compiler exception caused by dynamically created :arglists metadata + recursive call in defn body

Cannot invoke "clojure.lang.Var.isBound()" because "clojure.lang.Compiler.LOADER" is null, potential bug?

Answered: Why does compilation of fn fail when referencing a class with a failing static field initializer?

Answered: Can direct-linking be enabled for my own code and not for libraries?

Answered: In 1.12, use arity for method selection disambiguation where possible

Answered: Validation that next Clojure version has no regression in language semantics with previous version

Executable 'java' not found on system path.

Executable 'java' not found on system path.

Answered: Is clojure.lang.Compiler/analyze safe to use?

Answered: 'Method size too large!' compiling a `case` expression with unfortunate clause hashes

Answered: Compiler bug with lazy-seq getting quoted

Answered: Special symbols can be shadowed inconsistently

Answered: Why gen-class does not generate default interface methods?

Answered: Create/get symbol of class instance?

Answered: Is a bytecode file generated after the Clojure code compilation?

Answered: Macro-expansion hooks similar to clojure spec

Answered: Why does the Clojure compiler give different output for the same input?

Answered: Macro symbols in &env don't get updated when shadowed, still contain the outer symbol instead.

Answered: let binding does not infer primitive type of type hinted global var

Answered: Finer-grained control over direct-linking

Answered: volatile-mutable not recognized in some deftype method subforms

Answered: How to solve the error I get in the console? - Clojure

Answered: Bytecode not 100% deterministic given identical inputs?

Answered: Why does Clojure generate too many .class files?

Answered: How to require a symbol from within a function?

need help with compiler error "unresolved symbol"

VerifyError caused by combination of protocols, primitive type hints, `min`

Teaching Old `eval` New Tricks