Scala, case, Option, None et Some

Note importante : au moment où j’écris ces lignes, je découvre Scala. Cet article n’est pas destiné à être une référence. Il ne prétend pas être exhaustif, exact et parfait. Lisez en fin d’article les commentaires qui complètent et corrigent certains points incorrects. Merci à Alexandre encore une fois pour son retour.

Après un article d’introduction sur Scala puis un autre sur les Traits et les Collections, nous allons parler un peu de Pattern Matching.

Prenons un exemple en Java pour comprendre. Je dois retourner une image selon la catégorie d’une annonce. Si l’annonce est de type CDI, je souhaite retourner un logo CDI.png. Si l’annonce est de type CDD, un autre logo, etc. En Java il n’est pas possible d’utiliser des String dans des boucles switch/case. Voici la version Java:

 public static String getURLForJobType(String type) {
        if (type == null || type.trim().equals("")) return null;

        if (type.equalsIgnoreCase("cdi")) {
            return "/public/images/icons/cdi.png";
        }
        if (type.equalsIgnoreCase("cdd")) {
            return "/public/images/icons/cdd.png";
        }
        if (type.equalsIgnoreCase("stage")) {
            return "/public/images/icons/stage.png";
        }
        if (type.equalsIgnoreCase("apprentissage")) {
            return "/public/images/icons/cpp.png";
        }
        if (type.equalsIgnoreCase("autre")) {
            return "/public/images/icons/other.png";
        }
        return null;
    }

Scala comme en C# est capable de matcher une expression quelque soit son type. Cela permet de reprendre le code ci-dessus, et d’écrire :

object TestPattern {
  def main(args: Array[String]) {
    println("Test Scala: " + getURLForJobType("CDI"))
  }

  def getURLForJobType(typeContrat: String): String = typeContrat.toLowerCase match {
    case "cdi" => "/public/images/cdi.png"
    case "stage" => "/public/images/icons/stage.png"
    case "contrat d'apprentissage" | "contrat de professionalisation" => "/public/images/icons/cpp.png"
    case "autre" => "/public/images/icons/other.png"
    case _ => "/public/images/noimages.png"
  }

}

La version Scala permet de matcher sur des chaînes de caractères et de traiter les cas multipe avec l’opérateur « | ».

