Conversione implicita tra tipi di collezione Scala

Question

Vorrei convertire implicitamente tra l'oggetto Elem XML di Scala e un'altra rappresentazione di un elemento XML, nel mio caso dom4j Element. Ho scritto le seguenti conversioni implicite:

implicit def elemToElement(e: Elem): Element = ... do conversion here ... 
implicit def elementToElem(e: Element): Elem = ... do conversion here ... 

Fin qui tutto bene, questo funziona.

Ora ho bisogno anche di raccolte di detti elementi per convertire entrambi i modi. Per prima cosa, devo assolutamente scrivere metodi di conversione aggiuntivi? Le cose non sembra funzionare se non l'avessi fatto.

ho cercato di scrivere il seguente:

implicit def elemTToElementT(t: Traversable[Elem]) = t map (elemToElement(_)) 
implicit def elementTToElemT(t: Traversable[Element]) = t map (elementToElem(_)) 

Questo non sembra troppo ideale, perché se il metodo di conversione prende un Traversable, poi ritorna anche una Traversable. Se passo una lista, ottengo anche un Traversable. Quindi presumo che la conversione dovrebbe essere parametrizzata in qualche modo.

Quindi qual è il modo standard di scrivere queste conversioni per essere il più generico possibile?

Answer 1

Penso che questo potrebbe richiedere implicitamente troppo. Tanto più che si può semplicemente utilizzare il metodo convertitore in una mappa

val listOfElements = listOfElems map elemToElement(_) 

Penso che la concisione livello si sta andando per è sempre in confusione. Creerei un convertitore e lavorerò solo in una delle rappresentazioni in modo da evitare che le cose si confondano.

Answer 2

Questo non è banale, quindi per ottenere quello che vuoi penso che dovrai andare un po 'più a fondo. Questo articolo spiega molto su come funzionano le collezioni scala (e interessante anche leggere): http://www.artima.com/scalazine/articles/scala_collections_architecture.html

Stai praticamente provando a fare lo stesso di List.map (...) (o TraversableLike che ha l'implementazione) e metodi simili .... solo con la conversione implicita in aggiunta.

Aggiornamento:

ho iniziato a sperimentare un po 'con questo e ha scritto una conversione in base a quello che fa TraversableLike.map (...). Tuttavia ho scoperto che ha funzionato anche senza di esso. Sembra Scala supporta fuori dalla scatola (almeno sulla mia macchina :-)):

case class Element(e: Elem) 
implicit def elemToElement(e: Elem): Element = Element(e) 
implicit def elementToElem(e: Element): Elem = e.e 

val a: List[Element] = List(<a/>, <b/>, <c/>) 
val b: List[Elem] = List(Element(<a/>), Element(<b/>), Element(<c/>)) 
val c: Set[Element] = Set(<a/>, <b/>, <c/>) 

Questo era quello che erano dopo?