Université des langages scala

SCALA
Université des languages
Fabrice Sznajderman

Roadmap
Présentation du language Scala
Les labs
Debriefs

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

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

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

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 >

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

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

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

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

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.

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

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

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

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

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

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

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

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
}

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

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

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

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"
}

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

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

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

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

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 =>

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

val stringNumber = "123"
val y: Int = stringNumber
Résultat : Int = 123
math.max(stringNumber, 111)
Résultat : Int = 123

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

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

Les Collections : Les types de collections

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)

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

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

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)

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))

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)

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.

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

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)
● ...

Université des langages scala

Contenu connexe

Tendances (19)

En vedette (20)

Similaire à Université des langages scala (20)

Plus de Fabrice Sznajderman (6)

Université des langages scala