En Scala, tout est une instance d’une classe (sauf les méthodes) ([update : voir le commentaire d’Alexandre plus bas). Les primitives Java comme int sont traitées comme des instances par le compilateur Scala. C’est une opération qui s’effectue lors de la compilation et de la génération du bytecode Java. Celui-ci est d’ailleurs optimisé. Donc l’addition de 2 Ints en Scala donne exactement le même bytecode que l’addition de 2 int en Java. Et donc, il n’y a pas de dégradation des performances, Scala reste aussi efficace que Java. Lorsque le compilateur Scala doit par exemple stocker un Int dans une Map, celui-ci stocke la primitive dans une boîte.

En Scala, les primitives sont donc représentées par les classes Int, Long, Double, Float, Boolean, Char, Byte et Short. Toutes ces classes dérivent de la classe Any. Celle-ci est dérivée en AnyRef et AnyVal.
Scala a aussi une représentation de void appelée Unit. Cela vous permet donc de retourner explicitement l’équivalent de void dans les traitements.
Unit se note simplement avec une parenthèse ouvrante/fermante : ()

Très pratique, il est aussi possible d’utiliser plusieurs types dans la même expression :

object TestPattern {
  def main(args: Array[String]) {
    println("Test with an Int: " + getURLForJobType2(555))
    println("Test with a Float : " + getURLForJobType2(10.33))
  }

  def getURLForJobType2(typeContrat: Any) = typeContrat match {
     case "cdi" => "/public/images/cdi.png"
     case "stage" => "/public/images/icons/stage.png"
     case 555 => "matched an Int"
     case 10.33 => "matched a Float"
     case _ => None
   }

}

L’argument « typeContrat » est maintenant de type Any. L’underscore est équivalent à default en Java et permet de matcher tout.

Options, Some et None : éviter les nulls
Comment pourrions-nous maintenant aller plus loin et traiter le cas où typeContrat serait null ?
La classe Option et ses 2 classes dérivées Some et None sont très simples à utiliser.

En Java, nous sommes habitués à utiliser null lorsque nous souhaitons affecter ou vérifier la valeur d’une référence. En Scala, tout est objet comme dit plus haut. C’est donc logiquement que Scala vous encourage à utiliser le type Option pour les variables et les retours de fonctions. Lorsqu’il n’y a aucunes valeurs, utilisez None. Lorsqu’il y a une valeur, vous pouvez utiliser Some pour wrapper la valeur.

Modifions notre méthode afin qu’elle retourne le type Option dérivé soit en None, soit en Some.

object TestPattern {

  def main(args: Array[String]) {
    println("Test with a String : " + getURLForJobType("CDI").get )
    println("Test with an Int   : " + getURLForJobType(3).get )
    println("Test with a bad value : " + getURLForJobType("Bad Entry").getOrElse("Not a valid value"))


  }

  def getURLForJobType(typeContrat: Any) : Option[Any] = typeContrat match {
    case "CDI" => Some("/public/images/" + typeContrat + ".png")
    case 3 => Some("/public/images/" + typeContrat + "_icon.png")
    case _ => None
  }

}
// Execution
Test with a String : /public/images/CDI.png
Test with an Int   : /public/images/3_icon.png
Test with a bad value : Not a valid value

Notez à la ligne 4 l’utilisation de l’opérateur get qui retourne la valeur d’une option. A la ligne 10 j’ai aussi modifié la signature de ma méthode afin de spécifier que je retourne un objet Option. A la ligne 6 la fonction getOrElse permet de s’assurer qu’une valeur sera utilisée même si la fonction appelée venait à retourner None. En règle général, en Scala la vérification à priori des arguments d’une méthode devient inutile. Nous verrons que le if/then/else tend à être remplacé par des « cases », ce qui est plus simple à lire d’une part. Je trouce que le plus important est ce passage du mode « je vois une méthode » à un mode « je vois une fonction ». Une fonction traite tous les arguments et retourne un résultat. La valeur None est un résultat valide. Cela permet de gérer les cas limites, d’améliorer la qualité de votre code, et de s’approcher de la vision « fonction » de Scala.

Pattern Matching et les listes
Un petit aperçu des possibilités de Scala maintenant sur le traitement des Lists avec la notion de Pattern Matching. Si par exemple je souhaite effectuer la somme de toutes les valeurs paires d’une Liste, je peux utiliser pour cela une expression simple :

object TestPattern {

  def main(args: Array[String]) {
    val myList = List(1, 2, 3, 4, 5, 6)
    val emptyList = List()
    val emptyList = Nil

    println("Sum of Evens in list: " + sumEven(myList))
    println("Sum of empty list: " + sumEven(emptyList))
    println("Sum of a Nil : " + sumEven(nullList))

  }

  def sumEven(in: List[Int]): Int = in match {
    case Nil => 0 // liste vide
    case x :: rest if x % 2 == 0 => x + sumEven(rest)
    case _ :: rest => sumEven(rest)
  }
}

// Execution
Sum of Evens in list: 12
Sum of empty list: 0
Sum of a Nil : 0

Si la liste est vide (Nil) alors la fonction retourne 0. Si par contre nous avons un entier, la fonction vérifie s’il s’agit d’un nombre pair pour ensuite l’additionner. Le plus intéressant est la ligne 17. Le caractère underscore signifie « n’importe quelle valeur du début de la liste à la valeur de la variable rest« . C’est en quelques sortes une plage de valeur dynamique. Ici nous prenons la première valeur de la liste et nous appelons de manière récursive la fonction sumEven.
A noter qu’ici x et rest ne sont pas des mots clés spéciaux, simplement le nom de variables. Vous pourriez les appeler courant et restant, cela fonctionnerait aussi.

 // suite
 def sumEven(in: List[Int]): Int = in match {
    case Nil => 0 // liste vide
    case courant :: restant if courant % 2 == 0 => courant + sumEven(restant)
    case _ :: restant => sumEven(restant)
  }

Conclusion
C’est tout pour aujourd’hui. Je parlerai un peu de l’histoire de Scala et de son fondateur la fois prochaine. Nous verrons les Actors, une notion particulièrement intéressante en Scala. Et puis je vous parlerai aussi de 3 livres sur Scala, vous verrez par lesquels commencer pour bien apprendre et ne pas se décourager.

A bientôt !

Articles similaires:

Scala, partie 1 Présentation de Play! Scala au Scala User Group Le gars qui connaît Scala et celui qui débute Soirée Scala au Paris JUG