Clojure Q&A - Recent questions in Java Interop

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!

definterface doesn't expose gen-interface's :extends for interface extension

Mon, 26 Jan 2026 19:49:08 +0000

gen-interface allow :extends to specify one or more interfaces, which will be extended by this interface.

definterface doesn't expose this.

Use case is working with primitives (where protocols don’t help), to get things to dispatch nicely in a zero boxing primitive transducer implementation.

clojure.core/subs should use type hints of ^CharSequence, NOT ^String

Tue, 13 Jan 2026 18:10:48 +0000

This is related to this ancient ask, but it would be ideal if clojure.core/subs was type hinted with ^CharSequence rather than ^String, and used the subSequence() method instead of substring() (since the latter doesn't exist in CharSequence).

The single parameter version of subs would need to call s.length() as the second argument in the call to subSequence() (there is no single-arg version of that method, unlike substring()).

More generally, there are substantial benefits in using CharSequence instead of String throughout Clojure core, not only in the context of Java interop, but also when using custom String-like data structures (e.g. ropes).

[edit] @alexmiller mentioned this in another forum (and I'm capturing it here for posterity), but this might also require that the result be stred, to ensure the return type remains unchanged (subSequence() returns a CharSequence, unlike substring, which might break callers). There may be performance implications of adding that call for types other than String (but existing callers should be unaffected, since String.toString() is identity).

Could we get deref support on ScopedValue?

Tue, 25 Nov 2025 16:26:47 +0000

Following on from this, and since Optional is already being considered, I would like to propose that ScopedValue is considered as well. It is now a standard feature on an LTS release (i.e. 25).

As always, thanks in advance...

Multiple Java types cannot be idiomatically leveraged w/o proper `IDeref` support

Mon, 24 Nov 2025 17:33:52 +0000

There are certain java types that are a perfect fit for IDeref - e.g. Optional, ScopedValue, LazyConstant etc. However, since IDeref is not a protocol (like in cljs), we are left with having to ask for this to be added/supported (e.g. this) every time. I guess my question is whether it is at all feasible to have IDeref be a protocol, and if not, what are the plans (if any) for supporting deref on these types?

Many thanks in advance...

Improve javadoc especially for tool usage

Tue, 16 Sep 2025 17:54:13 +0000

In order to provide a hot key in VS Code to show the JavaDocs associated with a selected form (class name or the type of an expression), I wrote the following Joyride script:

https://github.com/seancorfield/vscode-calva-setup/blob/develop/joyride/scripts/javadoc.cljs#L15

This highlights three issues that could be addressed/improved:

On JDKs later than 15, the javadoc machinery falls back to JDK 8, unless you explicitly call add-remote-javadoc for at least java. and javax.. This is a known issue that should be addressed in Clojure 1.13 per https://clojure.atlassian.net/browse/CLJ-2920 -- hopefully it will assume the URL structure for JDKs going forward so we don't run into this problem again, unless Oracle changes their URL structure again (hopefully, unlikely).
javadoc-url is private so tools have to use #' to access it, which makes it feel like this is just an implementation detail and subject to change. It would be nice for tools if this was part of the public, documented API for clojure.java.javadoc.
Inner classes are not handled well. If you ask for the javadoc-url for java.util.Map$Entry, you get a URL with Map$Entry.html which doesn't exist. Since inner classes are documented in their outer class, removing $[a-zA-Z0-9_]+ from the class name or from the URL would really help here.

Here's an example REPL session for Clojure 1.12.2 on JDK 24, showing these issues:

user=> (clojure-version) "1.12.2" user=> (require 'clojure.java.javadoc) nil user=> (#'clojure.java.javadoc/javadoc-url "java.util.concurrent.ExecutionException") "http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutionException.html" user=> (#'clojure.java.javadoc/javadoc-url "java.util.Map$Entry") "http://docs.oracle.com/javase/8/docs/api/java/util/Map$Entry.html" user=>

Refection warning even with type hinting

Fri, 11 Jul 2025 14:48:42 +0000

I have the function

(defn println-err [^String s]
  (.println *err* s))

When I set *warn-on-reflections*, I get
> call to method println can't be resolved (target class is unknown).

I can work around this with (binding [*out* *err*] (println s))), but I'd like to know why I'm getting this reflection warning even though I'm telling the compiler the type.

Note: I have zero Java experience.

Method with int parameter is called, although the provided parameter is long

Sat, 05 Jul 2025 21:13:00 +0000

AIMesh provides several overloaded create methods. There is one with an int parameter and another one with a long parameter. They have very different semantics.

This code snippet intends to call the one with the long parameter:

(defn read-model
  "read a 3D model from a file"
  [path]
  (let [scene (Assimp/aiImportFile path (bit-or Assimp/aiProcess_Triangulate
                                                Assimp/aiProcess_FlipUVs))]
    (if (= scene nil)
      (println (Assimp/aiGetErrorString))
      (for [index (range (.mNumMeshes scene))]
        (let [pointer (.get (.mMeshes scene) index)]
          (assert (= (type pointer) java.lang.Long))
          (AIMesh/create pointer))))))

The assertion right before the problematic call makes sure that pointer is indeed a long; but nevertheless the int overload of create is called, as can be verified in the stack trace:

{:clojure.main/message
 "Execution error (IllegalArgumentException) at java.nio.Buffer/createCapacityException (Buffer.java:290).\ncapacity < 0: (-689151616 < 0)\n",
 :clojure.main/triage
 {:clojure.error/class java.lang.IllegalArgumentException,
  :clojure.error/line 290,
  :clojure.error/cause "capacity < 0: (-689151616 < 0)",
  :clojure.error/symbol java.nio.Buffer/createCapacityException,
  :clojure.error/source "Buffer.java",
  :clojure.error/phase :execution},
 :clojure.main/trace
 {:via
  [{:type clojure.lang.Compiler$CompilerException,
    :message
    "Syntax error macroexpanding at (learnopengl/core.clj:12:1).",
    :data
    {:clojure.error/phase :execution,
     :clojure.error/line 12,
     :clojure.error/column 1,
     :clojure.error/source "learnopengl/core.clj"},
    :at [clojure.lang.Compiler load "Compiler.java" 7665]}
   {:type java.lang.IllegalArgumentException,
    :message "capacity < 0: (-689151616 < 0)",
    :at [java.nio.Buffer createCapacityException "Buffer.java" 290]}],
  :trace
  [[java.nio.Buffer createCapacityException "Buffer.java" 290]
   [java.nio.Buffer <init> "Buffer.java" 253]
   [java.nio.ByteBuffer <init> "ByteBuffer.java" 316]
   [java.nio.ByteBuffer <init> "ByteBuffer.java" 324]
   [java.nio.MappedByteBuffer <init> "MappedByteBuffer.java" 113]
   [java.nio.DirectByteBuffer <init> "DirectByteBuffer.java" 107]
   [java.nio.ByteBuffer allocateDirect "ByteBuffer.java" 360]
   [org.lwjgl.system.Struct __create "Struct.java" 118]
   [org.lwjgl.assimp.AIMesh create "AIMesh.java" 487]
   [jdk.internal.reflect.DirectMethodHandleAccessor
    invoke
    "DirectMethodHandleAccessor.java"
    103]
   [java.lang.reflect.Method invoke "Method.java" 580]
   [clojure.lang.Reflector invokeMatchingMethod "Reflector.java" 167]
   [clojure.lang.Reflector invokeStaticMethod "Reflector.java" 332]
   [learnopengl.mesh_model$read_model$iter__332__336$fn__337$fn__338
    invoke
    "mesh_model.clj"
    66]
   [learnopengl.mesh_model$read_model$iter__332__336$fn__337
    invoke
    "mesh_model.clj"
    63]
   [clojure.lang.LazySeq sval "LazySeq.java" 42]
   [clojure.lang.LazySeq seq "LazySeq.java" 51]
   [clojure.lang.RT seq "RT.java" 535]
   [clojure.lang.RT countFrom "RT.java" 650]
   [clojure.lang.RT count "RT.java" 643]
   [learnopengl.core$eval351 invokeStatic "core.clj" 12]
   [learnopengl.core$eval351 invoke "core.clj" 12]
   [clojure.lang.Compiler eval "Compiler.java" 7194]
   [clojure.lang.Compiler load "Compiler.java" 7653]
   [clojure.lang.RT loadResourceScript "RT.java" 381]
   [clojure.lang.RT loadResourceScript "RT.java" 372]
   [clojure.lang.RT load "RT.java" 459]
   [clojure.lang.RT load "RT.java" 424]
   [clojure.core$load$fn__6908 invoke "core.clj" 6161]
   [clojure.core$load invokeStatic "core.clj" 6160]
   [clojure.core$load doInvoke "core.clj" 6144]
   [clojure.lang.RestFn invoke "RestFn.java" 408]
   [clojure.core$load_one invokeStatic "core.clj" 5933]
   [clojure.core$load_one invoke "core.clj" 5928]
   [clojure.core$load_lib$fn__6850 invoke "core.clj" 5975]
   [clojure.core$load_lib invokeStatic "core.clj" 5974]
   [clojure.core$load_lib doInvoke "core.clj" 5953]
   [clojure.lang.RestFn applyTo "RestFn.java" 142]
   [clojure.core$apply invokeStatic "core.clj" 669]
   [clojure.core$load_libs invokeStatic "core.clj" 6016]
   [clojure.core$load_libs doInvoke "core.clj" 6000]
   [clojure.lang.RestFn applyTo "RestFn.java" 137]
   [clojure.core$apply invokeStatic "core.clj" 669]
   [clojure.core$require invokeStatic "core.clj" 6038]
   [clojure.core$require doInvoke "core.clj" 6038]
   [clojure.lang.RestFn invoke "RestFn.java" 408]
   [user$eval140$fn__144 invoke "form-init15974239925031016013.clj" 1]
   [user$eval140 invokeStatic "form-init15974239925031016013.clj" 1]
   [user$eval140 invoke "form-init15974239925031016013.clj" 1]
   [clojure.lang.Compiler eval "Compiler.java" 7194]
   [clojure.lang.Compiler eval "Compiler.java" 7184]
   [clojure.lang.Compiler load "Compiler.java" 7653]
   [clojure.lang.Compiler loadFile "Compiler.java" 7591]
   [clojure.main$load_script invokeStatic "main.clj" 475]
   [clojure.main$init_opt invokeStatic "main.clj" 477]
   [clojure.main$init_opt invoke "main.clj" 477]
   [clojure.main$initialize invokeStatic "main.clj" 508]
   [clojure.main$null_opt invokeStatic "main.clj" 542]
   [clojure.main$null_opt invoke "main.clj" 539]
   [clojure.main$main invokeStatic "main.clj" 664]
   [clojure.main$main doInvoke "main.clj" 616]
   [clojure.lang.RestFn applyTo "RestFn.java" 137]
   [clojure.lang.Var applyTo "Var.java" 705]
   [clojure.main main "main.java" 40]],
  :cause "capacity < 0: (-689151616 < 0)",
  :phase :execution}}

This repository contains the full code to reproduce the error. read-model is defined in mesh-model.clj.

I ran this with Clojure version 1.11.1 and Java version:

openjdk 21.0.7 2025-04-15
OpenJDK Runtime Environment (Red_Hat-21.0.7.0.6-2) (build 21.0.7+6)
OpenJDK 64-Bit Server VM (Red_Hat-21.0.7.0.6-2) (build 21.0.7+6, mixed mode, sharing)

There was a previous question on stackoverflow leading to this question.

Why does a qualified instance method call fails at compile time with NullPointerException if missing target

Mon, 30 Jun 2025 13:33:36 +0000

Has anyone else noticed a lot of Syntax error (NullPointerException) when using the new Class/.instanceMethod syntax? Specifically whenever I forget the first argument like

(fn [] (String/.length))

gets

#error{:cause "Cannot invoke \"clojure.lang.Compiler$Expr.emit(clojure.lang.Compiler$C, clojure.lang.Compiler$ObjExpr, clojure.asm.commons.GeneratorAdapter)\" because \"this.target\" is null",
       :via [{:type clojure.lang.Compiler$CompilerException,
              :message "Syntax error compiling fn* at (/private/var/folders/cr/wpw7hgnx0jj9m33g28rtbpzc0000gn/T/form-init4871175438924650637.clj:1:1).",
              :data #:clojure.error{:phase :compile-syntax-check,
                                    :line 1,
                                    :column 1,
                                    :source "/private/var/folders/cr/wpw7hgnx0jj9m33g28rtbpzc0000gn/T/form-init4871175438924650637.clj",
                                    :symbol fn*},
              :at [clojure.lang.Compiler analyzeSeq "Compiler.java" 7677]}
             {:type java.lang.NullPointerException,
              :message "Cannot invoke \"clojure.lang.Compiler$Expr.emit(clojure.lang.Compiler$C, clojure.lang.Compiler$ObjExpr, clojure.asm.commons.GeneratorAdapter)\" because \"this.target\" is null",
              :at [clojure.lang.Compiler$InstanceMethodExpr emit "Compiler.java" 2060]}],
       :trace [[clojure.lang.Compiler$InstanceMethodExpr emit "Compiler.java" 2060]
               [clojure.lang.Compiler$BodyExpr emit "Compiler.java" 6723]
               [clojure.lang.Compiler$FnMethod doEmit "Compiler.java" 6243]
               [clojure.lang.Compiler$FnMethod emit "Compiler.java" 6045]
               [clojure.lang.Compiler$FnExpr emitMethods "Compiler.java" 4500]
               [clojure.lang.Compiler$ObjExpr compile "Compiler.java" 5136]
               [clojure.lang.Compiler$FnExpr parse "Compiler.java" 4662]
               [clojure.lang.Compiler analyzeSeq "Compiler.java" 7667]
               [clojure.lang.Compiler analyze "Compiler.java" 7360]
               [clojure.lang.Compiler analyze "Compiler.java" 7316]
               [clojure.lang.Compiler$BodyExpr$Parser parse "Compiler.java" 6683]
               [clojure.lang.Compiler$FnMethod parse "Compiler.java" 6022]
               [clojure.lang.Compiler$FnExpr parse "Compiler.java" 4585]
               [clojure.lang.Compiler analyzeSeq "Compiler.java" 7667]
               [clojure.lang.Compiler analyze "Compiler.java" 7360]
               [clojure.lang.Compiler eval "Compiler.java" 7736]
               [clojure.lang.Compiler eval "Compiler.java" 7694]
               [clojure.core$eval invokeStatic "core.clj" 3232]
               [clojure.core$eval invoke "core.clj" 3228]
               [nrepl.middleware.interruptible_eval$evaluate$fn__966$fn__967 invoke "interruptible_eval.clj" 87]
               [clojure.lang.AFn applyToHelper "AFn.java" 152]
               [clojure.lang.AFn applyTo "AFn.java" 144]
               [clojure.core$apply invokeStatic "core.clj" 667]
               [clojure.core$with_bindings_STAR_ invokeStatic "core.clj" 1990]
               [clojure.core$with_bindings_STAR_ doInvoke "core.clj" 1990]
               [clojure.lang.RestFn invoke "RestFn.java" 428]
               [nrepl.middleware.interruptible_eval$evaluate$fn__966 invoke "interruptible_eval.clj" 87]
               [clojure.main$repl$read_eval_print__9248$fn__9251 invoke "main.clj" 437]
               [clojure.main$repl$read_eval_print__9248 invoke "main.clj" 437]
               [clojure.main$repl$fn__9257 invoke "main.clj" 459]
               [clojure.main$repl invokeStatic "main.clj" 459]
               [clojure.main$repl doInvoke "main.clj" 368]
               [clojure.lang.RestFn invoke "RestFn.java" 1526]
               [nrepl.middleware.interruptible_eval$evaluate invokeStatic "interruptible_eval.clj" 84]
               [nrepl.middleware.interruptible_eval$evaluate invoke "interruptible_eval.clj" 56]
               [nrepl.middleware.interruptible_eval$interruptible_eval$fn__997$fn__1001
                invoke
                "interruptible_eval.clj"
                152]
               [clojure.lang.AFn run "AFn.java" 22]
               [nrepl.middleware.session$session_exec$main_loop__1065$fn__1069 invoke "session.clj" 202]
               [nrepl.middleware.session$session_exec$main_loop__1065 invoke "session.clj" 201]
               [clojure.lang.AFn run "AFn.java" 22]
               [java.lang.Thread run "Thread.java" 1447]]}

