Scala alternative à la série d'instructions if qui s'ajoutent à une liste?

Question

J'ai un Seq[String] dans Scala, et si le Seq contient certains String s, j'ajoute un message pertinent à une autre liste.

Existe-t-il une façon plus «scalaesque» de faire cela, plutôt qu'une série d'instructions if qui s'ajoutent à une liste comme ci-dessous?

val result = new ListBuffer[Err]() 

val malformedParamNames = // A Seq[String] 

if (malformedParamNames.contains("$top")) result += IntegerMustBePositive("$top") 
if (malformedParamNames.contains("$skip")) result += IntegerMustBePositive("$skip") 
if (malformedParamNames.contains("modifiedDate")) result += FormatInvalid("modifiedDate", "yyyy-MM-dd") 
... 

result.toList 

Answer 1

Si vous souhaitez utiliser une scala iterables sucre J'utiliser

sealed trait Err 
case class IntegerMustBePositive(msg: String) extends Err 
case class FormatInvalid(msg: String, format: String) extends Err 

val malformedParamNames = Seq[String]("$top", "aa", "$skip", "ccc", "ddd", "modifiedDate") 

val result = malformedParamNames.map { v => 
    v match { 
    case "$top" => Some(IntegerMustBePositive("$top")) 
    case "$skip" => Some(IntegerMustBePositive("$skip")) 
    case "modifiedDate" => Some(FormatInvalid("modifiedDate", "yyyy-MM-dd")) 
    case _ => None 
    } 
}.flatten 


result.toList 

Soyez avertira si vous demandez chemin scala-esque de faire les choses, il y a beaucoup de possibilités.

La fonction de carte combinée à Aplatir peut être simplifiée en utilisant flatmap

sealed trait Err 
case class IntegerMustBePositive(msg: String) extends Err 
case class FormatInvalid(msg: String, format: String) extends Err 

val malformedParamNames = Seq[String]("$top", "aa", "$skip", "ccc", "ddd", "modifiedDate") 

val result = malformedParamNames.flatMap { 
    case "$top" => Some(IntegerMustBePositive("$top")) 
    case "$skip" => Some(IntegerMustBePositive("$skip")) 
    case "modifiedDate" => Some(FormatInvalid("modifiedDate", "yyyy-MM-dd")) 
    case _ => None 
} 


result 

Answer 2

Benoit c'est probablement le moyen le plus scala-esque de le faire, mais en fonction de qui va être lire le code plus tard, vous pourriez veux une approche différente.

// Some type definitions omitted 
val malformations = Seq[(String, Err)](
    ("$top", IntegerMustBePositive("$top")), 
    ("$skip", IntegerMustBePositive("$skip")), 
    ("modifiedDate", FormatInvalid("modifiedDate", "yyyy-MM-dd") 
) 

Si vous avez besoin d'une liste et l'ordre est siginificant:

val result = (malformations.foldLeft(List.empty[Err]) { (acc, pair) => 
    if (malformedParamNames.contains(pair._1)) { 
    pair._2 ++: acc // prepend to list for faster performance 
    } else acc 
}).reverse // and reverse since we were prepending 

Si l'ordre est non significatif (bien que si l'ordre est non significatif, vous pourriez envisager de vouloir un ensemble au lieu d'une liste):

val result = (malformations.foldLeft(Set.empty[Err]) { (acc, pair) => 
    if (malformedParamNames.contains(pair._1)) { 
    acC++ pair._2 
    } else acc 
}).toList // omit the .toList if you're OK with just a Set 

Si les prédicats dans les ifs répétées sont plus complexes/moins uniforme, le type de malformation peut-être besoin de changer, comme ils le feraient si les réponses changé, mais le modèle de base est v Etre flexible.

Answer 3

La plupart version « scalesque » Je peux penser tout en gardant lisible serait:

val map = scala.collection.immutable.ListMap(
    "$top" -> IntegerMustBePositive("$top"), 
    "$skip" -> IntegerMustBePositive("$skip"), 
    "modifiedDate" -> FormatInvalid("modifiedDate", "yyyy-MM-dd")) 

val result = for { 
    (k,v) <- map 
    if malformedParamNames contains k 
} yield v 

//or 

val result2 = map.filterKeys(malformedParamNames.contains).values.toList