Slides in french

Slides in french
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Génie Logiciel, logiciels Répartis et Embarqués
Introduction à Scala
Mathieu Giorgino
Doctorant 3e année IRIT, équipe ACADIE
Inspiré d’une présentation de Simon Chemouil et Luc Pons
09/06/2011
Scala – Intro
Mathieu Giorgino
1 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
If I were to pick a language to use today other than Java,
it would be Scala
James Gosling, créateur de Java
Scala – Intro
Mathieu Giorgino
2 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Java
Plan
1
Introduction
Java
Scala
Scala – Intro
Mathieu Giorgino
3 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Java
JVM pratique et performante
“Write once. Run everywhere”
Multi-plateforme
Des JVM (“Java Virtual Machine”) existent pour chaque
plateforme matérielle et chaque système d’exploitation majeur
Les spécifications de la JVM sont ouvertes et il existe une
implémentation libre (OpenJDK)
Optimisations de la JVM “HotSpot”
Compilation Just-In-Time (JIT) du bytecode
Optimisation adaptative
Ramasse-miette générationnel parrallèle G1
Scala – Intro
Mathieu Giorgino
4 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Java
Un existant conséquent
Une bibliothèque standard bien fournie
Collections, Swing, XML
D’autres librairies spécialisées : JEE, J2ME
Nombreuses librairies existantes
De nombreux outils
Eclipse, Netbeans, outils de profilage, debogueurs, ...
Un investissement pour les entreprises
Très larges bases de code
Expertise
Confiance
Scala – Intro
Mathieu Giorgino
5 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Java
Les limites de Java
Verbeux
Pas d’inférence de type (bool a = true, ...)
Code banal syntaxiquement lourd (getters/setters, for, ...)
Trop simple
Pas de fonctions d’ordre supérieur
Pas d’héritage multiple (mieux que C++ mais trop simple)
Peu concurrent (multi-coeurs, systèmes répartis)
Impératif : difficile à paralléliser
Objets mutable : synchronisation nécessaire
D’où : deadlocks, mauvaises performances, famines, ...
Scala – Intro
Mathieu Giorgino
6 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Scala
Plan
1
Introduction
Java
Scala
Scala – Intro
Mathieu Giorgino
7 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Scala
Histoire
A Scalable language
“Scala” = escalier en italien
Conçu en 2002 par Martin Odersky a à l’EPFL b
Objectif : Unifier les paradigmes Objet et Fonctionnel
a. Auteur des “Generics” dans Java 1.5 et du compilateur javac
b. Ecole Polytechnique Fédérale de Lausanne
Maintenant
Une grande communauté avec de nombreux contributeurs
Un intérêt grandissant dans la recherche
Utilisé par de nombreuses entreprises : Twitter, Amazon,
Ebay, LinkedIn, EDF, Siemens, Xerox, Sony, ...
Scala – Intro
Mathieu Giorgino
8 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Scala
Paradigmes
Un Langage fonctionnel : Concision, Concurrence
Inférence de type
Types paramétriques (“Generics”)
Données immutables priviligiées
Les fonctions sont des valeurs (objets)
Un Langage orienté-objet : Composition
Tout est objet : pas de cas particuliers (types primitifs)
Héritage, sous-typage
Les composants sont des valeurs
Scala – Intro
Mathieu Giorgino
9 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Scala
Pourquoi les deux ?
Extensibilité
Orienté objet :
Facile de rajouter d’autres sous-classes
Difficile de rajouter des opérations (pattern du visiteur un peu
lourd)
Fonctionnel :
Facile de rajouter des opérations
Difficile de rajouter des sous-classes (datatypes)
Les deux sont possibles grace à l’ajout du pattern matching
dans un langage orienté objet
Scala – Intro
Mathieu Giorgino
10 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Scala
Originalité
Une syntaxe souple, unifiée et extensible
Tout est expression (instruction = expression de type Unit)
Paramètres par noms, répétés et implicites
XML, DSL (Domain Specific Languages)
Annotations définies par l’utilisateur
Plus de 2 fois moins verbeux que Java en moyenne
Interoperabilité Java avancée (et .NET)
Utilisation des librairies existantes
Types compatibles (Int, Boolean, collections, ...)
Exécution sur la JVM
Scala – Intro
Mathieu Giorgino
11 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Scala
Des outils actualisés : Interpréteur (REPL)
REPL : Read-Eval-Print Loop
Scala – Intro
Mathieu Giorgino
12 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Scala
Des outils actualisés : scala-doc
Scala – Intro
Mathieu Giorgino
12 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Syntaxe élémentaire
Plan
2
De Java à Scala
Syntaxe élémentaire
Classes
Scala – Intro
Mathieu Giorgino
13 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Syntaxe élémentaire
Variables et constantes
Java
final String s = "abc";
double vx = 21;
double vy = 42.;
final HashSet<Integer> hs
= new HashSet<Integer>();
boolean b = s.equals("abc");
Scala
val
var
var
val
s = "abc"
vx:Double = 21
vy = 42.
hs = new HashSet[Int]()
var b = (s == "abc")
Distinction variable/constante avec var/val
Point-virgules optionnels
Indication du type (optionnelle) : “x:Type”
Paramètres de types (“Generics”) : “Type[Param]”
“==” appelle equals (égalité de références : “eq”)
Scala – Intro
Mathieu Giorgino
14 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Syntaxe élémentaire
Conditionnelles
Java
if (a == 1){
...
} else {
...
}
int i = (k < 2) ? 4 : 5
Scala
if (a == 1){
...
} else {
...
}
val i = if (k < 2) 4 else 5
Instruction = expression de type Unit
{...} : groupement d’instructions, portée des variables
Le type du groupement est le type de sa dernière expression
Scala – Intro
Mathieu Giorgino
15 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Syntaxe élémentaire
Boucles : While
Java
int x = 0;
while (x < 100) {
x += 11;
}
do {
x -= 9;
} while (x > 0);
Scala
var x = 0
while (x < 100) {
x += 11
}
do {
x -= 9
} while (x > 0)
Même syntaxe aux points-virgules près
Scala – Intro
Mathieu Giorgino
16 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Syntaxe élémentaire
Boucles : For
Java
String s = "";
int n = args.length;
for (int i = 0; i < n; i++){
s += args[i];
}
for (String arg : args){
s += arg;
}
Scala
var
val
for
s
}
for
s
}
s = ""
n = args.length
(i <- 0 until n){
+= args(i)
(arg <- args){
+= arg
Une syntaxe unifiée : for (... <- ...) ...
A droite de <- : une collection (entre autres ...)
1 to 5 = 1.to(5) = Range(1,2,3,4,5)
Et plus : c.f. slide 45
Scala – Intro
Mathieu Giorgino
16 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Syntaxe élémentaire
Exceptions
Scala
Java
class E1 extends
class E2 extends
try { ...; throw
catch(E1 e){ ...
catch(E2 e){ ...
finally { ... }
Exception
Exception
new E1();}
}
}
class E1 extends Exception
class E2 extends Exception
try { ...; throw new E1() }
catch {
case e:E1 => { ... }
case e:E2 => { ... }
} finally { ... }
Pas de distinction Exception/RuntimeException
Toutes les exceptions sont “hors-contrôle” (mais l’annotation
@throws(classOf[...]) existe)
Argument de catch : pattern matching (c.f. slide 33)
Scala – Intro
Mathieu Giorgino
17 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Syntaxe élémentaire
Identifieurs
val
val
val
val
abcXyz132_ef:Int = 4
aB_c0_+<: :Int = 4
~+? :Int = 4
‘class +-*var?‘:Int = 4
opchar = !#$%&*+-/<>=?@\^|~
identifier =
[a-zA-Z_][0-9a-zA-Z_]*
[a-zA-Z_][0-9a-zA-Z_]*_opchar+
opchar+
‘...‘
Scala – Intro
Mathieu Giorgino
18 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Syntaxe élémentaire
Méthodes : Définition
def
def
def
def
def
meth(p1:Type1, p2:Type2, ...){ ... }
meth(p1:Type1, p2:Type2, ...) = { ... }
meth(p1:Type1, p2:Type2, ...):TypeR = { ... }
+(p1:Type1, p2:Type2, ...):TypeR = { ... }
+:(p1:Type1, p2:Type2, ...):TypeR = { ... }
Mot clé def
Sans “=” : procédure (type de retour Unit)
Type de retour obligatoire pour les méthodes récursives
Dans une classe : méthode
Dans une expression : fonction, méthode locale (clôture)
Scala – Intro
Mathieu Giorgino
19 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Syntaxe élémentaire
Méthodes : Appel
a.meth()
a.meth(b)
a.meth_:(b)
a.+(b)
a.+:(b)
a.unary_!()
=
=
=
=
=
=
a meth
a meth b
b meth_: a
a+b
b+:a
!a
0 argument : postfix
1 argument : infix associatif à gauche
Fini par “:” : infix associatif à droite
unary_{+,!,-,~} : prefix
Scala – Intro
Mathieu Giorgino
19 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Classes
Plan
2
De Java à Scala
Syntaxe élémentaire
Classes
Scala – Intro
Mathieu Giorgino
20 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Classes
Définition : Comparaison avec Java
Java
public class Student {
private final String name;
private int age;
public Student(String name, int age){
this.name = name;
setAge(age);
}
public String getName() { return name; }
public int getAge() { return age; }
public void setAge(int age) {
this.age = age;
} }
Scala
class Student(val name:String, var age:Int)
Scala – Intro
Mathieu Giorgino
22 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Classes
Constructeurs
class Student /* mod */ (val name:String, var age:Int){
private var friends = Map(name -> this)
def this(name:String) = this(name, 42)
def this() = this("Jack")
...
Constructeur principal défini par les paramètres et le corps de
la classe
Constructeurs secondaires = méthodes nommées this(...)
Chaque constructeur secondaire doit appeler un autre
constructeur
/* mod */ : modifieurs du constructeur principal (private,
protected)
Modifieurs de la classe devant class
Scala – Intro
Mathieu Giorgino
23 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Classes
Attributs
class Student(val name:String, /* mod */ var age:Int){
private var friends = Map(name -> this)
val initialAge = age
...
Modifieurs
val : attribut immutable public (= privé + getter)
var : attribut mutable public (= privé + getter/setter)
En paramètre, ni val, ni var : attribut immutable privé si
utilisé dans la classe
/* mod */ : modifieurs des getter/setter (private,
protected)
Scala – Intro
Mathieu Giorgino
24 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Classes
Getters/Setters
class Memory (_value:Int){
var values:List[Int] = List(_value)
def value() = values.head
def value_=(v:Int) = { values = v::values }
def last(n:Int) = values.lift(n)
}
val m = new Memory(0)
m.value = 3 /* = m.value_=(3) */
println(m.value) /* = m.value() = 3 */
m.value = 4
println(m.last(2)) /* Some(0) */
println(m.last(3)) /* None */
Getter pour att : méthode att sans argument
Setter pour att : méthode att_=, utilisable sous la forme
o.att = ... si le getter correspondant existe
Scala – Intro
Mathieu Giorgino
25 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Classes
Objets : Modules, Singletons et static
public class A{
static int a = 0
static public int b() { ... }
...
}
A.b()
A.getA()
object A{
var a:Int = 0
def b():Int = { ... }
}
class A{ ... }
A.b()
A.a
Objet compagnon
Pas de modifieur static : remplacé par les objets
compagnons = un objet du même nom que la classe
correspondante (défini dans le même fichier)
Scala – Intro
Mathieu Giorgino
26 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Classes
Objets : Modules, Singletons et static
public class ID {
private int id;
public static ID getInstance()
...
public int next(){
id += 1;
return id;
} }
ID id = ID.getInstance();
println(id.next()) /* 1 */
println(id.next()) /* 2 */
object ID {
private var id = 0
def next() = {
id += 1
id
} }
println(ID.next()) /* 1 */
println(ID.next()) /* 2 */
Singleton
Pattern du singleton (public static getInstance())
Instancié une seule fois, accédé à l’aide de son nom
Scala – Intro
Mathieu Giorgino
26 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Classes
Objets : Modules, Singletons et static
public class Main {
public static void
main(String[] args){
for (String arg: args){
System.out.println(arg)
}
}
}
object Main extends App {
for (arg <- args)
println(arg)
}
Programme
trait App : permet de créer rapidement un programme
exécutable
Scala – Intro
Mathieu Giorgino
26 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Classes
Héritage
Java
public class Person{ ... }
public class Student extends Person {
private int age;
public void setAge(int age) { this.age = age }
public int getAge() { return age }
public Student(String name, int age) {
super(name); setAge(age); } }
Scala
class Person(val name:String)
class Student(name:String, var age:Int) extends Person(name)
Héritage ou implémentation : mot clé extends ! !
Le constructeur principal doit être appelé
Scala – Intro
Mathieu Giorgino
27 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Classes
Héritage
class Person(val name:String){
override def toString = name
/* override val toString = name */
}
class Student(name:String, var age:Int) extends Person(name){
override def toString = "Student(" + name + ", " + age + ")"
/* override val toString = ... */
}
override remplace l’annotation @Override mais :
obligatoire pour la redéfinition d’une valeur
optionnel pour l’implémentation d’une valeur abstraite
val/var (en fait le getter généré) peut redéfinir un def
Scala – Intro
Mathieu Giorgino
27 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Classes
Trait : Interface
Java
interface IAccount {
public deposit(int amount)
public int getBalance()
}
class Account
implements IAccount{
private int balance
public deposit(int amount){
balance += amount }
public getBalance() = balance
}
Scala
trait
def
def
}
class
IAccount {
deposit(amount:Int)
getBalance():Int
Account extends IAccount{
private var balance:Int
def deposit(amount:Int){
balance += amount }
def getBalance() = balance
}
Les traits remplacent les interfaces de Java
Héritage ou implémentation : mot clé extends
Scala – Intro
Mathieu Giorgino
28 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Classes
Trait : Sous-typage multiple
abstract class A { ... }
interface I1 {
public abstract R1 i1(T1 a)
}
interface I2 {
public abstract R2 i2(T2 a)
}
class Impl extends A
implements I1, I2
abstract class A {
trait I1 {
def i1(a:T1):R1
}
trait I2 {
def i2(a:T2):R2
}
class Impl extends
with I1 with I2{
def i1(a:T1) =
def i2(a:T1) =
}
... }
A
...
...
Héritage multiple : mot clé with
Les traits peuvent aussi contenir du code (c.f. slide 41).
Scala – Intro
Mathieu Giorgino
28 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Classes
Paquetages
package a
package b
package c
package
class C
val x
val y
val z
} }
{
{
{
b
{
=
=
=
class A }
class B }
{ class CB }
new /*_root_.*/a.A
new _root_.b.B
new /*_root_.c.*/b.CB
Référence au paquetage relative ou absolue
_root_ désigne le paquetage racine (ou “par défaut”)
Scala – Intro
Mathieu Giorgino
29 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Classes
Importations
La proposition
import p._
import p.x
import p.{x =>a}
import p.{x, y}
import p1.p2.z
rend disponible sans qualification
tous les membres de p (import p.* en Java)
le membre x de p
le membre x de p renommé a
les membres x et y de p
le membre z de p2, lui-même membre de p1
scala.Predef._, scala._ et java.lang._ sont importés
par défaut
Les membres sont des classes ou des membres des classes
Scala – Intro
Mathieu Giorgino
30 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
n-uplets
Plan
3
Les plus de Scala
n-uplets
Pattern Matching
Fonctions
Héritage multiple
For comprehension
Scala – Intro
Mathieu Giorgino
31 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
n-uplets
n-uplets
val a:(Int, String, Boolean) = (1, "abc", true)
println(a._1) /* 1 */
println(a _3) /* true */
Abbréviation de type : (T0, T1, ...)
Syntaxe : (v0, v1, ...)
Permet de regrouper plusieurs valeurs de types
potentiellement différents (produit cartésien)
Pratique pour retourner plusieurs valeurs
Classes sous-jacentes : Unit, Tuple{1,2,3,...,22}
Scala – Intro
Mathieu Giorgino
32 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Pattern Matching
Plan
3
Les plus de Scala
n-uplets
Pattern Matching
Fonctions
Héritage multiple
For comprehension
Scala – Intro
Mathieu Giorgino
33 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Pattern Matching
Switch : Int, String, Char, ...
def intToEnString(x: Int): String = x match {
case 1 => "one"
case 2 => "two"
case x if x < 10 => "many"
case _ => "many more"
}
println(intToEnString(3)) /* many */
val deux = "two"
def intFromEnString(s: String): Int = s match {
case "zero" => 0
case "one" => 1
case ‘deux‘ => 2
case _ => 3
}
println(intFromEnString("one")) /* 1 */
println(intFromEnString("two")) /* 2 */
Scala – Intro
Mathieu Giorgino
34 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Pattern Matching
Sur les types
def typeToString(x: Any):String = x match {
case (_:String) => "String"
case (_:Int) => "Int"
//case (_:List[Int]) => "List[_]" /* warning:unchecked */
case (_:List[_]) => "List"
case (_:Array[Int]) => "Array[Int]"
case _ => "?"
}
println(typeToString(2)) /* "Int" */
println(typeToString(List(42,2))) /* "List" */
println(typeToString(Array(1,2,3))) /* "Array[Int]" */
Scala – Intro
Mathieu Giorgino
34 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Pattern Matching
Sur des “Case classes”
sealed abstract class Expr[E]
case class Plus(e1:Expr[Int], e2:Expr[Int]) extends Expr[Int]
case class Mult(e1:Expr[Int], e2:Expr[Int]) extends Expr[Int]
case class Const(a:Int) extends Expr[Int]
Définition de types de données algébriques (types somme)
Mot clé case ; val implicite
sealed : ne peut-être hérité que par des classes du même
fichier + vérification de complétude des pattern-matching
Instanciation possible sans le mot clé new
Les arguments du constructeur principal (appelés “éléments”)
sont utilisés pour définir :
pattern matching
equals, hashCode, toString
Scala – Intro
Mathieu Giorgino
35 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Pattern Matching
Case classes : Exemple
sealed abstract class Expr[E]
case class Plus(e1:Expr[Int], e2:Expr[Int]) extends Expr[Int]
case class Mult(e1:Expr[Int], e2:Expr[Int]) extends Expr[Int]
case class Const[E](a:E) extends Expr[E]
val a:Expr[Int] = Plus(Const(1), Mult(Const(2), Const(3)))
def eval(e:Expr[Int]):Int = e match {
case Plus(e1, e2) => eval(e1) + eval(e2)
case Mult(e1, e2) => eval(e1) * eval(e2)
case Const(n) => n
}
println(eval(a)) /* 7 */
Scala – Intro
Mathieu Giorgino
36 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Pattern Matching
Case classes : des classes comme les autres
toString():String
Le nom de la classe et ses éléments
println(A(1, true, "abc")) /*A(1,true,abc) */
copy(...)
Retourne une copie de l’objet (avec certains éléments remplacés)
A(1, true, "abc").copy(c="def") /*A(1,true,def) */
equals(...):Boolean
Egalité structurelle (equals de tous les éléments)
hashCode():Int
Respecte la spécification par rapport à equals(...)
a == b ⇒ a.hashCode == b.hashCode
Scala – Intro
Mathieu Giorgino
37 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Pattern Matching
Case classes : avec un objet compagnon
apply(...)
Permet d’appliquer un objet à des valeurs. Par exemple :
pour les collections : List(5,7,3)(2) → 7
pour les fonctions : ((x:Int) =>x+1)(1) → 2
pour des objets : Some(5), Array(1,2,3)
unapply(...)
Permet le pattern-matching sur un objet
argument : l’objet à comparer
type de retour :
Boolean : case A =>...
Option[T] : case A(x:T) =>...
Option[(T0,...)] : case A(x0:T0,...) =>...
Scala – Intro
Mathieu Giorgino
37 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Fonctions
Plan
3
Les plus de Scala
n-uplets
Pattern Matching
Fonctions
Héritage multiple
For comprehension
Scala – Intro
Mathieu Giorgino
38 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Fonctions
Méthodes : application partielle (Curryfication)
def
val
val
val
meth0 ( x0 : T0 , x1 : T1 ): TR = { ... }
f0 :( T0 , T1 ) = > TR = meth0 _
g0 : T1 = > TR
= meth0 ( v0 , _ )
r0 : TR
= meth0 ( v0 , v1 )
def
val
val
val
meth1 ( x0 : T0 )( x1 : T1 ): TR = { ... }
f1 : T0 = > T1 = > TR = meth1 _
g1 : T1 = > TR
= meth1 ( v0 )
r1 : TR
= meth1 ( v0 )( v1 )
Abbréviation de type : A => B
Classes sous-jacentes : Function{1,2,3,...,22}
Fonction anonyme : (x:Int) =>x + 1
Abbréviation : (2*(_:Int)), (_:List[Int])(3), (_+_)
Scala – Intro
Mathieu Giorgino
39 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Fonctions
Applications dans scala.collection
Array(5,1,8).map(2 * _) /* → Array(10, 2, 16) */
Map(1 -> "one", 2 -> "two", 3 -> "three", 4 -> "four")
.filter (xy => xy._1 == xy._2.length)/* → Map(4 -> four) */
Set(42,14,21,63) forall (_ % 7 == 0) /* → true */
xs.foreach(x => println(x))
Vector("abc", "z", "3215").sortBy(_.length)
/* → Vector(z, abc, 3215) */
val (minors, adults) = people partition (_.age < 18)
List(3,2,5,4,1).sorted /* → List(1,2,3,4,5) */
xs.mkString xs.mkString(",") xs.mkString("[", "," ,"]")
Scala – Intro
Mathieu Giorgino
40 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Héritage multiple
Plan
3
Les plus de Scala
n-uplets
Pattern Matching
Fonctions
Héritage multiple
For comprehension
Scala – Intro
Mathieu Giorgino
41 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Héritage multiple
Héritage multiple : Les traits
abstract class Person { def schedule:Schedule }
trait Student extends Person {
private var classSchedule:Schedule = ...
override def schedule = classSchedule
def learn() = {...} }
trait Worker extends Person {
private var workSchedule:Schedule = ...
override def schedule = workSchedule
def work() = {...} }
class CollegeStudent(school:School, company:Company)
extends Student with Worker { ... }
Peut contenir du code et des attributs : factorisation
Pas de constructeur (différence avec une classe abstraite)
Permet l’héritage multiple : mixin class composition
Scala – Intro
Mathieu Giorgino
42 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Héritage multiple
Héritage multiple : The Diamond problem
A
m()
B
C
m()
m()
Problème
Quelle est la méthode
correspondant à m() dans D ?
D
Scala – Intro
Mathieu Giorgino
43 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Héritage multiple
Héritage multiple : Linéarisation
class
trait
trait
trait
class
Animal
Furry extends Animal
HasLegs extends Animal
FourLegged extends HasLegs
Cat extends Animal with Furry with FourLegged
Any
AnyRef
Sous forme de pile :
dernier étendu, premier
cherché
HasLegs
Animal
Furry
FourLegged
Cat
Scala – Intro
Mathieu Giorgino
44 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
For comprehension
Plan
3
Les plus de Scala
n-uplets
Pattern Matching
Fonctions
Héritage multiple
For comprehension
Scala – Intro
Mathieu Giorgino
45 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
For comprehension
Plus “For” : énumérateurs et générateurs
for (i <- 0 until n by 3 if i != 6){
s += args(i)
}
for (i <- 0 to 3; j <- 0 to 3){
a(i)(j) = i + j
}
for ((a,b) <- abs){ println(a + b) }
for (Some(x) <- xs){ println(x) }
pattern <- valeur avec une méthode foreach
for impératif : mutation/IO sur chacun des éléments d’un
ensemble
1 to 5 = 1.to(5) = Range(1,2,3,4,5)
Scala – Intro
Mathieu Giorgino
46 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
For comprehension
Encore plus “For”
for (i <- 0 to 3; j <- 0 to 3 if j > i) yield (i,j)
/* → Vector((0,1), (0,2), (0,3), (1,2), (1,3), (2,3)) */
pattern <- valeur avec une méthode map
for fonctionnel : création d’un nouvel ensemble contenant les
résultats de l’application d’une fonction à un ensemble
d’éléments
Scala – Intro
Mathieu Giorgino
47 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Paramètres implicites et vues
Plan
4
Concepts avancés
Paramètres implicites et vues
Contrôle des paramètres
Autres
Scala – Intro
Mathieu Giorgino
48 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Paramètres implicites et vues
Méthodes : paramètres implicites
object ImplicitTest extends App {
def default[A](implicit d:A):A = d
implicit val intDefault = 42
implicit val stringDefault = "default"
val n:Int = default /* 42 */
val s = default[String] /* "default" */
// val a = default /* ambiguous implicit values */
val b = default(true) /* true */
}
Mot clé implicit pour le paramètre et pour la valeur
La valeur implicite unique dans l’environnement est utilisée
Le paramètre implicite peut être fourni explicitement
Scala – Intro
Mathieu Giorgino
49 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Paramètres implicites et vues
Méthodes : paramètres implicites
abstract class Monoid[A] {
def add(x:A, y:A): A
def unit: A
}
object ImplicitTest extends App {
def sum[A](xs: List[A])(implicit m: Monoid[A]): A =
if (xs.isEmpty) m.unit
else m.add(xs.head, sum(xs.tail))
implicit object IntMonoid extends Monoid[Int] {
def add(x: Int, y: Int): Int = x + y
def unit: Int = 0
}
println(sum(List(1, 2, 3))) /* 6 */
}
Scala – Intro
Mathieu Giorgino
49 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Paramètres implicites et vues
Méthodes : paramètres implicites
object ImplicitTest extends App {
def sum[A](xs: List[A])(implicit m: Monoid[A]): A =
if (xs.isEmpty) m.unit
else m.add(xs.head, sum(xs.tail))
implicit object IntMonoid extends Monoid[Int] {
def add(x: Int, y: Int): Int = x + y
def unit: Int = 0
}
implicit object StringMonoid extends Monoid[String] {
def add(x: String, y: String): String = x concat y
def unit: String = ""
}
println(sum(List(1, 2, 3))) /* 6 */
println(sum(List("a", "b", "c"))) /* "abc" */
}
Scala – Intro
Mathieu Giorgino
49 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Paramètres implicites et vues
Conversion implicite (Vue)
/* Adding ! as a method on Int */
object extendBuiltins extends App {
def fact(n: Int): BigInt =
if (n == 0) 1 else fact(n-1) * n
class Factorizer(n: Int) {
def ! = fact(n)
}
implicit def int2fact(n: Int) = new Factorizer(n)
println("10! = " + (10!))
}
Mot clé implicit
Quand une méthode n’existe pas, la fonction implicite (si elle
existe et est unique) qui transforme la valeur en une valeur
pour laquelle elle existe est appliquée
Scala – Intro
Mathieu Giorgino
50 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Contrôle des paramètres
Plan
4
Concepts avancés
Paramètres implicites et vues
Contrôle des paramètres
Autres
Scala – Intro
Mathieu Giorgino
51 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Contrôle des paramètres
Paramètres : passage par nom
def tracingID[A](a:A):A = { print("called, "); a }
def f0(a: Int) = {print("f0:"); println(a + a)}
f0(tracingID(1))
/* called, f0:2 */
def f1(a: => Int) = {print("f1:"); println(a + a)}
f1(tracingID(1))
/* f1:called, called, 2 */
Notation : “a: => Type” (fonction sans argument)
Passage par valeur (défaut) : l’argument est évalué avant
l’appel
Passage par nom : l’argument est réévalué à chaque utilisation
Paresseux : l’argument est évalué à la première utilisation
Scala – Intro
Mathieu Giorgino
52 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Contrôle des paramètres
Paramètres répétés
def sum(args: Int*) = {
var result = 0
for (arg <- args) result += arg
result
}
sum() /* → 0 */
sum(1) /* → 1 */
sum(1, 2, 3) /* → 6 */
Scala – Intro
Mathieu Giorgino
53 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Contrôle des paramètres
Paramètres nommés et par défaut
def f0(a:Int, b:Int, c:Int, d:Int) = a - b + c*d
f0(2, d=2, b=1, c=3)
def f1(a:Int, b:Int)(c:Int, d:Int) = a - b + c*d
f1(b=2, a=1)(1, 3)
def f2(a:Int = 0, b:Int, c:Int) = a - b + c
f2(2, 3, 4)
f2(b=3, c=4)
def f3(a:Int, b:Int = 0, c:Int = 0) = a - b + c
f3(0, 1, 2)
f3(0, 1)
f3(0, c=2)
f3(0)
Scala – Intro
Mathieu Giorgino
54 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Autres
Plan
4
Concepts avancés
Paramètres implicites et vues
Contrôle des paramètres
Autres
Scala – Intro
Mathieu Giorgino
55 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Autres
Autres
Restriction d’accès fine
private[this] : restreint l’accès à this
private[p1.p2]
: restreint l’accès au paquetage p2
Types structurels (“Duck Typing” statique)
Définition d’un type par les méthodes qu’il fournit
type T = { def meth() }
def m(x:T) { x.meth() ... }
Évaluation paresseuse : Évaluation à la première utilisation
lazy val a = { print("a: "); 5 }
print("print: "); println(a + a) /* print: a: 10*/
Scala – Intro
Mathieu Giorgino
56 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Bibliothèque standard
Plan
5
Dans la pratique
Bibliothèque standard
Outils
Bibliographie
Scala – Intro
Mathieu Giorgino
57 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Bibliothèque standard
scala.collection
Traversable
Iterable
IndexedSeq
Scala – Intro
Seq
Map
Set
LinearSeq
SortedMap
SortedSet
Mathieu Giorgino
BitSet
58 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Bibliothèque standard
scala.collection
Seq
IndexedSeq
mutable.{ArraySeq, StringBuilder, ResizableArray},
Array
immutable.Vector
LinearSeq
immutable.{List, Stream}
mutable.{Queue, MutableList}
mutable.Buffer: mutable.{ListBuffer,ArrayBuffer}
Range
Set (SortedSet)
mutable.{HashSet, LinkedHashSet}, BitSet
immutable.{HashSet, Treeset}
Map
mutable.{HashMap, LinkedHashMap}
immutable.{HashMap, TreeMap}
Scala – Intro
Mathieu Giorgino
59 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Bibliothèque standard
scala.swing
import scala.swing._
object HelloWorld extends SimpleSwingApplication {
def top = new MainFrame {
title = "Hello, World!"
contents = new Button {
text = "Click Me!"
}
}
}
Scala – Intro
Mathieu Giorgino
60 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Bibliothèque standard
scala.actors
import scala.actors.Actor
import scala.actors.Actor._
/* Messages */
case class Crible(n:Int)
case object Die
/* Acteur */
class Prime(val prime:Int) extends Actor {
println(prime + " is prime !")
def end = loop {
react {
case Crible(n) if (n % prime != 0) => {
val next = new Prime(n)
middle(next)
}
case Die => exit()
}
}
Scala – Intro
Mathieu Giorgino
61 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Bibliothèque standard
scala.actors
def middle(next:Prime) = loop {
react {
case Crible(n) if (n % prime != 0) => {
next ! Crible(n)
}
case Die => { next ! Die; exit() }
} }
def act() = end
} /* Prime */
object Main extends App{
val n = try { args(0).toInt } catch { case _ => 10 }
val p = new Prime(2).start()
for (n <- 3 to n) p ! Crible(n)
p ! Die
}
Scala – Intro
Mathieu Giorgino
61 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Outils
Plan
5
Dans la pratique
Bibliothèque standard
Outils
Bibliographie
Scala – Intro
Mathieu Giorgino
62 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Outils
IDEs, Compilateur
IDEs
Plugin Eclipse : ScalaIDE
Intellij IDEA
Plugin Netbeans
jedit, emacs, vi, ...
Compilation
Fichiers nommés *.scala
scalac : similaire à javac
fsc (fast scala compiler) : démarre un démon à la première
exécution pour des exécutions ultérieures plus rapides
Système de plugins pour contraintes/optimisations
Scala – Intro
Mathieu Giorgino
63 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Outils
Scala doc
Scala – Intro
Mathieu Giorgino
64 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Outils
Interpréteur
Scala – Intro
Mathieu Giorgino
65 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Bibliographie
Plan
5
Dans la pratique
Bibliothèque standard
Outils
Bibliographie
Scala – Intro
Mathieu Giorgino
66 / 66
Introduction
De Java à Scala
Les plus de Scala
Concepts avancés
Dans la pratique
Bibliographie
Martin Odersky, Lex Spoon, and Bill Venners.
Programming in Scala.
Artima, 2008.
Alex Payne and Dean Wampler.
Programming Scala.
O’Reilly, 2009.
http://programming-scala.labs.oreilly.com/.
L’agrégateur des blogs sur scala.
http://www.planetscala.com.
Le site web officiel.
http://www.scala-lang.org/.
Scala – Intro
Mathieu Giorgino
66 / 66
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertising