nuevo código {} Iterable de Scala 2.7.7 a 2.8

Question

vi este tema:

What are the biggest differences between Scala 2.8 and Scala 2.7?

Parece cubrir algunos cambios, pero el primer compilar los problemas que he dado no parecen para ser mencionado. ¿Alguna sugerencia?

• tipos de los argumentos de tipo (Iterable [Cualquier] con (A con Int) => Cualquier) no se ajusten a los tipos esperados de los parámetros de tipo (tipo CC) en GenericCompanion clase. Iterable [Cualquiera] con (A con Int) => Cualquiera de los parámetros del tipo no coinciden con los parámetros esperados del tipo CC: no tiene parámetros de tipo, pero el tipo CC tiene
• creación de objeto imposible, ya que iterador de método en el atributo IterableLike de tipo => Iterator [java.io.File] se no definida
• creación de objetos imposible, ya que método iterador en rasgo IterableLike de tipo => Iterator [V] no está definido
• método de elementos imperiosas de rasgo IterableLike de tipo => Iterador [java.io.File]; método elementos necesita el modificador 'anular'
• elementos del método de anulación en el rasgo IterableInsignia de tipo => iterador [V]; elementos método de las necesidades `anulación' modificador

Aquí está el código en cuestión:

/** 
* Filesystem walker. 
* <p> 
* Less magic version of: http://rosettacode.org/wiki/Walk_Directory_Tree#Scala 
*/ 
object FsWalker { 
    /** 
    * Recursive iterator over all files (and directories) in given directory. 
    */ 
    def walk(f: File): Iterable[File] = new Iterable[File] { 
    def elements = { 
     if (f.isDirectory()) { 
     // recurse on our child files 
     f.listFiles.elements.flatMap(child => FsWalker.walk(child).elements) 
     } else { 
     // just return given file wrapped in Iterator 
     Seq(f).elements 
     } 
    } 
    } 
} 

Answer 1

El ex elements es ahora iterator.

Debe compilar con -Xmigration para obtener consejos útiles sobre cómo portar su código de 2.7 a 2.8.

Answer 2

La clave aquí es asegurarse de usar el iterador del método con un Iterable. Scala 2.8.0 también hizo mucho para garantizar que los tipos sean consistentes en todas las llamadas de recolección.

scala> val x = new Iterable[String] { 
    | def iterator = List("HAI", "YOU", "GUYS").iterator 
    | } 
x: java.lang.Object with Iterable[String] = line18(HAI, YOU, GUYS) 

También consideraría utilizar un Stream en lugar de un iterador. El enfoque de iterador construirá todo el conjunto de archivos al llamar al método de iterador. Una corriente puede ser floja.

scala> def files(f : File) : Stream[File] = { 
    | if(f.isDirectory) {     
    |  f.listFiles.toStream.map(files).flatten 
    | } else Stream(f) 
    | } 
files: (f: java.io.File)Stream[java.io.File] 

scala> files(new File("/home/jsuereth/projects/scala/scala")) 
res1: Stream[java.io.File] = Stream(/home/jsuereth/projects/scala/scala/build/manmaker/classes/scala/man1/sbaz.class, ?) 

scala> res1 take 10 foreach println 
/home/jsuereth/projects/scala/scala/build/manmaker/classes/scala/man1/sbaz.class 
/home/jsuereth/projects/scala/scala/build/manmaker/classes/scala/man1/scala$$anon$1.class 
... 

Alternativamente, si desea incluir directorios en la corriente, intente lo siguiente:

scala> def files_with_dirs(f : File) : Stream[File] = { 
    | if(f.isDirectory) Stream.cons(f, f.listFiles.toStream.map(files).flatten) 
    | else Stream(f) 
    | } 
files_with_dirs: (f: java.io.File)Stream[java.io.File]