Come faccio a convertire Array [Node] per NodeSeq?

Question

Sto cercando di integrare un'applicazione di sollevamento in qualche codice Java esistente. In uno dei miei frammenti, ho un array di oggetti Java che ho bisogno di mappare che in un NodeSeq. Posso ottenere una matrice di Nodo di, ma non un NodeSeq. (Almeno, non in modo molto funzionale-looking).

import scala.xml.NodeSeq

// pretend this is code I can't do anything about
val data = Array("one", "two", "three")

// this is the function I need to write
def foo: NodeSeq = data.map { s => <x>{s}</x> }
//                          ^
// error: type mismatch;
//  found   : Array[scala.xml.Elem]
//  required: scala.xml.NodeSeq

Qual è il modo più pulito per fare questo?

Answer 1

Vorrei semplicemente convertire uscita map alla sequenza (dato che Seq[Node] è un super-classe di NodeSeq)

scala> def foo: NodeSeq = data.map { s => <x>{s}</x> } toSeq
foo: scala.xml.NodeSeq

o l'uso foldLeft invece di map

scala> def foo: NodeSeq = (Seq[Node]() /: data) {(seq, node)=> seq ++ <x>{node}</x>}
foo: scala.xml.NodeSeq

Answer 2

scala> import collection.breakOut
import collection.breakOut

scala> def foo: NodeSeq = data.map { s => <x>{s}</x> }(breakOut)
foo: scala.xml.NodeSeq

La mappa metodo ha in realtà due liste di argomenti. Il primo accoglie una funzione che avete passato. Il secondo accetta un oggetto CanBuildFrom che viene usato per creare un generatore che crea quindi la sequenza di rinvio. Questo argomento è implicita, per cui di solito il compilatore riempie per voi. Si accetta 3 parametri di tipo: Da, T, A. Ci sono diversi impliciti PREDEF (tra cui in oggetto NodeSeq), ma nessuno di loro partite Da = Array, T = Nodo, A = NodeSeq.

Breakout risolve questo: si tratta di un metodo generico che restituisce un'istanza CanBuildFrom attraverso la ricerca di un CanBuildFrom implicita [Niente, T, A]. Secondo le regole di ricerca implicite, qualsiasi CanBuildFrom che partite T, A e ha da> Nulla è accettabile. In questo caso: canBuildFrom nell'oggetto Array

Answer 3

Siete alla ricerca di questo metodo sull'oggetto NodeSeq compagna.

NodeSeq.fromSeq(s: Seq[Node])