Wie rufe ich überladene Java-Methoden in Clojure

Question

Für dieses Beispiel Java-Klasse:

package foo; 
public class TestInterop 
{ public String test(int i) 
    { return "Test(int)"; } 

    public String test(Object i) 
    { return "Test(Object)"; } 
} 

Wenn ich Clojure starten und versuchen, den Test (int) -Methode aufzurufen, der Test (Object) -Methode stattdessen aufgerufen wird, weil Clojure die ganze Zahl automatisch in ein java.lang.Integer-Objekt einfügt.

Wie erzwinge ich Clojure, die Test (int) -Methode aufzurufen?

user=> (.test (new foo.TestInterop) 10) 
"Test(Object)" 

Ich möchte AWT wie Component.add(Component comp, int index) Methoden aufrufen, sondern halten add(Component comp, Object constraints) anrufen, damit die Tasten auf meiner Symbolleiste immer in der falschen Reihenfolge angezeigt.

Answer 1

Eine Diskussion findet gerade im #clojure Channel auf Freenode zu diesem Thema statt. Chris Houser (der eine Antwort schreiben wollte, aber letztendlich entschied, dass er zu beschäftigt war, um das zu tun) hat a Gist gepostet, was zeigt, was mit einer überladenen Methode boolean gegenüber Object passiert; Es stellt sich heraus, dass in einigen Szenarien zusätzlich zu einer (boolean ...) Umwandlung ein Typhinweis erforderlich ist. Die Diskussion war ziemlich aufschlussreich, und ein paar dunkle Ecken des Clojure-Kompilierungsprozesses wurden schön beleuchtet. (Siehe Links zum IRC-Protokoll unten.)

Wenn ein Objekt direkt in der Methodenaufrufform erstellt wird - (.foo (Foo.) ...), sagen Sie -, dass Typhinweis nicht notwendig ist; es ist ebenfalls nicht notwendig, wenn das Objekt als ein Wert für eine lokale in einem umschließenden let Formular erstellt wurde (siehe Update 2 unten und meine Version des Gist). Wenn das Objekt jedoch durch Var-Nachschlagen erhalten wird, ist ein Typhinweis erforderlich, der entweder auf dem Var selbst oder auf der Aufrufseite auf dem Symbol bereitgestellt werden kann, das verwendet wird, um auf den Var Bezug zu nehmen.

Die Java-Code aus dem Gist:

Und der Clojure Code:

(.foo (mypkg.Ugly.) 5) 
;=> "obj: 5" 

(.foo (mypkg.Ugly.) true) 
;=> "obj: true" 

(.foo (mypkg.Ugly.) (boolean true)) 
;=> "bool: true" 


(def u (mypkg.Ugly.)) 
(.foo u (boolean true)) 
;=> "obj: true" 

(.foo #^mypkg.Ugly u (boolean true)) 
;=> "bool: true" 

Hinweis, wie die Clojure Compiler einen Typ Hinweis auf u muss in die Lage einen direkten Methodenaufruf zu kompilieren . Ansonsten scheint ein reflektionsbasierter Code erzeugt zu werden, der scheinbar den Überblick verliert, dass das Argument auf dem Weg ein Primitiv sein soll.

Meine Ergänzungen folgen (und hier ist my fork of the above Gist).

;; renamed mypkg.Ugly to foo.TestInterop2 when doing my tests 
user> (let [t (foo.TestInterop2.)] 
     (.foo t (boolean true))) 
"bool: true" 

;;; type-hinting the Var 
user> (def #^foo.TestInterop2 x (foo.TestInterop2.)) 
#'user/x 
user> (.foo x (boolean true)) 
"bool: true" 

Das Thema wurde zum ersten Mal at this point gebracht. Chouser postete den Gist half an hour later, und die Diskussion wurde danach immer interessanter.

Answer 2

Zahlen in Clojure werden im Allgemeinen eingerahmt (int => Integer), es sei denn, Sie fragen ausdrücklich nach Primitiven.

Here ist mehr Informationen über Primitive in Clojure.