Mapeo sobre sublistas en Scala

Question

Sé que la función de mapa toma cada elemento de una lista (una secuencia) y le aplica una función. De forma recursiva (y sin respeto a las condiciones de terminación, etc)

map(s, f) = f(s.head) :: map(s.tail, f) 

Busco a una función que hace algo como

foo(s, f) = f(s) :: map(s.tail, f). 

lo tanto un 'asignador', donde la función de mapeo es llamado en sublistas y no elementos individuales. En términos de ceceo, estoy buscando una lista de mapas, a diferencia de un carro de mapa. ¿Existe algo como esto, o tengo que hacer mi propio (o usar recursividad)?

Por otra parte, me gustaría tener una función que toma como entrada una secuencia y devuelve una secuencia de subsecuencias a mediados y finales, es decir

bar(s, f) = s :: bar(s.tail, f) 

Answer 1

/* Este enfoque define mapList en términos de otro método útil llamado colas. Como Daniel, lo voy a poner en una extensión implícita a la lista, pero eso es puramente una cuestión de gusto */

implicit def richerList[A](list : List[A]) = new { 

/* Aquí hay un método llamado colas que devuelve cada posible de la cola de la lista. Es cola recursiva por lo que no explotará en listas grandes. Tenga en cuenta que difiere ligeramente de una función Haskell del mismo nombre. La versión Haskell siempre añade una lista vacía en la que el resultado */

def tails : List[List[A]] = { 
    def loop(ls : List[A], accum : List[List[A]]) : List[List[A]] = ls match { 
     case _ :: tail => loop(tail, ls :: accum) 
     case _ => accum 
    } 

    loop(list, Nil).reverse 
    } 

/* Esto es lo que el uso de colas se parece

scala> "abc".toList.tails 
res0: List[List[Char]] = List(List(a, b, c), List(b, c), List(c)) 

*/

/* Ahora podemos definir lista de mapas sobre la base de la cola */

def mapList[B](f : List[A] => B) = tails map f 
} 

/* Y esto es lo que el uso de lista de mapas parece

scala> "abc".toList mapList (_.reverse.mkString) 
res1: List[String] = List(cba, cb, c) 

*/

Answer 2

Es, básicamente, ha definido lo que estás buscando en pseudocódigo - por lo que es fácil de agregar un procedimiento de este tipo a una lista Scala utilizando las conversiones implícitas:

object ExtendedList{ 
    implicit def List2ExtendedList[A](l:List[A])=new ExtendedList(l) 
} 
class ExtendedList[A](l:List[A]){ 
    import ExtendedList._ 
    def mapList[B](f:List[A]=>B):List[B]=l.length match { 
    case 0 => List() 
    case _ => f(l)::l.tail.mapList(f) 
    } 
} 

object Test extends Application{ 
    import ExtendedList._ 
    val test = List(5,4,3,2,1) 
    assert(List(15,10,6,3,1)==test.mapList{l=>(0/:l){_+_}}) 
} 

es esto lo que está buscando?

Answer 3

La otra respuesta es estrecha, pero debe Nunca uso List#length menos que sea absolutamente necesario. En particular, hace que su solución O (n^2) cuando el problema es inherentemente O (n). He aquí una versión limpia-up:

implicit def addListSyntax[A](list: List[A]) = new { 
    def mapList[B](f: List[A]=>B) = { 
    // use inner function to avoid repeated conversions 
    def loop(list: List[A]): List[B] = list match { 
     case ls @ (_ :: tail) => f(ls) :: loop(tail) 
     case Nil => Nil 
    } 

    loop(list) 
    } 
} 

Y, para responder a su pregunta original: no, no hay manera de hacer esto utilizando métodos de utilidad estándar. De hecho, tengo curiosidad por saber por qué querrías algo como esto ...