scala 2.8 inconsistencia de colecciones?

Question

por qué el métodos (versión mutación en el lugar de map) transform y retain (versión mutación en el lugar de filter) se definen solamente en mutable.Map pero no en mutable.Buffer y mutable.Set? ¿No deberían todas las colecciones mutables respaldar estos métodos?

Answer 1

Las operaciones retain y transform de Map son sobre las claves y valores, conceptos que no son parte de un Set o una Buffer.

Un mapa es un Iterable que consiste en pares de claves y valores (también llamados mapeos o asociaciones).
Las operaciones fundamentales en los mapas son similares a las de los conjuntos.

Pero sus operaciones se enumeran en:

mapas mutables apoyar además las operaciones que se resumen en la siguiente tabla.

ms transform f 

Transforma todos los valores asociados en el mapa ms con la función f.

ms retain p 

se queda sólo con esas asignaciones en ms que tienen un key satisfacer predicado p.

---

one-zero-zero-one comentarios:

retain y transform son esencialmente versiones de mutación en lugar de filter y map, respectivamente, y se pueden definir fácilmente en Set y Buffer.
No veo cómo son Map -específicas.

Yo diría que retain y transform ofrecen implementaciones-mapa específico (en que su aplicación se ocupa específicamente de claves y valores) para características como los proporcionados por map y filter de TraversableLike.

La implementación de transform en Set y Buffer agregará poco valor, ya que simplemente deffer a map.

---

Nota: Michael Kebe comentarios:

Una cosa más. immutable.MapLike tiene el método transform, pero no el método retain.

(en contraposición a mutable.MapLike que tiene ambos)

Esto parece sin embargo, en línea con la naturaleza de transformation operations si transformada produce un nuevo mapa por filtrado y transformación de las consolidaciones de un mapa existente.

Aquí es el source code for transform

def transform[C, That](f: (A, B) => C)(implicit bf: CanBuildFrom[This, (A, C), That]): That = { 
    val b = bf(repr) 
    for ((key, value) <- this) b += ((key, f(key, value))) 
    b.result 
} 

Source code for retain, sin embargo, modificar la instancia actual, que sólo puede ser compatible con los objetos mutables:

/** Retains only those mappings for which the predicate 
* `p` returns `true`. 
* 
* @param p The test predicate 
*/ 
def retain(p: (A, B) => Boolean): this.type = { 
    for ((k, v) <- this ; if !p(k, v)) 
    this -= k 

    this 
}