Default Imports Don't Include Clojure Internals

Tue, 24 Jun 2025 14:02:08 +0000

The map clojure.lang.RT/DEFAULT_IMPORTS defines all of the Java classes that are (by default) available in all Clojure namespaces. In 2007, Rich added and then commented out a number of the clojure.lang classes and interfaces (removed in this commit) without any commentary, and those lines have remained unchanged since.

Is there a reason why the "primary" clojure.lang classes and interfaces aren't imported by default?

Idiomatic way to use java.util.Optional

Mon, 07 Apr 2025 14:16:59 +0000

Is there an easy way to work with java.utils.Optional values in Clojure? I'm currently using 1.12 so I can say things like (Optional/.orElse foo nil) to convert the optional value to a "normal" value (X or nil), but that and other Optional methods are still sources of tension or boilerplate compared idiomatic Clojure constructs (some-> for example).

If such a way doesn't currently exist, can it be considered for addition to Clojure? Maybe opening up deref to work on Optionals as well.

Using java.data

Wed, 02 Apr 2025 15:55:56 +0000

Hi @here,
Clojure noob and java dev here.
Wanted to convert a tree object into clojure object. This is not the definite end goal.

Aim is to provide a human readable intermediate language that will have parameterized methods for similar subtrees that will provide lazy initialization for breadth first search from root. (Not a proper BFS, you have expand and create objects for all children and when a node is selected among children, you have to get all its children. So, more like, expand all nodes, select a node, repeat)

