Le document présente un aperçu du langage Scala, détaillant son historique, ses caractéristiques, et ses outils tels que SBT et REPL. Il aborde également des concepts essentiels comme les classes, traits, pattern matching, et les types de collections, ainsi que l'utilisation de la bibliothèque de tests ScalaTest. Enfin, des ressources pour approfondir la compréhension de Scala sont fournies.

1. SCALA
Université des languages
Fabrice Sznajderman

2. Roadmap
Présentation du language Scala
Les labs
Debriefs

3. Historique
➢ 2001 : Création du langage par Martin Odersky
➢ 2003 : 1.0
➢ 2006 : 2.0
➢ 2008 : 2.8
➢ 2011 : 2.09
➢ fin 2012 : 2.10
➢ juin 2015 : 2.11.7
➢ janvier 2016 : 2.12

4. Généralités
➢ Scala pour Scalable Langage
➢ Language fonctionnel / objet
➢ Fonctionnant sur la JVM
➢ Interopérabilité avec la plate-forme .NET

5. Environnement et outils

6. Outils - SBT overview
● Comparable à Maven
● Compilation incrémentale à l'aide d'informations fournies par le compilateur
● Compilation et lancement des tests en continu
● Support natif des principaux frameworks de tests Scala (Junit via un
plugin)
● Exécution en parallèle des tâches (ainsi que les tests unitaires)
● Gestion de projet simple ou multi-projets
● Basé sur le principe de convention over configuration
● Continous testing

7. Outils - REPL
● Appréhender la syntaxe et tester rapidement du code
● Pratique et économique en ressources
● Convient plus à des fonctions simples qu'à tester des designs
entiers avec des classes / traits et autres
● Excellent outil d'apprentissage permettant de se familiariser
avec le langage et d’appréhender la mécanique de typage fort
Scala
● Ce n'est pas une nouveauté dans le monde de la
programmation fonctionnelle;Haskell dispose aussi d'un REPL
● Démo >

8. Outils - WorkSheet
● REPL graphique
● Disponible dans IDEA et Scala IDE
● Meilleurs support dans Scala IDE
● Démo >

9. Introduction au language

10. Scaladoc
Par rapport à la java doc, elle offre des
fonctionnalités supplémentaires.
http://www.scala-lang.org/api/current/#package

11. Déclaration d’une variable
val a: Int = 2
var a: Int = 4
val a = 5

12. Déclaration d’une fonction
def f(a:Int,b:Int):Int = {a+b}
def f(a:Int,b:Int) = a+b
val f = (a:Int,b:Int) => a+b

13. object : Introduction
Une ‘classe’ déclarée object est un singleton.
Scala nous garantit qu’il n’existera qu’une seule
instance dans la JVM.

14. object : Exemple
Déclaration:
object MonObject {
def inc(n:Int):Int=n+1
}
Utilisation:
MonObject.inc(1)

15. Déclaration d’une classe
class Eleve(age:Int)
class Eleve(val age:Int)
class Eleve(var age:Int)

16. Déclaration d’une case classe
case class Eleve(age:Int)
case class Eleve(val age:Int)
case class Eleve(var age:Int)

17. Une case classe c’est quoi?
➢ Déclaration simplifiée
➢ Exposition des paramètres du constructeur
➢ Attribut en lecture seul
➢ Constructeur sans l’opérateur new
➢ Equals & hashcode fournis par défaut
➢ Décomposable

18. Traits
➢ Proche des interfaces Java
➢ Mais peut contenir du code
➢ Beaucoup de traits au coeur du langage.
➢ Héritage simple de code (classe) comme en
Java mais héritage multiple de traits

19. Traits
S'utilise d'une manière similaire à une interface
en Java
➢ Si la classe n'hérite pas explicitement d'une
autre , alors héritage du trait avec le mot clé
extends
➢ Dans le cas contraire utilisation du mot clé
with

20. Déclaration d’un trait
trait SimpleTrait {
def log: Unit = (println("from SimpleTrait"))
}
trait SecondSimpleTrait {
def display:Unit=(println("from SecondSimpleTrait"))
}

21. Utilisation d’un trait
object MainRunner extends App{
class SimpleTraitUser extends SimpleTrait
class BothSimpleTraitUSer extends SimpleTrait with SecondSimpleTrait
val stu = new SimpleTraitUser()
val sstu = new BothSimpleTraitUSer()
stu.log
sstu.log
sstu.display
}

22. Equals vs ==
obj1 == obj2
>> va comparer l’égalité des objets via equals() et
hashcode()
(Il faut redéfinir les méthodes hashcode() et equals())

