using java.lang.invoke.MethodHandle in clojure

Question

I'm following a tutorial here: https://www.baeldung.com/java-method-handles

In clojure, I've got a simple example:

(import (java.lang.invoke MethodHandles
                          MethodHandles$Lookup
                          MethodType
                          MethodHandle))

(defonce +lookup+ (MethodHandles/lookup))

(def ^MethodHandle concat-handle (.findVirtual +lookup+
                                 String
                                 "concat"
                                 (MethodType/methodType String String)))

(.invokeExact concat-handle (into-array Object ["hello" "there"]))

which gives an error:

Unhandled java.lang.invoke.WrongMethodTypeException
 expected (String,String)String but found (Object[])Object

         Invokers.java:  476  java.lang.invoke.Invokers/newWrongMethodTypeException
         Invokers.java:  485  java.lang.invoke.Invokers/checkExactType
                  REPL:   26  hara.object.handle/eval17501
                  REPL:   26  hara.object.handle/eval17501
         Compiler.java: 7062  clojure.lang.Compiler/eval
         Compiler.java: 7025  clojure.lang.Compiler/eval
              core.clj: 3206  clojure.core/eval
              core.clj: 3202  clojure.core/eval
              main.clj:  243  clojure.main/repl/read-eval-print/f

is there a way to get invoke working?

Answer 1

You can use .invokeWithArguments which will figure out the correct arity from the supplied arguments:

(.invokeWithArguments concat-handle (object-array ["hello" "there"]))
=> "hellothere"

Or you can use .invoke, but you'll need MethodHandle.asSpreader to apply the varargs correctly to String.concat which has fixed arity:

(def ^MethodHandle other-handle
  (.asSpreader
    concat-handle
    (Class/forName "[Ljava.lang.String;") ;; String[].class
    2))

(.invoke other-handle (into-array String ["hello" "there"]))
=> "hellothere"

I'm not sure how to make this work with .invokeExact from Clojure, if it's possible.

The symbolic type descriptor at the call site of invokeExact must exactly match this method handle's type. No conversions are allowed on arguments or return values.

This answer has more explanation on restrictions of .invoke and .invokeExact.

Answer 2

Some interesting benchmarks based on @TaylorWood's answer:

(with-out-str
  (time (dotimes [i 1000000]
          (.concat "hello" "there"))))
=> "\"Elapsed time: 8.542214 msecs\"\n"


(with-out-str
  (def concat-fn (fn [a b] (.concat a b)))
  (time (dotimes [i 1000000]
          (concat-fn "hello" "there"))))
=> "\"Elapsed time: 3600.357352 msecs\"\n"

(with-out-str
  (def concat-anno (fn [^String a b] (.concat a b)))
  (time (dotimes [i 1000000]
          (concat-anno "hello" "there"))))
=> "\"Elapsed time: 16.461237 msecs\"\n"

(with-out-str
  (def concat-reflect (.? String "concat" :#))
  (time (dotimes [i 1000000]
          (concat-reflect "hello" "there"))))
=> "\"Elapsed time: 1804.522226 msecs\"\n"

(with-out-str
  (def ^MethodHandle concat-handle
    (.findVirtual +lookup+
                  String
                  "concat"
                  (MethodType/methodType String String)))
  (time (dotimes [i 1000000]
          (.invokeWithArguments concat-handle (into-array Object ["hello" "there"])))))
=> "\"Elapsed time: 1974.824815 msecs\"\n" 

(with-out-str
  (def ^MethodHandle concat-spread
    (.asSpreader concat-handle
                 (Class/forName "[Ljava.lang.String;") ;; String[].class
                 2))
  (time (dotimes [i 1000000]
          (.invoke other-handle (into-array String ["hello" "there"])))))
=> "\"Elapsed time: 399.779913 msecs\"\n"