Clojure Q&A - Recent questions and answers in Java Interop

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.

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

Tue, 13 Jan 2026 19:06:31 +0000

Created jira and patch at https://clojure.atlassian.net/browse/CLJ-2936

Answered: Could we get deref support on ScopedValue?

Tue, 25 Nov 2025 20:00:22 +0000

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

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

Mon, 24 Nov 2025 20:55:02 +0000

Probably tough to make it a protocol now, especially with backward compiled compatibility.

It would be best to vote on the question for Optional to voice your opinion there - we look at higher voted things with more urgency.

ScopedValue is only available non-preview in 25, so pretty new still. would probably be best to file an Ask question specifically about that so it can gather votes.

LazyConstant is not a thing yet, so will be a long while probably.

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=>

Answered: Refection warning even with type hinting

Fri, 11 Jul 2025 15:13:01 +0000

You could type hint the target (which is what the warning is about, not the argument types):

user=> (type *err*)
java.io.PrintWriter
user=> (.println ^java.io.PrintWriter *err* "foo")
foo
nil

I suspect this is because *err* is a dynamically bound var so the compiler doesn't know its type, even tho' the bound value is java.io.PrintWriter.

You could also use the new-in-1.12 qualified method access, to avoid the warning:

user=> (set! *warn-on-reflection* true)
true
user=> (.println *err* "foo")
Reflection warning, NO_SOURCE_PATH:1:1 - call to method println can't be resolved (target class is unknown).
foo
nil
user=> (import 'java.io.PrintWriter)
java.io.PrintWriter
user=> (PrintWriter/.println *err* "foo")
foo
nil

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

Sat, 05 Jul 2025 22:28:50 +0000

This is a known issue with reflection (it's actually not entirely deterministic - both methods match and either may get chosen depending on the JVM and other factors).

The important takeaway is that you are leaving the choice to reflection rather than making it explicit. If you use (set! *warn-on-reflection* true) you should see a warning here.

You can use either a type hint (AIMesh/create ^long pointer) or an explicit coercion (AIMesh/create (long pointer)) or param-tags metadata (^[long] AIMesh/create pointer) to remove the ambiguity. You should see the warning go away if it's working.

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

Mon, 30 Jun 2025 13:46:55 +0000

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

Answered: Default Imports Don't Include Clojure Internals

Tue, 24 Jun 2025 14:20:25 +0000

Well, where do you stop? Only Rich could tell you but I assume he was experimenting and decided that "where to stop" was with java.lang.

Answered: Idiomatic way to use java.util.Optional

Mon, 07 Apr 2025 14:31:43 +0000

Logged enhancement at https://clojure.atlassian.net/browse/CLJ-2905

Answered: Using java.data

Wed, 02 Apr 2025 16:37:21 +0000

Since you're a beginner I'll mentioned right off the bat the #beginners channels on both Clojurians Zulip and Clojurians Slack. They allow for a much better interactivity with the community when you need help with something.

Your description lacks important details. Ideally, there should be an MRE (Minimal Reproducible Example) which shows what you want to achieve, what you currently have, and what doesn't work.
Since I don't know what your Java classes look like, what your modification to clojure.java.data is exactly, how you use the resulting data, I can't really help here. So at the very least, just those things should be shown.

clojure.java.data has both from-java and from-java-deep. The former recurses only for Iterable, but even there it uses for so it "escapes" the recursion and should not lead to a stack overflow. from-java-deep does use a proper recursion, so it's bound to hit SO on specific data types that are nested deeply enough.

Answered: SourceDataLine method not found

Wed, 22 Jan 2025 21:51:06 +0000

I suspect the latter case is using reflection (because you've lost the interface return type of getSourceDataLine), and you are thus searching the concrete class for the method, which may not be accessible due to module visibility.

If so, you could try:

(defn getline ^javax.sound.sampled.SourceDataLine []
  (AudioSystem/getSourceDataLine fmt))

That flows the interface type into play2 where it should be able to make the same calculation as in play1.

BTW, you might find doto could simplify that code in the play methods.

Answered: Java interop issue

Tue, 12 Nov 2024 22:12:25 +0000

Can you do (pst *e) and provide that too? It's complaining about ApplicationCommon class which does not seem accessible from Clojure's classloader. That class doesn't show up in your code so I'm not sure how/why it's needed but might be something classloader related.

Answered: Using integer parameters in deftype annotations

Mon, 01 Jul 2024 13:52:52 +0000

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

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

Fri, 28 Jun 2024 13:47:27 +0000

Thanks! Logged as https://clojure.atlassian.net/browse/CLJ-2865 - we will get that fixed before 1.12 release.

Answered: Request: def should infer type tag where possible

Fri, 17 May 2024 22:25:38 +0000

the last time I recall some discussion about this, I think rhickey rejected it because vars are mutable and type hints effect compilation, so if if you type hint a var as some type X later code will be compiled to depend on it, and won't be recompiled if you change the hinted type (which would be more likely to happen if the hint was automatic). so hints on vars are opt in not opt out.

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

Tue, 26 Mar 2024 11:36:14 +0000

Given the Java code, the .build() method on the third line must also return an instance of Consumer. So there's no need to reify anything, you should be able to use this:

(let [consumer (-> (S3Configuration/builder) (.pathStyleAccessEnabled true) (.build))]
  (-> (S3Client/builder) (.seviceConfiguration consumer) (.build)))

This pattern, where you create a builder, call a bunch of configuration methods on it, and then call .build to get the final object that you actually need, is called a... "builder". :) In the OOP world, it's quite helpful when you want to ensure encapsulation and that there are no partially built objects. It can also help in cases where you need to have multiple different builder using the same interface that behave differently. Or in cases where you have to separate creation of an object across different contexts.

Answered: Why can't I type hint these floats?

Thu, 15 Feb 2024 19:06:34 +0000

Copying my answer from SO below.

You can't. The error is quite clear. Even this fails:

user=> (defn f [^float x])
Syntax error (IllegalArgumentException) compiling fn* at (REPL:1:1).
Only long and double primitives are supported

You can still use unboxed doubles. If that doesn't work for you, it might be better to implement this particular part in Java.

Answered: `resolve` should support array class symbols?

Fri, 09 Feb 2024 02:52:55 +0000

I'm not sure that resolve should work for this as it's really about looking things up in the namespace mappings. We'll talk about it though, thanks.

This was logged as https://clojure.atlassian.net/browse/CLJ-2832

Answered: RT/chunkIteratorSeq does not produce a chunked-seq?

Tue, 19 Dec 2023 01:38:11 +0000

Created CLJ-2821 to track this issue.

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

Fri, 01 Dec 2023 19:33:25 +0000

This happens because when the compiler converts a VarExpr invocation into an invokePrim expression, it loses the type hint from the arglist. I already have a patch for this if this gets converted into a JIRA ticket.

Answered: Add support for context logging in tools.logging

Sun, 26 Nov 2023 17:04:35 +0000

We ported to strcutrued logging with Markers, as wrote here: https://stackoverflow.com/a/60101309/8162407

with a thin wrapper on clojure.tools.logging. really happy with it. Upvoting.

Answered: Request to find and eliminate virtual thread pinning

Sat, 21 Oct 2023 19:41:59 +0000

Clojure 1.12.0-alpha5 is now available and modifies lazy-seq and delay to use locks instead of synchronized.

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.

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

Tue, 10 Jan 2023 18:46:08 +0000

I won't have time to take a look at this for a while, but it is pretty easy to fall into boxing at the loop/recur boundary which will cause substantial slowdowns, but it's easiest to tell for sure by looking at the bytecode.

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!

Answered: Cannot resolve public generic method from package-private base class

Fri, 16 Dec 2022 10:39:39 +0000

Here is another example of code that works for Java but fails on Clojure. The example class comes from the [org.opensearch.client/opensearch-java "2.1.0"] library.

This Java code works without problems:

package example;

import org.opensearch.client.opensearch.core.bulk.IndexOperation;

import java.io.IOException;
import java.util.Map;

public class Example {
    public static void main(String[] args) throws IOException {
        new IndexOperation.Builder<Map<?, ?>>()
                .index("test-index")
                .id("test-id")
                .document(Map.of("test-document", 123))
                .build();
    }
}

But the Clojure version cannot be written using Java interop. The workaround is to manually use reflection to call those methods:

(ns example
  (:import (org.opensearch.client.opensearch.core.bulk IndexOperation$Builder)))

(defn bug []
  (-> (IndexOperation$Builder.)
      (.index "test-index")
      (.id "test-id")
      (.document {"test-document" 123})
      (.build)))

(defn workaround []
  (let [bulk-builder-index (-> (Class/forName "org.opensearch.client.opensearch.core.bulk.BulkOperationBase$AbstractBuilder")
                               (.getDeclaredMethod "index" (into-array Class [String])))
        bulk-builder-id (-> (Class/forName "org.opensearch.client.opensearch.core.bulk.BulkOperationBase$AbstractBuilder")
                            (.getDeclaredMethod "id" (into-array Class [String])))]
    (-> (IndexOperation$Builder.)
        ^IndexOperation$Builder ((fn [builder index]
                                   (.invoke bulk-builder-index builder (into-array Object [index])))
                                 "test-index")
        ^IndexOperation$Builder ((fn [builder id]
                                   (.invoke bulk-builder-id builder (into-array Object [id])))
                                 "test-id")
        (.document {"test-document" 123})
        (.build))))

(comment
  (bug)
  (workaround))

When this namespace is loaded with Clojure 1.11.1, it gives the following reflection warnings:

Reflection warning, .../example.clj:6:7 - call to method index on org.opensearch.client.opensearch.core.bulk.IndexOperation$Builder can't be resolved (argument types: java.lang.String).
Reflection warning, .../example.clj:7:7 - call to method id can't be resolved (target class is unknown).
Reflection warning, .../example.clj:8:7 - call to method document can't be resolved (target class is unknown).
Reflection warning, .../example.clj:9:7 - reference to field build can't be resolved.

And when the bug function is executed, it fails with the exception:

Execution error (IllegalArgumentException) at example/bug (example.clj:6).
Can't call public method of non-public class: public final org.opensearch.client.opensearch.core.bulk.BulkOperationBase$AbstractBuilder org.opensearch.client.opensearch.core.bulk.BulkOperationBase$AbstractBuilder.index(java.lang.String)

IndexOperation$Builder is a public class, which extends the protected abstract class WriteOperation$AbstractBuilder, which extends the protected abstract class BulkOperationBase$AbstractBuilder. The index and id methods' return type is a class-level type parameter, but the method arguments are non-generic.

Here are the relevant places in the library code:

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

Sun, 06 Nov 2022 15:49:16 +0000

In the inline code, replace (put. env val) with (.put env val).

In the code block, replace for with doseq.

But that won't solve the exception. It seems like you're hitting either https://clojure.atlassian.net/browse/CLJ-1243 (even though the description is not entirely the same, the root cause might be) or something very similar, and I can also reproduce it.

In order to fix it, add a type annotation: (.put ^java.util.Map environment env val).

Answered: Java method overloaded

Fri, 16 Sep 2022 17:40:29 +0000

user=> (vec (.getBytes "ᵶ" "latin1"))
[63]
user=> (vec (.getBytes "ᵶ"))
[-31 -75 -74]
user=>

If you don't pass an argument then clojure will call the one that doesn't take an argument.

Answered: Could deftype allow for overriding methods?

Thu, 18 Aug 2022 21:15:52 +0000

Did you actually try this? Because it seems to work for me now.

(deftype MyIterator []
  java.util.Iterator
  (hasNext [this] false)
  (next [this] 0)
  ;; try to override default method
  (remove [this] (println "boo")))

(.remove (MyIterator.))
;; boo

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

Wed, 27 Jul 2022 13:52:46 +0000

You can see the list of default imports here: https://github.com/clojure/clojure/blob/clojure-1.11.1/src/jvm/clojure/lang/RT.java#L39

I only see 2 nested classes: Thread$UncaughtExceptionHandler and Thread$State

It's static so I guess it should only include classes that are available in every supported java versions.

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

Tue, 14 Jun 2022 19:29:03 +0000

Okay, my mental model of identical? is not accurate. It calls clojure.lang.Util/identical which has the following implementation:

static public boolean identical(Object k1, Object k2){
    return k1 == k2;
}

When Clojure calls a function with such signature, it has to box the primitive values in the arguments. Doubles are boxed by calling Double.valueOf(double). The unusual equality semantics of NaN make the examples confusing, but in every case, identical? compares the reference equality of boxed values, not numerical equality.

By looking at disassembled byte code (see below), we can see what's happening. Here's summary.

In examples 1, 2, and 4, each of the arguments to identical? is boxed individually.
In example 3, ##NaN is boxed only once and the same boxed value is used as the both arguments of identical?.

Here are a few more examples. Note that the behavior of ##Inf matches that of ##NaN.

(identical? ##Inf ##Inf)          ; true
(let [x ##Inf] (identical? x x))  ; false

(identical? 1.0 1.0)              ; false
(let [x 1.0] (identical? x x))    ; false

(def my-one 1.0)
(identical? my-one my-one)        ; true

Conclusion

Everything works as it should. My mental model about identical? was wrong. It's more like (Object)... == (Object) ... than plain ==.

Lesson learned: Use identical? only for reference equality.

Disassembled examples

The code has been disassembled with clj-java-decompiler.

Example 1 `(identical? Double/NaN Double/NaN)`

class user$fn_line_1__254
    Minor version: 0
    Major version: 52
    Flags: PUBLIC, FINAL, SUPER
    
    public void <init>();
        Flags: PUBLIC
        Code:
                  linenumber      1
               0: aload_0        
               1: invokespecial   clojure/lang/AFunction.<init>:()V
               4: return         
    
    public static java.lang.Object invokeStatic();
        Flags: PUBLIC, STATIC
        Code:
                  linenumber      1
               0: getstatic       java/lang/Double.NaN:D
               3: invokestatic    java/lang/Double.valueOf:(D)Ljava/lang/Double;
                  linenumber      1
               6: getstatic       java/lang/Double.NaN:D
               9: invokestatic    java/lang/Double.valueOf:(D)Ljava/lang/Double;
                  linenumber      1
              12: invokestatic    clojure/lang/Util.identical:(Ljava/lang/Object;Ljava/lang/Object;)Z
              15: ifeq            24
              18: getstatic       java/lang/Boolean.TRUE:Ljava/lang/Boolean;
              21: goto            27
              24: getstatic       java/lang/Boolean.FALSE:Ljava/lang/Boolean;
              27: areturn        
        StackMapTable: 00 02 18 42 07 00 1D
    
    public java.lang.Object invoke();
        Flags: PUBLIC
        Code:
                  linenumber      1
               0: invokestatic    user$fn_line_1__254.invokeStatic:()Ljava/lang/Object;
               3: areturn        
    
    static {};
        Flags: PUBLIC, STATIC
        Code:
                  linenumber      1
               0: return

Example 2 `(let [x Double/NaN] (identical? x x))`

Skipped; similar to example 4.

Example 3 `(identical? ##NaN ##NaN)`

Note that the boxing happens in the static block.

class user$fn_line_1__246
    Minor version: 0
    Major version: 52
    Flags: PUBLIC, FINAL, SUPER
    
    public static final java.lang.Object const__1;
        Flags: PUBLIC, STATIC, FINAL
    
    public void <init>();
        Flags: PUBLIC
        Code:
                  linenumber      1
               0: aload_0        
               1: invokespecial   clojure/lang/AFunction.<init>:()V
               4: return         
    
    public static java.lang.Object invokeStatic();
        Flags: PUBLIC, STATIC
        Code:
                  linenumber      1
               0: getstatic       user$fn_line_1__246.const__1:Ljava/lang/Object;
               3: getstatic       user$fn_line_1__246.const__1:Ljava/lang/Object;
                  linenumber      1
               6: invokestatic    clojure/lang/Util.identical:(Ljava/lang/Object;Ljava/lang/Object;)Z
               9: ifeq            18
              12: getstatic       java/lang/Boolean.TRUE:Ljava/lang/Boolean;
              15: goto            21
              18: getstatic       java/lang/Boolean.FALSE:Ljava/lang/Boolean;
              21: areturn        
        StackMapTable: 00 02 12 42 07 00 17
    
    public java.lang.Object invoke();
        Flags: PUBLIC
        Code:
                  linenumber      1
               0: invokestatic    user$fn_line_1__246.invokeStatic:()Ljava/lang/Object;
               3: areturn        
    
    static {};
        Flags: PUBLIC, STATIC
        Code:
                  linenumber      1
               0: ldc2_w          NaN
               3: invokestatic    java/lang/Double.valueOf:(D)Ljava/lang/Double;
               6: putstatic       user$fn_line_1__246.const__1:Ljava/lang/Object;
               9: return

Example 4 `(let [x ##NaN] (identical? x x))`

Note two Double.valueOf calls in the invokeStatic method.

class user$fn_line_1__250
    Minor version: 0
    Major version: 52
    Flags: PUBLIC, FINAL, SUPER
    
    public void <init>();
        Flags: PUBLIC
        Code:
                  linenumber      1
               0: aload_0        
               1: invokespecial   clojure/lang/AFunction.<init>:()V
               4: return         
    
    public static java.lang.Object invokeStatic();
        Flags: PUBLIC, STATIC
        Code:
                  linenumber      1
               0: ldc2_w          NaN
               3: dstore_0        /* x */
               4: dload_0         /* x */
               5: invokestatic    java/lang/Double.valueOf:(D)Ljava/lang/Double;
               8: dload_0         /* x */
               9: invokestatic    java/lang/Double.valueOf:(D)Ljava/lang/Double;
                  linenumber      1
              12: invokestatic    clojure/lang/Util.identical:(Ljava/lang/Object;Ljava/lang/Object;)Z
              15: ifeq            24
              18: getstatic       java/lang/Boolean.TRUE:Ljava/lang/Boolean;
              21: goto            27
              24: getstatic       java/lang/Boolean.FALSE:Ljava/lang/Boolean;
              27: areturn        
        StackMapTable: 00 02 FC 00 18 03 42 07 00 1B
    
    public java.lang.Object invoke();
        Flags: PUBLIC
        Code:
                  linenumber      1
               0: invokestatic    user$fn_line_1__250.invokeStatic:()Ljava/lang/Object;
               3: areturn        
    
    static {};
        Flags: PUBLIC, STATIC
        Code:
                  linenumber      1
               0: return

Answered: Could realized? support Java futures?

Sat, 28 May 2022 20:14:05 +0000

Whenever anyone brings up realized? in discussions on Slack, the general advice is that you shouldn't use it and it already doesn't work in an intuitive way in many situations.

The question then usually turns to "Why are you using realized? in the first place?".

An example of non-intuitive behavior:

https://ask.clojure.org/index.php/10004/calling-realized-delay-currently-executing-blocks-caller

(considered a bug -- fixed in Clojure 1.11)

I just checked our 125k line codebase and there's just one call to realized? in a test, specifically checking whether a promise was delivered or not.

I'll be interested to hear what folks from the Clojure Team say about this but I suspect they wouldn't want to encourage use of it?

Answered: Integration with java.util.function interfaces

Thu, 26 May 2022 11:59:10 +0000

This is what a Kafka Streams app written in Java looks like:

      sb.table("input", Consumed.with(sl, sl))
            .groupBy((k, v) -> KeyValue.pair(k / 10, v), Grouped.with(sl, sl))
            .aggregate(() -> 0L,
                    (k, v, acc) -> acc + v,
                    (k, v, acc) -> acc - v,
                    Materialized.with(sl, sl))
            .toStream()
            .to("output", Produced.with(sl, sl));

The same app written in Clojure looks like this:

    (-> sb
        (.table "input" (topic->consumed data-in))
        (.groupBy (key-value-mapper
                    (fn [k v] (KeyValue/pair (long (/ k 10)) v)))
                (serdes->grouped "groupie" data-in))
        (.aggregate (reify Initializer
                    (apply [_] 0))
                    (reify Aggregator
                    (apply [_ k v acc]
                        (+ acc v)))
                    (reify Aggregator
                    (apply [_ k v acc]
                        (- acc v)))
                    (serdes->materialised ...))
        (.toStream)
        (.to "output" (topic->produced data-out)))

If we had the ability to use Lambdas where SAM types are expected, we could write this instead:

    (-> sb
        (.table "input" (topic->consumed data-in))
        (.groupBy (fn [k v] (KeyValue/pair (long (/ k 10)) v))
                (serdes->grouped "groupie" data-in))
        (.aggregate (constantly 0)
                    (fn [k v acc] (+ acc v))
                    (fn [k v acc] (- acc v))
                    (serdes->materialised ...))
        (.toStream)
        (.to "output" (topic->produced data-out)))

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

Thu, 05 May 2022 09:40:34 +0000

(def foo "bar") creates a Clojure var - technically a mutable form of storage.

There is no guarantee (implicit or explicit) that the code won't do something like (alter-var-root #'foo #(do % 42)) unless someone provides hints. That would make it difficult to do implicit type inference in the core language.

Answered: Incorrect long quot result involving Long/MIN_VALUE

Mon, 31 Jan 2022 17:13:26 +0000

Also see https://ask.clojure.org/index.php/11521/some-corner-cases-that-might-considered-ratio-implementation

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

Sun, 26 Dec 2021 18:13:41 +0000

If you prefer an interactive chat experience for asking such questions, the #beginners channel on the Clojurians Slack community at https://clojurians.slack.com is a good place for such questions. Either here or there, it can be helpful if you are willing to publish longer code samples you are working on in a public place such as Github.com.

To your questions, your first function pt%% assigns a value to val before the loop begins, and then val always has the same value from that point onwards, never changing. Thus regardless of what is done inside of the loop, it will be an infinite loop, unless an exception occurs, which is what happens in your case. I have not tried to diagnose exactly why that particular exception occurs, because of the infinite loop issue and val never changing.

pt5 has the same issue that val is always the same, because (recur val) occurs in a context where val is bound to the same value as when the loop began.

In pt5, try using val as an argument to the tocChars method, and change the recur expression to (recur (.read bfr)) and see how that goes. And think about why that behaves differently than your version in the question.

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

Tue, 08 Jun 2021 15:10:01 +0000

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

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

Answered: into-array should not need type hints

Sun, 16 May 2021 13:52:18 +0000

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

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

Sun, 02 May 2021 07:38:25 +0000

For reference, it looks like clojure.tools.emitter.jvm DOES preserve the type of non-primitive fields....

 (require '[clojure.tools.emitter.jvm :as e])

(e/eval '(deftype blah [^String x]) {:debug? true})
;;;
// class version 50.0 (50)
// access flags 0x31
public final class user/blah implements clojure/lang/IType  {

  // compiled from: user/blah

  // access flags 0x11
  public final Ljava/lang/String; x
...

user> (require '[clojure.reflect :as r])
nil
user> (r/reflect (user.blah. "hello"))
{:bases #{java.lang.Object clojure.lang.IType},
 :flags #{:public :final},
 :members
 #{{:name getBasis,
    :return-type clojure.lang.IPersistentVector,
    :declaring-class user.blah,
    :parameter-types [],
    :exception-types [],
    :flags #{:public :static}}
   {:name user.blah,
    :declaring-class user.blah,
    :parameter-types [java.lang.Object],
    :exception-types [],
    :flags #{:public}}
   {:name x,
    :type java.lang.String,  ;;in clojure
    :declaring-class user.blah,
    :flags #{:public :final}}}}

Answered: Problems loading ffmpeg library with jna

Fri, 02 Apr 2021 09:03:41 +0000

In the meantime: https://github.com/cnuernber/avclj

Answered: Apparently uncallable method overload

Mon, 08 Mar 2021 20:26:34 +0000

looks a lot like https://clojure.atlassian.net/browse/CLJ-1243, the addAll(RangeSet ...) method is defined in a package private class https://github.com/google/guava/blob/v30.1/android/guava/src/com/google/common/collect/AbstractRangeSet.java. There is also an interface(https://github.com/google/guava/blob/v30.1/android/guava/src/com/google/common/collect/RangeSet.java), but all the methods there lack access modifiers, so are private (not sure what that does to java inheritance)

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})

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

Wed, 23 Dec 2020 00:15:30 +0000

You explicitly asked for a JNR-FFI solution, but there are alternative Clojure libraries not based on JNR-FFI that allow you to do what you want. Have a look at:

https://github.com/Chouser/clojure-jna

https://github.com/techascent/tech.jna

Both can do what you want by using JNA under the hood (not using JNR-FFR).

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))