inconsistenza di scala 2.8 collezioni?

Question

perché i metodi transform (sul posto versione mutazione del map) e retain (sul posto versione mutazione del filter) sono definiti solo su mutable.Map ma non su mutable.Buffer e mutable.Set? shouldnt tutte le collezioni mutabili supportano questi metodi?

Answer 1

Le operazioni retain e transform di Map sono sulle chiavi e valori, concetti che non fanno parte di un Set o un Buffer.

Una mappa è un Iterable costituito da coppie di chiavi e valori (denominati anche associazioni o associazioni).
Le operazioni fondamentali sulle mappe sono simili a quelle sui set.

Ma le operazioni sono elencati in:

mappe Mutevole sostenere oltre le operazioni riassunte nella tabella seguente.

ms transform f 

Converte tutti i valori associati nella cartina ms con funzione f.

ms retain p 

Mantiene solo quelle mappature in ms che hanno un key soddisfacente predicato p.

---

one-zero-zero-one commenti:

retain e transform sono essenzialmente in-place versioni mutazione di filter e map rispettivamente, e possono essere facilmente definiti in Set e Buffer.
Non vedo come sono Map -specific.

Direi che retain e transform offerta conforme alla Mappa implementazioni (in quanto la loro applicazione si occupa specificamente di chiavi e valori) per le caratteristiche come quelli forniti da map e filter da TraversableLike.

L'implementazione di transform in Set e Buffer aggiungerebbe poco valore dato che sarebbe semplicemente differito a map.

---

Nota: Michael Kebe commenti:

più una cosa. immutable.MapLike ha il metodo transform, ma non il metodo retain.

(al contrario di mutable.MapLike che ha sia)

Questo sembra tuttavia in linea con la natura delle transformation operations se trasformare produce una nuova mappa filtrando e trasformando legature di una mappa esistente.

Ecco la 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, tuttavia, ha modificato l'istanza corrente, che può essere compatibile solo con oggetti mutabili:

/** 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 
}