Clojure Q&A - Recent questions tagged type-hints

Reflection warning when long hint on an argument

Fri, 01 May 2026 19:49:31 +0000

Hi,

I noticed some reflection warning that goes away when removing a hint from fn arguments. I would like to understand the reason for this.

Example, loading this code

(set! *warn-on-reflection* true)

(defn duration-of-seconds
  (^java.time.Duration [^long seconds]
   (java.time.Duration/ofSeconds seconds)))

(defn sleep
  [seconds]
  (Thread/sleep (duration-of-seconds seconds)))

Raises a reflection warning:

call to static method sleep on java.lang.Thread can't be resolved (argument types: java.lang.Object).

However, just removing the ^long hint from the duration-of-seconds fn argument, makes the reflection warning go away.

Thanks!

Macro expansion lose type hints

Mon, 03 Nov 2025 13:50:41 +0000

The following snippet demonstrate how type hints when put before a macro expression are being lost.
On the first expression, the compiler correctly complains about the wrong type hint while it gets accepted if you wrap the hinted expression on a macro.

$ clj 
Clojure 1.12.3

user=> (import 'java.util.Date)

user=> (.setHours (Date.) ^long (.getHours (Date.)))
Syntax error (UnsupportedOperationException) compiling fn* at (REPL:1:1).
Cannot coerce int to long, use a cast instead

user=> (.setHours (Date.) ^long (-> (.getHours (Date.))))
nil

Request: def should infer type tag where possible

Fri, 03 May 2024 20:01:21 +0000

Maybe there’s a good reason why it doesn’t, but it seems to me it would be great if def would automatically infer type hint:

(let [s "abc"]
  (.chars s)) ;; all fine, no warning

(def s "abc")

(.chars s) ;; Reflection warning, null:21:0 - reference to field chars can't be resolved.

(meta #'s) ;; ↓ notice -- no tag
;; {:line 19,
;;  :column 0,
;;  :file "NO_SOURCE_FILE",
;;  :name s,
;;  :ns #object[clojure.lang.Namespace 0x78068afb "user"]}

Why can't I type hint these floats?

Thu, 15 Feb 2024 18:48:26 +0000

I want to ensure I'm using unboxed and unreflected arithmetic on arrays of floats, but I can't get it to compile.

How can I type hint a float in a function like this?

`
(defn ff2a

^"[F" ; Return type hint for a float array

[^float f1 ^float f2] ; Argument type hints

(float-array [f1 f2]))
`

I get this error when I try to load it into the REPL:

Syntax error (IllegalArgumentException) compiling fn* [...] Only long and double primitives are supported

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

Mon, 30 Jan 2023 03:23:21 +0000

When you type hint a var such as:

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

And refer to it in a let binding:

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

The binding is unable to properly infer that it is a primitive type as it was hinted:

(set! *unchecked-math* :warn-on-boxed)
(def ^{:tag 'long} k 100)
(let [i k]
  (+ i 10))
;;=> Boxed math warning, unchecked_add(java.lang.Object,long).

It looks like it might be caused by a bug in the Compiler where for some reason, the expression of the var k is marked as not having a java class, even though it has one:

(defmacro inspect-local []
  (println
   (into {}
         (map (fn[[k v]]
                [k {:tag (.-tag v)
                    :class (.getJavaClass v)
                    :primitive? (.isPrimitive (.getJavaClass v))
                    :has-java-class? (.hasJavaClass v)}]))
         &env)))

(let [i k]
  (inspect-local)
  (+ i 10))

;;=> {i {:tag nil, :class long, :primitive? true, :has-java-class? false}}

As we can see, .hasJavaClass returns false, but .getJavaClass returns the Long/TYPE class.

I suspect that the compiler checks for .hasJavaClass before calling .getJavaClass, and since .hasJavaClass is erroneously false here, it would cause the compiler to think it isn't, and that the type can't be inferred.

I'm not too sure where in the Compiler this is, but I found the following: https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/Compiler.java#L1341

Where we see the compiler is first checking for .hasJavaClass:

 if(e instanceof MaybePrimitiveExpr && e.hasJavaClass() && ((MaybePrimitiveExpr)e).canEmitPrimitive())

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

Mon, 30 Jan 2023 03:13:31 +0000

(defmacro inspect
  [& body]
  (println (keys &env) (map meta (keys &env)))
  `(do ~@body))

(let [^:1 a 1]
  (let [^:2 a 2]
    (let [^:3 a 3]
      (inspect "hello"))))

;;=> (a) ({:1 true})
"hello"

The &env form returns a map of {sym LocalBinding} and the symbols on the keys of the map are supposed to be the local symbols, but as we see in the above code, when a local symbol is shadowing another, it seems the map does not contain the shadowing symbol, but instead contains the shadowed symbol. We can see that because it is returning the metadata of the outermost symbol, and not the inner one that is shadowing it.

In my opinion, this is a bug, that said, you can still get at the actual shadowing symbol by calling .-sym on the LocalBinding, in which case you get the inner shadowing symbol and it will have the right metadata.

into-array should not need type hints

Sat, 15 May 2021 16:49:15 +0000

Currently into-array's return value needs type hinting in addition to having to specify the target class in the first place. Type hinting array types isn't exactly trivial either (with the weird and extremely verbose ^"[Lorg.clojure.MyClass;" syntax).

It would be really nice if the compiler could deal with that for the user.

Type hints getting ignored, reverting to java.lang.Object

Sun, 02 May 2021 01:56:00 +0000

  (deftype l [^java.util.List x])
  (use '[clojure.reflect :as r])
  (:members (r/reflect (l. `())))

Despite the type-hints of java.util.List, on reflection x seems to always be an Object

Have been specifically trying to get an optaplanner example working in 100% clojure https://github.com/joinr/optaplanner-clj/tree/163d326a6433b88ca9811e33d30758ceff42b91f . The code is evaluating but this error keeps occurring on running (solve (->problem))

Unhandled java.lang.IllegalStateException The solutionClass (class optaplanner_clj.data.TimeTable) has a
PlanningEntityCollectionProperty annotated member (public final
java.lang.Object optaplanner_clj.data.TimeTable.lessonList) that does
not return a Collection or an array.

Can I use spec as type hint?

Sun, 11 Apr 2021 07:30:38 +0000

One cool feature of schema is that it works well with type hint,
So I can use it for validation, compiler optimization and documentation directly on the function. I'd like to know if the same could be done using specs and if possible, a real example. Thanks!

Can the clojure.tools.trace reflection warnings be addressed?

Thu, 11 Feb 2021 18:39:41 +0000

I frequently see these as part of my daily workflow - which is slightly inconvenient:

Reflection warning, clojure/tools/trace.clj:231:54 - call to method setStackTrace on java.lang.Object can't be resolved (no such method).
Reflection warning, clojure/tools/trace.clj:242:56 - call to method setStackTrace on java.lang.Object can't be resolved (no such method).
Reflection warning, clojure/tools/trace.clj:244:49 - call to java.lang.Exception ctor can't be resolved.
Reflection warning, clojure/tools/trace.clj:244:69 - call to method setStackTrace on java.lang.Object can't be resolved (no such method).
Reflection warning, clojure/tools/trace.clj:256:56 - call to method setStackTrace on java.lang.Object can't be resolved (no such method).
Reflection warning, clojure/tools/trace.clj:259:49 - call to java.lang.Throwable ctor can't be resolved.
Reflection warning, clojure/tools/trace.clj:259:69 - call to method setStackTrace on java.lang.Object can't be resolved (no such method).
Reflection warning, clojure/tools/trace.clj:275:56 - call to method setStackTrace on java.lang.Object can't be resolved (no such method).
Reflection warning, clojure/tools/trace.clj:276:68 - call to method setStackTrace on java.lang.Object can't be resolved (no such method).

Checking out the tools.trace code @ master, these seem tractable.

Could these reflection warnings be avoided?

Typehint `clojure.spec.alpha/explain-str`

Tue, 29 Dec 2020 18:19:38 +0000

Type hinting clojure.spec.alpha/explain-str would help in instances like the following,
(throw (IllegalArgumentException. (s/explain-str ::some-spec value)))

Reflection warnings in clojure.data.xml

Thu, 26 Nov 2020 15:04:41 +0000

The latest-on-Maven (0.2.0-alpha6) clojure.data.xml incurs reflection warnings.

$ clj
Clojure 1.10.1
user=> (set! *warn-on-reflection* true)
true
user=> (require '[clojure.data.xml :as dx])
Reflection warning, clojure/data/xml/jvm/name.clj:35:1 - call to static method decode on java.net.URLDecoder can't be resolved (argument types: unknown, java.lang.String).
Reflection warning, clojure/data/xml/jvm/name.clj:38:1 - call to static method encode on java.net.URLEncoder can't be resolved (argument types: unknown, java.lang.String).
nil
user=> (slurp "deps.edn")
"{:deps\n {org.clojure/data.xml {:mvn/version \"0.2.0-alpha6\"}}}"

There have been some updates in git, but they have not altered jvm/name.clj, so the issue might still be current.

defrecord could type hint the record constructor functions

Fri, 20 Mar 2020 00:17:49 +0000

Here's some code:

(set! *warn-on-reflection* true)
(defrecord Foo [bar])
(.-bar (->Foo "bar"))

;;> Reflection warning, NO_SOURCE_PATH:1:1 - reference to field bar can't be resolved.
;;=> "bar"

As we can see, the generated ->Foo function to construct record of type Foo is not type hinted, and thus Clojure will use reflection when doing interop calls over it.

It would be nice if Clojure would generate a type hinted constructor instead.

Infer Var type hint in a def from the return type hint of the function call that initializes it

Fri, 20 Mar 2020 00:13:39 +0000

Here's an example code:

(set! *warn-on-reflection* true)
(defn hello ^String []
  "hello")
(def a (hello))
(.replace a \e \a)

;;> Reflection warning, NO_SOURCE_PATH:1:1 - call to method replace can't be resolved (target class is unknown).
;;=> "hallo"

As we can see, Clojure doesn't seem to be able to infer the type of the Var a, even though the function (hello) had its return type hinted.

It would be great if Clojure could infer this. Otherwise, as of now, the user must provide an explicit type hint for it.

Is there a way to type hint derefs?

Thu, 21 Nov 2019 02:00:05 +0000

There are cases where I have either a delay or a future returning a Java object, in those cases, it seems you can only type hint the returned value of deref from the call site.

(.reflectionAvoided ^SomeObj @some-delayed-java-object)

Is there a way to type hint it at the definition site? If not, would this be a logical feature request?

(def some-delayed-java-object
  (delay (SomeObj.)))

(.someReflectionNeedingMethod @some-delayed-java-object)

Thank You