Remplacer chaque occurrence d'un élément par un autre élément

Question

Quelle est la meilleure façon pour Scala de remplacer à partir d'une liste chaque occurrence d'élément x par un autre élément y? C'est ce que je fais en ce moment:

list map { 
    case `x` => y 
    case a => a 
} 

Y at-il plus de façon concise disponible? Merci.

Answer 1

list.map(i => if (i==x) y else i) 

Pourquoi pas?

Answer 2

Vous pouvez créer méthode personnalisée pour remplacer:

class RichIterable[E] (col: Iterable[E]) { 
    def replace(pairs: (E, E)*): Iterable[E] = col map { 
     a => pairs.find(_._1 == a) match { 
      case None => a 
      case Some(p) => p._2 
     } 
    } 
} 

object RichIterable { 
    implicit def iterable2RichIterable[A](col: Iterable[A]) = 
     new RichIterable(col) 
} 

éléments Remplacement devraient alors être facile:

scala> import RichIterable._ 
import RichIterable._ 
scala> List(1, 2, 3, 4, 5, 4, 3, 4, 7).replace(3 -> 30, 4 -> 40) 
res1: Iterable[Int] = List(1, 2, 30, 40, 5, 40, 30, 40, 7) 

Answer 3

Si vous devez faire beaucoup, vous pourriez écrire une fonction utilitaire:

def replace[T](x: T, y: T) = (i: T) => if (i == x) y else i 

Ceci vous permettrait d'écrire

list map replace(x, y) 

Ou, pour la syntaxe infixe:

class ReplaceWith[T](x: T) { 
    def replaceWith(y: T) = (i: T) => if (i == x) y else i 
} 
object ReplaceWith { 
    implicit def any2replaceWith[T](x: T) = new ReplaceWith(x) 
} 

// now you can write 
list map (x replaceWith y) 

---

Une autre solution consiste à utiliser une carte:

list map Map(x -> y).withDefault(identity) 

Avec une fonction utilitaire:

scala> def replace[T](pairs: (T, T)*) = Map(pairs: _*).withDefault(identity) 
replace: [T](pairs: (T, T)*)scala.collection.immutable.Map[T,T] 

scala> List(1,2,3) map replace(1 -> -1, 3 -> 4) 
res0: List[Int] = List(-1, 2, 4)