23. Pattern matching
➢ Structure conditionnelle avancée
➢ Test sur des types
➢ Décomposition des cases classes

24. Soit la case classe Humain
case class Humain(name:String, age:Int)

25. Pattern matching : Exemple
val choice = 2
choice match {
case 1 | 2 | 3 => "yes"
case 0 => "no"
case _ => "error"
}
val humain = Humain(“Paul”, 35)
humain match {
case Humain("Louis", _) => "c’est Louis"
case Humain("Paul", _) => "C’est Paul"
case _ => "C’est personne"
}

26. Type Option
Le type Option[A] permet de caractériser la
présence ou l’absence d’une valeur.
Ce type abstrait possède deux types concrets :
● None : L’absence d’une valeur
● Some : La présence d’une valeur

27. Le type Option
val présent:Option[Int] = Some(10)
val absent = None

28. Le type Option
def getVoiture(idx:Int):Option[Voiture]
getVoiture(10) match {
case Some(v) => println(Voiture)
case None => println(“voiture non trouvée”)
}

29. Notions d’implicit
➢ Ce mécanisme d’implicit permet de réaliser
une conversion.
➢ Outil très puissant et utile, mais il faut l’
utiliser avec précaution.
➢ Permet de faire de la conversion ou d’ajouter
du comportement dynamique à une classe

30. Notions d’implicit
val stringNumber = "123"
val y: Int = stringNumber
Résultat : Error!
math.max(stringNumber, 111)
Résultat : Error!
Il faut créer un convertisseur implicit pour régler le problème =>

31. Notions d’implicit
Définition d’une fonction de conversion
implicit def strToInt(x: String) = x.toInt

32. Notions d’implicit
val stringNumber = "123"
val y: Int = stringNumber
Résultat : Int = 123
math.max(stringNumber, 111)
Résultat : Int = 123

33. Les Collections : Les types de collections
➢ Traversable
○ Définition du comportement minimal d’un collection
➢ Iterable
○ Itération sur l’ensemble des éléments de la collection
➢ Seq
○ Ensemble d’éléments ordonnés
➢ Set
○ Ensemble d’éléments sans dupliqua
➢ Map
○ Ensemble d’éléments Clef-Valeur

34. Traversable[T]
Iterable[T]
Map[T]Set[T]Seq[T]

35. Les Collections : Les types de collections

36. Les Collections : Types de collections courants
➢ val numbers = List(1, 2, 3, 4)
➢ val set = Set(1, 1, 2) // résultat [1,2]
➢ val kv = Map(1 -> 2, 2-> 5)
➢ val seq = Seq(1, 2, 3)

37. Les Collections : Fonctions sur les collections
➢ map()
➢ filter()
➢ flatmap()
➢ foreach()
➢ etc

38. Les Collections : Exemple fonction map()
case class Eleve(name:String, age:Int)
val e1 = Eleve("michel", 30)
val e2 = Eleve("Louis", 18)
val e3 = Eleve("Patrick",23)
val eleves = List(e1, e2, e3)
val ages = eleves.map(e => e.age) //transformation de la liste d’élèves

39. Les Collections : Exemple fonction map()
Résultat après exécution :
eleves = List(Eleve(michel,30), Eleve(Louis,18), Eleve
(Patrick,23))
ages : List(30, 18, 23)

40. Les Collections : Exemple fonction filter()
val filteredEleves = eleves.filter { e => e.age >= 18 }
println(filteredEleves)
Résultat après exécution :
filteredEleves = List(Eleve(michel,30), Eleve(Patrick,23))

41. Les Collections : Monade
Selon les propriétés monadique des collections en Scala, il
est possible de chaîner les opérations réalisées sur une
collection :
println(eleves.filter(e => e.age > 18).map(e => e.age))
Résultat :
List(30, 23)

42. Test : ScalaTest - introduction
Il existe plusieurs librairies pour écrire des tests en Scala.
Nous utiliserons pour les labs ScalaTest avec l’API
FunSuite.
Cette Librairie ressemble de très près à l’approche JUnit
mais avec la simplification de la description du use-case
couvert par le test.

43. Test : ScalaTest
class ExempleTest extends FunSuite {
test("Description du use case") {
assert(3 == 3);
}

44. Ressources pour aller plus loin
● https://twitter.github.io/scala_school/index.html
● http://twitter.github.io/effectivescala/
● http://daily-scala.blogspot.fr/
● https://www.typesafe.com/community/core-
projects/scala
● Livre : programming Scala (bibliothèque Zenika)
● ...

45. LABs

46. Debrief