Présentation d'initiation au scala

1. Scala Collections
5 Avril 2018Jeremy Guido

2. Scala ?
Wikipédia: https://fr.wikipedia.org/wiki/Scala_(langage)
Scala est un langage de programmation multi-paradigme créé par Martin Odersky et conçu à l'École polytechnique fédérale de
Lausanne (EPFL) pour exprimer les modèles de programmation courants dans une forme concise et élégante. Son nom vient de
l'anglais Scalable langage qui signifie à peu près « langage adaptable » ou « langage qui peut être mis à l'échelle ». Il peut en effet
être vu comme un métalangage.
Scala intègre les paradigmes de programmation orientée objet et de programmation fonctionnelle, avec un typage statique. Il concilie
ainsi ces deux paradigmes habituellement opposés et offre au développeur la possibilité de choisir le paradigme le plus approprié à
son problème.

3. Scala, le couteau Suisse
Types paramétrés, covariance, non-variance et contra-
variance
Types de type
Composition (trait)
Hybride entre l’Interface et la classe Abstraite
Pattern singleton au lieu des méthodes statiques
object Bar {
def apply(): Bar = new Bar()
}
case class Bar() {
def foo(): Unit = println(s"Hello World!")
}
Bar().foo()
Évaluation paresseuse (Lazy evaluation)
val foo => exécuté à chaque appel
lazy val foo => exécuté uniquement lors du premier appel
Structures de données paresseuses et infinies
Stream

4. Java vs Scala
class Graph {
private final HashSet<String> v;
private final HashMap<String, Pair<String, String>> e;
public Graph(HashSet<String> v, HashMap<String, Pair<String, String>> e)
throws Exception {
this.v = v;
this.e = e;
for (Pair<String, String> p : e.values()) {
if (!(v.contains(p.e1) && v.contains(p.e2))) {
throw new Exception();
}
}
}
class Pair<T0, T1> {
public final T0 e1;
public final T1 e2;
public Pair(T0 e1, T1 e2) {
this.e1 = e1;
this.e2 = e2;
}
}
}
class Graph(val v: List[String], private val e: Map[String, (String, String)]) {
require(e.values forall {case (x, y) => (v contains x) && (v contains y)})
}

5. C’est utilisé ça ?

6. Les collections

7. Mutable
Immutable

8. def foreach[U](f: A => U): Unit
def filter(p: A => Boolean): Repr
def exists(p: A => Boolean): Boolean
def map[B, That](f: A => B): That
def flatMap[B, That](f: A => GenTraversableOnce[B]): That
def foldLeft[B](z: B)(op: (B, A) ⇒ B): B
Quelques signatures

9. def foreach[B](f: (A) ⇒ B): Unit
Exemple avec le type : Set - foreach
1 3 5 8 10 2 -1 foreach (x => x+1)
2 4 6 9 11 3 0

10. def foreach[U](f: A => U): Unit
def filter(p: A => Boolean): Repr
def exists(p: A => Boolean): Boolean
def map[B, That](f: A => B): That
def flatMap[B, That](f: A => GenTraversableOnce[B]): That
def foldLeft[B](z: B)(op: (B, A) ⇒ B): B
Quelques signatures

11. def filter(p: (A) ⇒ Boolean): Set[A]
Exemple avec le type : Set - filter
1 3 5 8 10 2 -1 filter (_ >= 5)
5 8 10

12. def foreach[U](f: A => U): Unit
def filter(p: A => Boolean): Repr
def exists(p: A => Boolean): Boolean
def map[B, That](f: A => B): That
def flatMap[B, That](f: A => GenTraversableOnce[B]): That
def foldLeft[B](z: B)(op: (B, A) ⇒ B): B
Quelques signatures

13. def exists(p: (A) ⇒ Boolean): Boolean
Exemple avec le type : Set - exists
1 3 5 8 10 2 -1 exists (x => x > 0)
TRUE

14. def foreach[U](f: A => U): Unit
def filter(p: A => Boolean): Repr
def exists(p: A => Boolean): Boolean
def map[B, That](f: A => B): That
def flatMap[B, That](f: A => GenTraversableOnce[B]): That
def foldLeft[B](z: B)(op: (B, A) ⇒ B): B
Quelques signatures

15. def map[B](f: (A) ⇒ B): Set[B]
Exemple avec le type : Set - map
1 3 5 8 10 2 -1 map (x => Set(x - 1, x, x + 1))
Set(0, 1, 2) Set(2, 3, 4) Set(4, 5, 6) Set(7, 8, 9) Set(9, 10, 11) Set(1, 2, 3) Set(-2, -1, 0)

16. def foreach[U](f: A => U): Unit
def filter(p: A => Boolean): Repr
def exists(p: A => Boolean): Boolean
def map[B, That](f: A => B): That
def flatMap[B, That](f: A => GenTraversableOnce[B]):
That
def foldLeft[B](z: B)(op: (B, A) ⇒ B): B
Quelques signatures

17. def flatMap[B](f: (A) ⇒ GenTraversableOnce[B]): Set[B]
Exemple avec le type : Set - flatMap
1 3 5 8 10 2 -1 flatMap (x => Set(x - 1, x, x + 1))
0 1 2 3 4 5 6 7 8 9 10 11 -2 -1

18. def foreach[U](f: A => U): Unit
def filter(p: A => Boolean): Repr
def exists(p: A => Boolean): Boolean
def map[B, That](f: A => B): That
def flatMap[B, That](f: A => GenTraversableOnce[B]): That
def foldLeft[B](z: B)(op: (B, A) ⇒ B): B
Quelques signatures

19. def foldLeft[B](z: B)(op: (B, A) ⇒ B): B
Exemple avec le type : Set - foldLeft
1 3 5 foldLeft(’’’’) ((acc, digit) => acc + digit)
’’135’’

20. Cas d’utilisation : None
object None extends Option[Nothing] with Product with Serializable
sealed abstract class Option[+A] extends Product with Serializable
case class Foo(id: Option[String])
val a = Foo(None)
val b: Option[String] = a.id.map(_.toUpperCase)
val c: io.Serializable = a.id match {
case Some(value) => value.toUpperCase
case None => None
}
val d: Option[String] = if(a.id.isDefined) {
Some(a.id.get.toUpperCase())
} else {
None
}
}

21. Cas d’utilisation : Future
val userRequest: model.User = request.user
val eventualMaybeUser: Future[User] = userRepo.findByUsername(u.username)
eventualMaybeUser.map(user => {
if(user.get.username equals userRequest.username) {
// user is logged in
} else {
// user not known
}
})

22. Questions ?
Biblio :
Functionnal programming in scala
Paul Chiusano / Rùnar Bjarnason
Manning
Scala for the impatient (2nd edition)
Cay S Horstmann
Programming in Scala (3rd edition)
Martin Odersky, Lex Spoon, Bill Venners
Sources
https://www.scala-lang.org/