Come passare una collezione tipizzata da clojure a java?

Question

Conosco le basi di clojure/java interop: chiama java da clojure e viceversa. Tuttavia, non ero in grado di restituire una raccolta tipizzata da clojure a java. Sto cercando di vedere qualcosa di quella natura List<TypedObject> dal codice java che sta chiamando in clojure.

Java Object: 

public class TypedObject { 
    private OtherType1 _prop1; 
    public OtherType1 getProp1() { 
     return _prop1; 
    } 
    public void setProp1(OtherType1 prop1) { 
     _prop1 = prop1; 
    } 
} 

CLojure method: 

(defn -createListOfTypedObjects 
     "Creates and returns a list of TypedObjects" 
     [input] 
     ;Do work here to create and return list of TypedObjects 
     [typedObj1, typedObj2, typedObj3]) 

(:gen-class 
:name some.namespace 
:methods [createListofTypedObjects[String] ????]) 

Consideriamo che sto scrivendo un'API utilizzando clojure, che deve essere distribuito come un file jar, per essere utilizzato da Java. La mia domanda era davvero come cosa passare al posto del ???? questioni di marchi di cui sopra all'interno del: Gen-classe per AOT, in modo che un programmatore che scrive un pezzo di codice in Java utilizzando il mio api, può avere il completamento intellisense/codice appropriato (cioè .: createListofTypedObjects() returns List<TypedObject>) dall'interno di Eclipse per esempio.

Answer 1

Gli altri hanno ragione che Clojure non garantisce i tipi di elementi nelle raccolte restituite, ecc. (In realtà, la JVM non garantisce i tipi di elementi nelle raccolte - sia gestita interamente da javac.)

Tuttavia, posso vedere il valore di fornire un'API per altri programmatori Java che specifica un'interfaccia che dichiara che i valori di ritorno (o parametri) parametrizzati in vari modi; questo è particolarmente interessante se si sta cercando di usare Clojure in un ambiente Java esistente senza fare ondate.

Questo momento richiede un processo in due fasi:

• definire un'interfaccia separata (in Java!) Che specifica i tipi parametrizzati come ti piace
• definire il tuo gen-class spazio dei nomi (o proxy o reify esempio) quali che implementa quell'interfaccia

(Clojure fornisce un modulo definterface che consente di evitare la definizione di interfaccia Java separata, ma definterface, proprio come il resto di Clojure, non prevede la specifica dei tipi parametrizzati. Forse un giorno ... :-))

ad es.

public interface IFoo { 
    List<TypedObject> createListOfTypedObjects(); 
} 

e poi il Gen-class namespace:

(ns your.ns.FooImpl 
    (:gen-class 
    :implements [IFoo])) 
(defn -createListOfTypedObjects 
    [] 
    [typedObj1, typedObj2, typedObj3]) 

Quando gli utenti di creare istanze di FooImpl, faranno per esempio ottenere il completamento del codice che indica che il metodo restituisce List<TypedObject> anziché Object o il tipo non parametrizzato List.

Se si utilizzano strumenti di generazione normale (ad esempio maven, gradle o formica configurata correttamente), è possibile inserire l'interfaccia Java nel progetto Clojure e la dipendenza tra lingue sarà gestita.

Answer 2

Se si sta tentando di passare qualcosa come List<String> a un metodo java, non è necessario preoccuparsene. Il parametro type (ad es., String) è utilizzato solo dal compilatore javac, quindi qualsiasi List funzionerà correttamente in fase di esecuzione.

D'altra parte, se si sta cercando di passare un array di un particolare tipo di oggetto (ad esempio, String[]), quindi è possibile utilizzare le varie funzioni: -array

user=> (make-array String 10)   ; an empty String array 
#<String[] [Ljava.lang.String;@78878c4c> 
user=> (into-array ["foo" "bar"])  ; array type inferred from first element 
#<String[] [Ljava.lang.String;@743fbbfc> 
user=> (into-array Number [1.2 5 7N]) ; explicit type array 
#<Number[] [Ljava.lang.Number;@7433b121> 

Answer 3

Non è necessario preoccuparsi di generici (raccolte tipizzate) in Clojure. I generici sono in realtà solo suggerimenti per il compilatore Java. In un programma Java in esecuzione, List<String> equivale esattamente a List<Object>.

Quindi, ad esempio, un vettore Clojure contenente stringhe è già un List<String> senza necessità di conversione.