Clojure中是否有适用于Java函数的apply函数？

Question

 user=> (Integer/rotateRight 0 0)
 0

 user=>  (apply Integer/rotateRight [0 0])
 CompilerException java.lang.RuntimeException: Unable to find static field: 
   rotateRight in class java.lang.Integer, compiling:(NO_SOURCE_PATH:172)

Is there any way to do apply for java functions in Clojure? If not how could I write a macro or function that would support this?

Answer 1

The simplest thing I can think of is wrapping it in a function, but I'm not entirely sure if this is the best/most idiomatic way:

user> (apply (fn [a b] (Integer/rotateRight a b)) [0 0])
0

Or, slightly shorter but equivalent:

user> (apply #(Integer/rotateRight %1 %2) [0 0])
0

Alternatively, you could create a proper wrapper function for your java method call:

(defn rotate-right [a b]
  (Integer/rotateRight a b))

You'd use it like so:

user> (apply rotate-right [0 0])
0

edit : just for fun, inspired by iradik's comment about efficieny, time comparisons between three different ways of calling this method:

;; direct method call (x 1 million)
user> (time (dorun (repeatedly 1E6 #(Integer/rotateRight 2 3))))
"Elapsed time: 441.326 msecs"
nil

;; method call inside function (x 1 million)
user> (time (dorun (repeatedly 1E6 #((fn [a b] (Integer/rotateRight a b)) 2 3))))
"Elapsed time: 451.749 msecs"
nil

;; method call in function using apply (x 1 million)
user> (time (dorun (repeatedly 1E6 #(apply (fn [a b] (Integer/rotateRight a b)) [2 3]))))
"Elapsed time: 609.556 msecs"
nil

Answer 2

A couple of points which, while not a direct answer, are relevant here.

First off, Java does not have functions. It only has either instance methods or static methods. This may seem like a pedantic distinction, but it does make a difference (as shown in some of the other examples where different forms are needed for static and instance invocation).

Secondly, the impedance mismatch between the type systems comes into play. For Java to have fully-fledged FP support in a Javaish manner, it would need to be statically typed. This turns out to be quite hard to do in a truly satisfactory manner (see the discussion on the lambda-dev mailing list for details of the approach that is being used and will arrive in Java 8).

From these two points, we can see that from Clojure the best we can really do is to support an "all bets are off" approach to calling Java methods via #() or similar. Clojure will only choose between forms to call based on the arity of the argument, so some sort of type hints or casting may be needed to ensure the correct overloaded Java method is called.

More importantly, of course, if a user passes an argument of a type that Java isn't expecting, or can't handle, this may not be detectable until runtime.

Answer 3

I wrote a few macros to do this after being inspired by gertalot's answer. Appears to compile to the equivalent normal code. Benchmark was identical. Curious what you think.

(defmacro java-new-apply 
   ([klass] `(new ~klass))
   ([klass args] `(new ~klass ~@(map eval args))))

(defmacro java-static-apply 
   ([f] f)
   ([f args] `(~f ~@(map eval args))))

(defmacro java-method-apply 
   ([method obj] method obj) 
   ([method obj args] `(~method ~obj ~@(map eval args))))

;; get date for Jan 1 1969
(import java.util.Date)
(java-new-apply Date [69 1 1])
(macroexpand '(java-new-apply Date [69 1 1]))
(new Date 69 1 1)

(java-static-apply Integer/rotateRight [2 3])
(macroexpand '(java-static-apply Integer/rotateRight [2 3]))
(. Integer rotateRight 2 3)

(java-method-apply .substring "hello world!" [6 11])
(macroexpand '(java-method-apply .substring "hello world!" [6 11]))
(. "hello world!" substring 6 11)