This will again output a data format like yaml.

When I tried to do traversal in the clojure with java.data lib, it threw error because the objects were not pure java beans. So, I plugged into the name space and changed a method definition to use reflection instead of getter, setters.

Then it was working for simple cases but even slightly large case, I am getting stack overflow error. Is that normal?
I did not create the intermediate language in clojure yet, I just created the object and tried to convert.
I increased the stack memory, still I was not able to solve this.

SourceDataLine method not found

Wed, 22 Jan 2025 21:38:08 +0000

Hi, I've found some weird behaviour when attempting to play a sound using a javax.sound.sampled.SourceDataLine. The following code illustrates the problem:

(ns cljtest.core)
(import '[java.util Random]
        '[javax.sound.sampled AudioSystem AudioFormat])

; create an AudioFormat instance:
(def fmt (AudioFormat. 44100. 16 2 true false))

; create some data representing a second of white noise:
(def data (byte-array 176400))
(.nextBytes (Random.) data)

; define a function that creates a SourceDataLine and uses it to play a sound:
(defn play1 []
  (let [l (AudioSystem/getSourceDataLine fmt)]
    (.open l) (.start l) (.write l data 0 (count data))))

; define a function that creates a SourceDataLine and returns it:
(defn getline []
  (AudioSystem/getSourceDataLine fmt))

; define a function that uses the output of getline to play a sound:
(defn play2 []
  (let [l (getline)]
    (.open l) (.start l) (.write l data 0 (count data))))

Compiling this with Clojure 1.12.0 using Leiningen, play1 does what it's supposed to, but play2 gives me the following error:

Execution error (IllegalArgumentException) at cljtest.core/play2 (core.clj:24).
No matching method write found taking 3 args for class com.sun.media.sound.DirectAudioDevice$DirectSDL

I get this error using both OpenJDK 21.0.5.11-hotspot and Oracle's JDK 23. Also with Clojure 1.11.0 and 1.10.0, but 1.9.0 works fine. Anyone know why this is happening?

Java interop issue

Tue, 12 Nov 2024 19:25:31 +0000

Hi everyone,

Failing to make clojure work with our commercial java library. I can run the following Java code on my machine and it works fine:

import com.numerix.pro.Application;
import com.numerix.pro.ApplicationCall;
import com.numerix.pro.ApplicationData;
import com.numerix.pro.ApplicationObjectFactory;
import com.numerix.pro.ApplicationWarning;

public final class FxAmericanOption {

    public static void main(final String argv[]) 
    {
        int rVal = 0;      // exit value
        try {
            System.out.println("Running: " + new Throwable().getStackTrace()[0].getClassName() + "\n");

            final Application app = new Application();
            {
                final ApplicationCall call = new ApplicationCall();
                call.addValue("ID",       "USD_Curve");
                call.addValue("OBJECT",   "Curve");
                call.addValue("TYPE",     "Yield");
                call.addValue("Now Date", ApplicationObjectFactory.parseDate("26-Oct-2003"));
                call.addValue("CURRENCY", "USD");
                call.addValue("RATE",     0.04);

                final String[] outHeaders =
                    new String[] {"Updated", "Timer", "ID"};

                final ApplicationWarning warning = new ApplicationWarning();

                app.call(call, outHeaders, warning);

I tried porting it to clojure 1.12 like this

(ns hello
  (:import (com.numerix.pro Application ApplicationCall
                            ApplicationWarning 
                            ApplicationObjectFactory)))
           
(def myapp (new Application))
(def appcall (new ApplicationCall))
(def warning (new ApplicationWarning))

(.addValue ^ApplicationCall appcall "NAME" "Yield Curve")
(.addValue ^ApplicationCall appcall "ID" "MyCurve")
(.addValue ^ApplicationCall appcall "OBJECT" "Curve")
(.addValue ^ApplicationCall appcall "TYPE" "Yield")
(.addValue ^ApplicationCall appcall "Now Date" (ApplicationObjectFactory/parseDate "26-Oct-2023"))
(.addValue ^ApplicationCall appcall "CURRENCY" "USD")
(.addValue ^ApplicationCall appcall "RATE" 0.04)

(def outHeaders (into-array String ["timer" "id"]))

(^[ApplicationCall String/1 ApplicationWarning] Application/.call ^Application myapp
                                                                  ^ApplicationCall appcall
                                                                  ^String/1 outHeaders
                                                                  ^ApplicationWarning warning)

I can inspect appcall object and it looks totally fine - all the .addValue register correctly with it. But when I evaluate the last form with Application/.call I get an error which I don't understand how to address..

 Execution error (IllegalAccessError) at hello/eval10370 (REPL:25).
; failed to access class com.numerix.pro.ApplicationCommon from class hello$eval10370 (com.numerix.pro.ApplicationCommon is in unnamed module of loader 'app'; hello$eval10370 is in unnamed module of loader clojure.lang.DynamicClassLoader @cc01572)

Any help much appreciated!

Using integer parameters in deftype annotations

Sun, 30 Jun 2024 18:44:17 +0000

I am trying to use a Java library that uses annotations on Java classes and methods, so I pass to it deftypes with annotated methods. Some of the annotations require using integer parameters and it seems there is no convenient way to do this in Clojure. The code I am trying is something like this:

(deftype SomeType []
  (^{Retention RetentionPolicy/RUNTIME
     SomeAnnotationClass {:order 1} }
   someMethod [_]...))

The :order 1 part causes an exception:

Incorrectly typed data found for annotation element ... (Found data of type java.lang.Long[1])

This happens because the java library expects that :order would have a java.lang.Integer value, but Clojure creates a java.lang.Long. If I try (int 1) instead of 1, I get another exception.

I asked for help on clojurians Slack, and it was suggested that I use #java.lang.Integer[1] instead of simply 1. This works, but it would be nice to have a more intuitive way to do this.

Wrong implementation of IBlockingDeref for clojure.java.process/start

Tue, 25 Jun 2024 12:59:18 +0000

The IBlockingDeref for the reification in clojure.java.process/start is not implemented according to specification in deref doc-string.

The 3-arity IBlockingDeref expects timeout in milliseconds, and that the third argument is a timeout-val. The implementation in clojure.java.process (line 113, linked below) wrongly expects the two arguments to be a timeout with its unit specified in last argument as a java.util.concurrent.TimeUnit. When given some j.u.c.TimeUnit as timeout-val, it will still return nil after the timeout.

Expected: That this implementation of IBlockingDeref always assumes the timeunit to be hardcoded as TimeUnit/MILLISECONDS, and that the given timeout-val is returned if the deref to IBlockingDeref times out.

See clojure/java/process.clj#L113

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"]}

How to use the AWS S3 Java API v2 `S3Configuration`?

Tue, 26 Mar 2024 08:44:25 +0000

I want to turn this Java code into Clojure

S3Client.builder()
      .serviceConfiguration(S3Configuration.builder()
            .pathStyleAccessEnabled(true)
            .build())
      .build();

The Problem: .seviceConfiguration takes a java.util.function.Conumser.

default B serviceConfiguration(Consumer<S3Configuration.Builder> serviceConfiguration)

The .servcieConfiguration method is defined here AWS SDK serviceConfiguration

I tried to use reify without much luck.

Maybe someone can point me into the right direction, or has already used this specific part of the API.

And can someone tell me why, is an API design like this advantageous for Java Developers, what is the point of this Construct?

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

`resolve` should support array class symbols?

Fri, 09 Feb 2024 02:06:42 +0000

Clojure 1.12.0-alpha6 has introduced array class symbols, but it doesn't seem that resolve supports them right now:

(resolve 'long**) ;=> nil
(resolve 'String**) ;=> nil

It would be nice if resolve would be aware of array class symbols. Otherwise, it'd require extra work for some sorts of macros and development tools (that use resolve under the hood) to support them.

Do primitive type hints in fn arguments turns the return value as an Object?

Fri, 01 Dec 2023 18:42:52 +0000

Hi everyone,
I was playing around with java-interop and found this:

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

(import [java.util.concurrent ScheduledExecutorService Executors ScheduledFuture TimeUnit])

(defonce ^:private ^ScheduledExecutorService executor (Executors/newScheduledThreadPool 1))

(defn set-timeout-primitive ^ScheduledFuture [^long ms ^Callable f]
  (.schedule executor f ms TimeUnit/MILLISECONDS))

(defn set-timeout-object ^ScheduledFuture [^Long ms ^Callable f]
  (.schedule executor f ms TimeUnit/MILLISECONDS))

(.get (set-timeout-primitive 2000 (fn [] (println :done) :done))) ; Reflection warning, ... - reference to field get on java.lang.Object can't be resolved.
(.get (set-timeout-object 2000 (fn [] (println :done) :done))) ; No warnings

The reason for this reflection warning (thanks for explaining) seems to be that when the compiler looks for the matching interface it finds this:

static public interface OLOO{Object invokePrim(Object arg0, long arg1, Object arg2);}

So the return value becomes an Object and not a ScheduledFuture. But this doesn't happen when using a ^Long type hint instead of a ^long.

Could this be improved? Thank you!

Add support for context logging in tools.logging

Sun, 26 Nov 2023 16:21:19 +0000

Structured logging beats plain text.
Context logging + structured logging is a net win. At my workplace we could dump our ad-hoc logging solution which besides support for context logging is inferior to tools.logging, and will make a strong addition to the library's capabilities.
To add support for context logging, we'll probably need an additional protocol for the frameworks which implement such APIs (like SLF4J).
Not sure if it's required, but an additional logging function might also simplify the implementation.
Suggested usage:

(log/info-c {:foo "bar"} my-error "some message")

RT/chunkIteratorSeq does not produce a chunked-seq?

Thu, 16 Nov 2023 15:05:15 +0000

user> (def al (hamf/array-list (range 200))) 
#'user/al
user> (type al)
java.util.ArrayList
user> (chunked-seq? (seq al))
false
user> (instance? java.lang.Iterable al)
trueSyntax error reading source at (REPL:65:41).
Unmatched delimiter: )
user> (instance? java.lang.Iterable al)
true
user> (chunked-seq? (clojure.lang.RT/seq al))
false
user> (chunked-seq? (clojure.lang.RT/chunkIteratorSeq (.iterator al)))
false
user> (type (clojure.lang.RT/chunkIteratorSeq (.iterator al)))
clojure.lang.LazySeq

If no lazy seq is a chunked seq then the result of clojure.core/map, filter, etc. also cannot ever be a chunked seq as they are currently written. There are just a whole lot of questions here.

Seed support in java.util.Random

Wed, 30 Aug 2023 17:01:05 +0000

Is it possible to add additional arities for functions like rand, rand-int, rand-nth etc. to support seeds passed to the Java methods? It could also be nice to create other functions for more secure variants than java.util.Random, maybe SecureRandom? I really don't know what is most widely used so that's just an idea.

Request to find and eliminate virtual thread pinning

Thu, 01 Jun 2023 06:02:37 +0000

Asking this here because I can't post to https://clojure.atlassian.net/jira/software/c/projects/CLJ/issues/CLJ-2771.

I run a startup and we ran headlong into this synchronized block when using Java 19 virtual threads:

https://github.com/clojure/clojure/blob/4090f405466ea90bbaf3addbe41f0a6acb164dbb/src/jvm/clojure/lang/Delay.java#L35

This took significant engineering effort and sanity to debug, as -Djdk.tracePinnedThreads reported precisely nothing.

As it stands, we're needing to reimplement a virtual-thread-friendly (non-synchronized) clojure.core/delay, and as many clojure.core functions as we need to ensure virtual threads don't get pinned.

As always, I'm amazed by the Clojure team's work! Just wanted to highlight the virtual-thread-unfriendliness of some of its API and get it prioritized if possible, since virtual threads are extremely useful.

Thanks!

Odd performance penalty on numeric benchmark alleviated by going to doubles...

Tue, 10 Jan 2023 17:51:55 +0000

I happened across the performance benchmark here and I was curious why clojure was getting beaten by java.

So I tossed it into the profiler (after modifying their version to use unchecked math - which didn't help) and nothing shows up. hmm. decompile and find that

// Decompiling class: leibniz$calc_pi_leibniz
import clojure.lang.*;

public final class leibniz$calc_pi_leibniz extends AFunction implements LD
{
    public static double invokeStatic(final long rounds) {
        final long end = 2L + rounds;
        long i = 2L;
        double x = 1.0;
        double pi = 1.0;
        while (i != end) {
            final double x2 = -x;
            final long n = i + 1L;
            final double n2 = x2;
            pi += Numbers.divide(x2, 2L * i - 1L);
            x = n2;
            i = n;
        }
        return Numbers.unchecked_multiply(4L, pi);
    }

    @Override
    public Object invoke(final Object o) {
        return invokeStatic(RT.uncheckedLongCast(o));
    }

    @Override
    public final double invokePrim(final long rounds) {
        return invokeStatic(rounds);
    }
}

So looks like the double/long boundary is costing us at least a method lookup maybe in Numbers.divide?
So I just coerce everything to double (even our index variable):

(def rounds 100000000)

(defn calc-pi-leibniz2
  "Eliminate mixing of long/double to avoid clojure.numbers invocations."
  ^double
  [^long rounds]
  (let [end (+ 2.0 rounds)]
    (loop [i 2.0 x 1.0 pi 1.0]
      (if (= i end)
        (* 4.0 pi)
        (let [x (- x)]
          (recur (inc i) x (+ pi (/ x (dec (* 2 i))))))))))

leibniz=> (c/quick-bench (calc-pi-leibniz rounds))
Evaluation count : 6 in 6 samples of 1 calls.
             Execution time mean : 575.352216 ms
    Execution time std-deviation : 10.070268 ms
   Execution time lower quantile : 566.210399 ms ( 2.5%)
   Execution time upper quantile : 588.772187 ms (97.5%)
                   Overhead used : 1.884700 ns
nil
leibniz=> (c/quick-bench (calc-pi-leibniz2 rounds))
Evaluation count : 6 in 6 samples of 1 calls.
             Execution time mean : 158.509049 ms
    Execution time std-deviation : 759.113165 ╡s
   Execution time lower quantile : 157.234899 ms ( 2.5%)
   Execution time upper quantile : 159.205374 ms (97.5%)
                   Overhead used : 1.884700 ns
nil

Any ideas why the java implementation not paying the same penalty for division? [both versions are implemented with unchecked-math at :warn-on-boxed].

I also tried a variant with fastmath's primitive math operators and actually got slower. So far nothing has beaten coercing the loop index i into a double (which I would normally never do).

How to use local library from ~/.m2 directory

Mon, 09 Jan 2023 20:42:16 +0000

Hello, I am unable to find out how to import and use a library from my local ~.m2 directory using leiningen. I have installed [apache pdfbox 2.0.27] (https://pdfbox.apache.org/) using groupID 'deps' and artifactID 'pdfbox' and added it to my project.clj (until here everything seems to work fine as lein install does not complain). Now I am trying to import the pdmodel.PDDocument class as instructed here by supplying the :import option to the ns function. However, it doesn't seem to work, and I am unable to find documentation that works for me.

Should I import deps.pdfbox, or just pdfbox, and then for class import pdmodel, or pdmodel.PDDocument? Or, as this all does not seem to work, am I doing anything else wrong?

Anyone here has any advice? Thank you!

How to set environment variables to an interactive process spawned by ProcessBuilder?

Sun, 06 Nov 2022 14:15:47 +0000

I managed to get an interactive CLI working from: https://stackoverflow.com/questions/56541688/how-to-run-an-interactive-cli-program-from-within-clojure

but I also need to set the environment varibles, https://stackoverflow.com/questions/30574972/java-processbuilder-and-using-environment-variables suggests pb.environment().put("ENV", "val") so I think it should be (-> pb .environment (put. env val)):

(defn process-interactive-cli
  [args & [working-directory envs]]
  (let [process-builder (java.lang.ProcessBuilder. args)
        inherit (java.lang.ProcessBuilder$Redirect/INHERIT)
        environment (.environment process-builder)]
    ;; change CWD
    (when working-directory
      (.directory process-builder (io/file working-directory)))
    ;; set environment variables
    (for [[env val] envs]
      (.put environment env val))
    (.redirectOutput process-builder inherit)
    (.redirectError process-builder inherit)
    (.redirectInput process-builder inherit)
    ;; print the executing command (~ set -x)
    (apply println ">" args)
    (.waitFor (.start process-builder))))

But debugging this gives me:
1. Unhandled java.lang.IllegalArgumentException No matching method put found taking 2 args for class java.lang.ProcessEnvironment$StringEnvironment

Java method overloaded

Fri, 16 Sep 2022 01:07:57 +0000

I’m a newbie to Clojure. I want to call a Java method which is overloaded in Java, one has no parameter and the other has one parameter. I want to call the method with no parameter, but Clojure calls the method with one parameter and raise an IllegalArgumentException.

How can I call the Java method with no parameter from Clojure?

Could deftype allow for overriding methods?

Sat, 13 Aug 2022 16:52:31 +0000

Currently implementing a custom java.util.Iterator with the usual deftype form like

(deftype MyIterator []
  Iterator
  (hasNext [this]
    (my-custom-code))
  (next [this]
    (my-custom-code))
)

But I'd like to override the forEachRemaining default method on Iterator:

default void forEachRemaining(Consumer<? super E> action) {
    Objects.requireNonNull(action);
    while (hasNext())
        action.accept(next());
}

... with a more performant/specialized implementation. Perhaps I would even want to implement the by-default unimplemented remove:

default void remove() {
    throw new UnsupportedOperationException("remove");
}

But deftype does not allow for overriding methods. Is this a fundamental limitation or just something that hasn't been done (probably because Clojure predates default methods in java 8)? Anyways as a language whose philosophy is to embrace the the host, this would come in highly useful for using/integrating with java interfaces.

Runtime.Version nested class (JDK 9+) is not automatically imported?

Thu, 21 Jul 2022 07:05:07 +0000

In JDK 9 a new nested class Runtime.Version has been introduced.
However, I cannot use it without using the fully qualified name:

(Runtime$Version/parse (System/getProperty "java.version"))
Syntax error compiling at ...
No such namespace: Runtime$Version

;; fully qualified name works
(java.lang.Runtime$Version/parse (System/getProperty "java.version"))
#object[java.lang.Runtime$Version 0x39a4ea03 "11.0.2"]

Is this intended?
I quickly tried this with another (private) nested class and it's the same behavior:

String$CaseInsensitiveComparator
Syntax error compiling ...
Unable to resolve symbol: String$CaseInsensitiveComparator in this context

The Java Interop reference says that nested classes can be accessed as Classname$NestedClassName and doesn't mention this issue specifically.
It does look a bit inconsistent to me.

To be fair, I can still import the nested class and use it - but this is something I didn't expect I had to do:

(import 'java.lang.Runtime$Version)
(Runtime$Version/parse (System/getProperty "java.version"))
#object[java.lang.Runtime$Version 0x781187fa "11.0.2"]

Why does identical? treat let-bound ##NaN differently from direct reference to it?

Tue, 14 Jun 2022 14:13:39 +0000

Consider the following code snippets evaluated with Clojure 1.11.1:

;; example 1
user=> (identical? Double/NaN Double/NaN)
false

;; example 2
user=> (let [x Double/NaN] (identical? x x))
false

;; example 3
user=> (identical? ##NaN ##NaN)
true

;; example 4
user=> (let [x ##NaN] (identical? x x))
false

Why does example 3 return true when all the other examples return false? Is this the intended behavior?

I assume this has something to do with with how Clojure sometimes uses unboxed math.

In my mental model for Clojure, identical? is basically Java's == and ##NaN is Java's Double.NaN. In Java, Double.NaN == Double.NaN evaluates to false. Thus I expected all the examples to return false.

Could realized? support Java futures?

Sat, 28 May 2022 07:16:15 +0000

I'm running into a situation where I would need to mix CompletableFutures in with Clojure futures/delays/etc. Unfortunately, IPending is an interface, which can't be extended to Java core classes.

For IDeref and IBlockingDeref, it's not a problem working with Java Futures, because the deref fn supports them.

Couldn't the same be done with the realized? fn? Currently, it only works with IPending. It would be ideal if it matched the deref behavior and called .isDone() when given a java.util.concurrent.Future.

Why isn't there type inference for self-evident cases?

Thu, 05 May 2022 08:49:55 +0000

I often find myself addressing reflection warnings by placing annotations which type is completely obvious:

(def ^String foo "bar") ;; adding ^String fixes reflection warnings elsewhere

"bar" is a String, that is unmistakably known at compile-time, so it seems to me that I'm doing grunt work, and also creating something that might become outdated later.

Has it been considered to add "type inference" for such straightforward cases?

("type inference" is probably an exaggerated term for this use case)

...I can imagine at least one objection: (def ^CharSequence foo "bar") can also be accurate and useful. But a good default would be to infer the type of x to be the x's class - if a user wanted to annotate x as one of its ancestors (here: CharSequence, Object), he could override the inferred default by hand.

Pesky loop bug resulting in 0xFFFFFFFF with BufferedReader (java interop)

Sun, 26 Dec 2021 13:20:55 +0000

Hello --

I'm learning Clojure and its Java interop stuff. I am trying to emulate this function:

 public String readAllCharsOneByOne(BufferedReader bufferedReader) throws IOException {
    StringBuilder content = new StringBuilder();
       
    int value;
    while ((value = bufferedReader.read()) != -1) {
        content.append((char) value);
    }
       
    return content.toString();
}

So far, I've been able to reason that the parts I need are:

(def myfile "/path/to/svenska_sample.txt")
(import java.io.BufferedReader)
(import java.io.FileReader)
(import java.lang.StringBuilder)
(import java.lang.Character)
 
(def a-FileReader (FileReader. myfile))
(def bufferedReader (BufferedReader. a-FileReader))
(def content (StringBuilder.))

which works

user> (.append content (Character/toChars (.read bufferedReader)))
#object[java.lang.StringBuilder 0x490447d0 "\nDe"]
user> (.append content (Character/toChars (.read bufferedReader)))
#object[java.lang.StringBuilder 0x490447d0 "\nDen"]
user> (.append content (Character/toChars (.read bufferedReader)))
#object[java.lang.StringBuilder 0x490447d0 "\nDen "]
user> (.append content (Character/toChars (.read bufferedReader)))
#object[java.lang.StringBuilder 0x490447d0 "\nDen t"]
user> (.append content (Character/toChars (.read bufferedReader)))
#object[java.lang.StringBuilder 0x490447d0 "\nDen ty"]
user> (.append content (Character/toChars (.read bufferedReader)))
#object[java.lang.StringBuilder 0x490447d0 "\nDen typ"]
user> (.append content (Character/toChars (.read bufferedReader)))
#object[java.lang.StringBuilder 0x490447d0 "\nDen typi"]

The file is a small text file UTF-8 encoded in Linux with the following content:

❯ cat svenska_sample.txt

Den typiska impulsiva olycksfågeln är en ung man som kraschar flera bilar, och ofta skryter lite med det, i varje fall när han är tillsammans med sina vänner._. För dem har otur i det närmaste blivit en livsstil, och de råkar konstant ut för olyckor, stora som små. Olycksfåglar kallar vi dem. Hur många det finns kan ingen med säkerhet säga, för det finns inga konkreta definitioner på denna grupp, och heller ingen given avgränsning av den. Att de finns, råder det emellertid ingen tvekan om, varken på sjukhusens akutmottagningar eller i försäkringsbranschen

I wrote a function, with my brand new Clojure Java interop chops, that looks like this:

;; COMPILES  - BUT CAN'T GET AROUND THE 0XFFFFFFF BUG
(defn pt%% [file]
   (let [afr (FileReader. file); instances of FileReader, BufferedReader, StringBuffer
         bfr (BufferedReader. afr)
         ct (StringBuilder.)
         val (.read bfr)
         this-list (list afr bfr ct)]
         ; (apply println this-list)
         (loop []
               (when (not (= val -1))
                 (.append ct (Character/toChars (.read bfr))))
               (recur))
                ; when finished...
         (.toString ct)))

but it borks with the following error:

user> (pt%% myfile)
Execution error (IllegalArgumentException) at java.lang.Character/toChars (Character.java:8572).
Not a valid Unicode code point: 0xFFFFFFFF

What in the world could be causing this (NOTE: I am not a Java programmer)?
Here is the hex dump of the file text file:

❯ cat svenska_sample.hexdump

00000000: 0a44 656e 2074 7970 6973 6b61 2069 6d70  .Den typiska imp
00000010: 756c 7369 7661 206f 6c79 636b 7366 c3a5  ulsiva olycksf..
00000020: 6765 6c6e 20c3 a472 2065 6e20 756e 6720  geln ..r en ung
00000030: 6d61 6e20 736f 6d20 6b72 6173 6368 6172  man som kraschar
00000040: 2066 6c65 7261 2062 696c 6172 2c20 6f63   flera bilar, oc
00000050: 6820 6f66 7461 2073 6b72 7974 6572 206c  h ofta skryter l
00000060: 6974 6520 6d65 6420 6465 742c 2069 2076  ite med det, i v
00000070: 6172 6a65 2066 616c 6c20 6ec3 a472 2068  arje fall n..r h
00000080: 616e 20c3 a472 2074 696c 6c73 616d 6d61  an ..r tillsamma
00000090: 6e73 206d 6564 2073 696e 6120 76c3 a46e  ns med sina v..n
000000a0: 6e65 722e 5f2e 2046 c3b6 7220 6465 6d20  ner._. F..r dem
000000b0: 6861 7220 6f74 7572 2069 2064 6574 206e  har otur i det n
000000c0: c3a4 726d 6173 7465 2062 6c69 7669 7420  ..rmaste blivit
000000d0: 656e 206c 6976 7373 7469 6c2c 206f 6368  en livsstil, och
000000e0: 2064 6520 72c3 a56b 6172 206b 6f6e 7374   de r..kar konst
000000f0: 616e 7420 7574 2066 c3b6 7220 6f6c 7963  ant ut f..r olyc
00000100: 6b6f 722c 2073 746f 7261 2073 6f6d 2073  kor, stora som s
00000110: 6dc3 a52e 204f 6c79 636b 7366 c3a5 676c  m... Olycksf..gl
00000120: 6172 206b 616c 6c61 7220 7669 2064 656d  ar kallar vi dem
00000130: 2e20 4875 7220 6dc3 a56e 6761 2064 6574  . Hur m..nga det
00000140: 2066 696e 6e73 206b 616e 2069 6e67 656e   finns kan ingen
00000150: 206d 6564 2073 c3a4 6b65 7268 6574 2073   med s..kerhet s
00000160: c3a4 6761 2c20 66c3 b672 2064 6574 2066  ..ga, f..r det f
00000170: 696e 6e73 2069 6e67 6120 6b6f 6e6b 7265  inns inga konkre
00000180: 7461 2064 6566 696e 6974 696f 6e65 7220  ta definitioner
00000190: 70c3 a520 6465 6e6e 6120 6772 7570 702c  p.. denna grupp,
000001a0: 206f 6368 2068 656c 6c65 7220 696e 6765   och heller inge
000001b0: 6e20 6769 7665 6e20 6176 6772 c3a4 6e73  n given avgr..ns
000001c0: 6e69 6e67 2061 7620 6465 6e2e 2041 7474  ning av den. Att
000001d0: 2064 6520 6669 6e6e 732c 2072 c3a5 6465   de finns, r..de
000001e0: 7220 6465 7420 656d 656c 6c65 7274 6964  r det emellertid
000001f0: 2069 6e67 656e 2074 7665 6b61 6e20 6f6d   ingen tvekan om
00000200: 2c20 7661 726b 656e 2070 c3a5 2073 6a75  , varken p.. sju
00000210: 6b68 7573 656e 7320 616b 7574 6d6f 7474  khusens akutmott
00000220: 6167 6e69 6e67 6172 2065 6c6c 6572 2069  agningar eller i
00000230: 2066 c3b6 7273 c3a4 6b72 696e 6773 6272   f..rs..kringsbr
00000240: 616e 7363 6865 6e0a                      anschen.

I then changed the code (see below), because of some suggestions that the problem might be my use of recur.

And now it complains that a previous form that was working '(.append etc..') doesn't and the same error remains.

user> (pt5 myfile)

Execution error (IllegalArgumentException) at java.lang.Character/toChars (Character.java:8572).
Not a valid Unicode code point: 0xFFFFFFFF

(defn pt5 [file]

   (let [afr (FileReader. file); instances of FileReader, BufferedReader, StringBuffer
         bfr (BufferedReader. afr)
         ct (StringBuilder.)
         this-list (list afr bfr ct)]
         ; (apply println this-list)
         (loop [val (.read bfr)]
               (when (not (= val -1))
                 (.append ct (Character/toChars (.read bfr))))
               (recur val))
                ; when finished...
                (.toString ct)))

Harder then it seemed at first sight...
Any help is greatly appreciated.`
-- Hank

The clojure `rand-int` method seems to be 4 times slower than its java counterpart `java.util.Random.nextInt()`

Fri, 04 Jun 2021 09:12:42 +0000

Check the below gist to see detailed results.

Note that using interop is ok for me,
I am in an operations research use case where time consumption of random value is important.

But I wonder why clojure should not propose a better version of rand-int.

I suspect (but I will check if needed) that the nextInt version may be more uniform (statistically closer from the theory).

PS: Duplicate from a question in slack, channel clojure.

Unable to run Clara Rules from Java

Sat, 29 May 2021 12:17:53 +0000

Im beginning to learn Clara Rules and wanted to execute them from Java. I'm getting an error when trying to run the code. ExceptionInInitializerError: Syntax error compiling at (example/shopping.clj:2:3). clara.rules.accumulators. I'm attaching the project source for your reference. Could you please help. Please install Maven. Go to your project root directory and to compile the project execute mvn -q compile To run the code mvn -q exec:java -Dexec.mainClass=example.ClaraExampleMain

SourceCode to the project

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.

Apparently uncallable method overload

Mon, 08 Mar 2021 19:53:18 +0000

Google Guava 30.1 defines these two addAll overloads for TreeRangeSet:

public void TreeRangeSet.addAll(RangeSet)
public default void RangeSet.addAll(Iterable<Range>)

The following compiles without error or warning:

(import [com.google.common.collect Range RangeSet TreeRangeSet])

(defn example []
  (let [container (TreeRangeSet/create)
        temp (TreeRangeSet/create ^Iterable (list (Range/closed 1 2)))]
     (.addAll container ^RangeSet temp)))

However, calling example fails with a runtime error stating that TreeRangeSet does not implement Iterable. As I understand it, this error happens because the Clojure compiler has emitted a call to the second overload (despite the type hint). After some experimenting, I believe this happens because the first overload returns true for isBridge; Reflector.getMethods will not return it since the second overload is not a bridge method.

So two questions: is there a way to generate a call to the first overload, and, if not, should there be?

(By the way, in initializing temp above, I wanted to use:

(let [temp (TreeRangeSet/create ^Iterable [(Range/closed 1 2)])

but this generates a reflection warning. I belive it is an example of CLJ-1929.)

Problems loading ffmpeg library with jna

Sat, 30 Jan 2021 18:03:48 +0000

Hi, I have a problem trying to call a C library using JNA (on a windows platform, using vscode).

I grabbed a copy of the ffmpeg shared libraries from: https://www.gyan.dev/ffmpeg/builds/
specifically: https://www.gyan.dev/ffmpeg/builds/ffmpeg-release-full-shared.7z

I took the contents of the bin sub-directory and put it in the 'lib' directory of my clojure project. I also added this directory to my path and could happily call the ffmpeg app.

Here is the contents of my deps.edn:

{:deps
 {net.java.dev.jna/jna   {:mvn/version "5.6.0"}}
 :paths ["src" "lib"]
 }

And here is the code:

 (ns jnatest)

(import (com.sun.jna  Native Pointer))

(gen-interface
 :name jna.lib_avformat
 :extends [com.sun.jna.Library]
 :methods [[avformat_alloc_context [] Pointer]])

(def avformat
  (Native/loadLibrary "avformat-58" jna.lib_avformat))

On the the call to Native/loadLibrary I get the error:

; Execution error (UnsatisfiedLinkError) at com.sun.jna.Native/open (Native.java:-2).
; %1 is not a valid Win32 application.

I initially started with the techascent jna implementation, https://clojars.org/techascent/tech.jna, and had similiar issues, so I went back to basics.

I'm guessing it's something wrong with the libraries, but before I start recompiling all the ffmpeg libraries I thought I'd ask if there might be something simple to try.

Any hints appreciated.

Fails to load gen-classed class with pf4j from uberjar

Tue, 26 Jan 2021 16:23:57 +0000

The problem here might be more related to the pf4j default classloader but still:

I have a clojure plugin generating a class

(gen-class
 :name myplugin.SomeExtension
 :implements [plugin.SomeExtensionPoint]
 :prefix "-"
 :impl-ns my-plugin.some-extension)

The plugin jar is loaded in my clojure application using pf4j. When it is compiled with lein jar the class loads (but then I naturally have to put any plugin dependencies in the apps project.clj). When compiled with lein uberjar it fails with:

 Execution error (IllegalStateException) at myplugin.SomeExtension/<clinit> (REPL:-1).
; Attempting to call unbound fn: #'clojure.core/refer

with top of call stack

jdk.internal.reflect.NativeConstructorAccessorImpl/newInstance0 (NativeConstructorAccessorImpl.java:-2)
jdk.internal.reflect.NativeConstructorAccessorImpl/newInstance (NativeConstructorAccessorImpl.java:62)
jdk.internal.reflect.DelegatingConstructorAccessorImpl/newInstance (DelegatingConstructorAccessorImpl.java:45)
java.lang.reflect.Constructor/newInstance (Constructor.java:490)
java.lang.Class/newInstance (Class.java:584)
org.pf4j.DefaultExtensionFactory/create (DefaultExtensionFactory.java:38)
org.pf4j.ExtensionWrapper/getExtension (ExtensionWrapper.java:37)
org.pf4j.AbstractPluginManager/getExtensions (AbstractPluginManager.java:971)

I've struggled a bit but I am unsure about exactly what happens here and how to solve it?
Any ideas are most welcome!

(and the uberjar profile uses {:aot :all :omit-source true})

How to invoke native C-functions in Clojure via JNR-FFI?

Fri, 04 Dec 2020 13:57:56 +0000

Hi Everyone,

I want to call native functions in a C-Library from Clojure via JNR-FFI without having to write Java code.

(defproject mypkg
	:dependencies [[org.clojure/clojure "1.10.1"]
				   [com.github.jnr/jnr-ffi "2.2.0"]])

Based on the jnr-ffi examples here and here a Java wrapper might look like

package blahblah;

public class BlahNative {
	private static int[] intDummy;
	private static double[] doubleDummy;

	public BlahNative() {
	}

	public static native void native_a(char var0, char var1, int var2, int var3, int var4, double[] var7, int var8, int var9);

	public static native void native_b(char var0, char var1, int var2, int var3, int var4, double[] var7, int var8, int var9);

	static {
		lib = LibraryLoader
            .create(LibSodium.class)
            .search("/usr/local/lib")
            .search("/opt/local/lib")
            .search("/usr/lib")
            .search("/lib")
            .load(LIBRARY_NAME);
        initializeLibrary(lib);
    }
}

I presume my Clojure namespace should use the gen-class feature for implementing Java classes.

(ns mypkg.native
	(:import [jnr.ffi LibraryLoader])
	(:import [jnr.ffi.annotations IgnoreError])
	(:import [jnr.ffi.provider FFIProvider])
    (:gen-class))

Then,

How do I write a native method in Clojure? In other words, do I even need to specify the method type (as native) when using Clojure's Java interop features?
After loading the native library I do not know how to access the C-functions in the library. How do I do it?
To avoid reloading the library for every Clojure wrapper function of each C-functions, can I write a method like

(defn lib (. LibraryLoader load LIBRARY_NAME))

and then access the native functions in it?

I am neither a C nor a Java expert so any guidance will be much appreciated.

Thanks.

Could not initialize class javafx.stage.Screen

Tue, 22 Sep 2020 23:24:10 +0000

I've been trying to use javafx.stage.Screen to capture my screen dimensions. following java documentations
here is what I wrote

(import javafx.stage.Screen)
(Screen/getPrimary)

I get the following error

Execution error (NoClassDefFoundError) at user/eval194 (REPL:1).
Could not initialize class javafx.stage.Screen

I tried using the fully qualified named and using the dot special form but I get the same error. in the docs the class screen has no constructor so I don't think I need make new instance.
java version: 1.8.0_261
repl : clj 1.10.0.442
command line: powershell 5.1.17763.1432

any idea why this happens?

Why does bit-shift-left rotate bits instead of discarding bits?

Mon, 03 Aug 2020 05:35:41 +0000

(bit-shift-left 0xfffffff0 4) returns 0xffffff0f, while I expect it to be 0xffffff00. Similarly, (bit-shift-left 0xfffffff0 8) returns 0xfffff0ff, etc.

I checked the implementation, and bit-shift-left casts all its arguments to Long, then invokes Java's << operator, which should discard higher bits instead of rotate them.

What static type is needed to fix this "Illegal reflective access"?

Wed, 10 Jun 2020 02:24:56 +0000

Attempting to get the length of a Unicode string, I found this code on RosettaCode [1] called grapheme-length :

(def grapheme-length
  #(->> (doto (BreakIterator/getCharacterInstance)
          (.setText %))
        (partial (memfn next))
        repeatedly
        (take-while (partial not= BreakIterator/DONE))
        count))

I invoked it from the REPL to test it like this:

(star-traders.util/grapheme-length "\uD83D\uDE04⌘\uD83D\uDE00") ; Expecting 3

While it did return the expected value, I also got an unexpected warning in red text asking me to "consider reporting this to the maintainers of clojure.lang.InjectedInvoker"...

WARNING: An illegal reflective access operation has occurred
WARNING: Illegal reflective access by clojure.lang.InjectedInvoker/0x0000000800cc8440 (file:/Users/myusername/.m2/repository/org/clojure/clojure/1.10.1/clojure-1.10.1.jar) to method sun.text.RuleBasedBreakIterator.setText(java.text.CharacterIterator)
WARNING: Please consider reporting this to the maintainers of clojure.lang.InjectedInvoker/0x0000000800cc8440
WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations
WARNING: All illegal access operations will be denied in a future release

Apparently this is a known issue with the JVM due to the addition of the Java 9 module system and is mentioned in the Clojure FAQ. [2]

While the problem does go away if --illegal-access=deny is added to the JVM Args, it appears that the recommended solution is to fix the code with type hinting.

I've tried using --illegal-access=warn to locate the spot and fix it, like this:

          (.setText ^java.text.BreakIterator %)) ; Problem happens here (I think)

However, the problem still occurs, and this has me curious what the right type I should be using is.

How do I fix the code to get rid of the compiler warning, rather than suppress warnings?

[1] https://rosettacode.org/wiki/String_length#Grapheme_Length_2
[2] https://clojure.org/guides/faq#illegal_access

Reading serialized Java Objects in Clojure

Fri, 05 Jun 2020 14:04:33 +0000

Hello everyone,

I have a lot of Java Serialized Objects I wish to inspect and transform.

I tried using the naive Java-in-Clojure way to do the following:
(Excuse the iterative style, I'm usually never interfacing with Java directly and it's also a language I'm relatively unfamiliar with, but this doesn't seem to have a clojuristic wrapper.

file that contains object: input.ser

(import '[java.io FileInputStream ObjectInputStream])
(def fis (new FileInputStream "input.ser"))
(def ois (new ObjectInputStream fis)

(.readObject ois) ;; this fails due to a ClassNotFoundException

Is there a way to get the sort-of Deserialized View of the object that I can inspect after loading? The file itself is unreadable because it compresses the bytes before serializing.

How to call java method with interface as parameters?

Fri, 08 May 2020 04:37:31 +0000

Here's my sample code.
Thanks.

// Java code
interface IFace {
  String message();
}
class A implements IFace {
  @Override message () { return "Hello A!"};
}
class B implements IFace {
  @Override message () { return "Hello B!"};
}
class PrintHello {
  static void print (IFace msg) {
    if (msg instanceof A) { ... } else { ... }
  }
}

; Clojure code

(def a (A.))
(. PrintHello (print a))

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.