Le paradigme fonctionnel

📄 Ressources du cours

🎥 Vidéos recommandées

• 🇫🇷 Voyage en terre inconnue, épisode 1 : Scala - Functional Programming

  Montpellier Tech Hub · 01:03:24 · 2k vues — Scala est un langage de programmation multi-paradigme, associant la programmation objet à la programmation fonctionnelle, qui prône une écriture concise, élé...

• 🇫🇷 Tutoriel - programmation en Scala

  Juvénal CHOKOGOUE · 58:47 · 1k vues — Vous souhaitez travailler dans le Big Data ? Vous souhaitez maîtriser Spark pour le Big Data avec Scala ? Nous vous offrons gratuitement cette formation de 2...

• 🇬🇧 Scala Tutorial - Elements of Functional Programming - Part 2

  Learning Journal · 20:37 · 30k vues — Spark Programming and Azure Databricks ILT Master Class by Prashant Kumar Pandey - Fill out the google form for Course inquiry.https://forms.gle/Nxk8dQUPq4o...

1. Le paradigme fonctionnel ≡ pas d'effet de bord

Concrètement, le passage de l'impératif au fonctionnel se fait par cinq substitutions :

2. « Moins d'éléments = moins expressif ? »

Question naturelle : si on retire variables, instructions, procédures et boucles, que reste-t-il ? Réponse :

Historique des langages fonctionnels

• 1958 — LISP (LISt Processor) ; 1970 : Scheme
• 1973 — ML (Meta Language) ; 1985 : CaML, 1996 : OCaML, 1990 : Standard ML
• 1990 — Haskell
• 2003-2004 — Scala (Martin Odersky)
• 2005 — F# (basé sur C#)

Du côté des langages impératifs, l'adoption progressive des features fonctionnelles :

3. Récap théorique

Fonction pure

Une telle fonction est une constante typée. Son type est donné par :

• les types de ses paramètres ;
• et le type de son résultat.

Fonction récursive

Exemple : factorielle

Function factorial(n : integer) : integer
   If n <= 0 then
      Return 1
   Else
      Return n * factorial(n - 1)
   EndIf
EndFunction

Function factorialTR(n, a : integer) : integer
   If n = 0 then
      Return a
   Else
      Return factorialTR(n - 1, n * a)
   EndIf
EndFunction

Function factorial(n : integer) : integer
   Return factorialTR(n, 1)
EndFunction

Dans la version TR, l'appel récursif factorialTR(n-1, n*a) est la dernière opération — le compilateur peut transformer la récursion en boucle (élimination de la pile d'appels).

4. Typage statique vs dynamique

Conséquence pratique : en Scala, on déclare un val x : Int et le compilateur refusera x = "42" au moment de la compilation, pas de l'exécution.

5. Scala — fiche d'identité

Frameworks fondés sur Scala

6. Environnement de développement

Console (REPL)

Appel scala sans paramètre lance un REPL :

$ scala
Welcome to Scala 2.11.12 (OpenJDK 64-Bit Server VM, Java 11.0.8).
Type in expressions for evaluation. Or try :help.

scala> 1 + 1
res0: Int = 2

scala> "42"
res1: String = 42

Option -Dscala.color active la coloration syntaxique sur les résultats. Commandes spéciales :

• :help
• :load fichier — charge le contenu d'un fichier comme code Scala
• :quit (ou Ctrl+D) — quitte la console

sbt (Simple Build Tool)

Structure d'un projet sbt :

Working directory/
├── build.sbt                (configuration)
├── lib/                     (JARs)
└── src/
    ├── main/
    │   ├── java/            (sources Java)
    │   ├── scala/           (sources Scala)
    │   └── resources/       (fichiers de données)
    └── test/
        ├── java/            (tests Java)
        ├── scala/           (tests Scala)
        └── resources/

Exemple de build.sbt :

organization := "fr.cyu"
name         := "HelloWorld"
version      := "1.0-SNAPSHOT"

// Une dépendance pour les tests
libraryDependencies += "junit" % "junit" % "4.8" % "test"

// Plusieurs dépendances
libraryDependencies ++= Seq("org.scala-lang" % "scala-xml" % "2.11.0-M4",
                          "joda-time"      % "joda-time" % "2.9.5")

Sous-commandes sbt utiles :

Toutes ces sous-commandes peuvent être invoquées (1) en paramètre du terminal (sbt compile) ou (2) directement dans la console sbt.

7. Éléments de base de Scala

Main class… ou plutôt main object

Même objectif qu'en Java (point d'entrée avec une méthode main, arguments capturés dans un Array[String]), mais quelques différences :

• Une seule instance ⇒ déclaration object (au lieu de class)
• Le trait App définit lui-même main : pas besoin de la déclarer si l'objet extends App ; le corps entier de l'objet devient le corps de main.

object HelloWorld {
   def main(args : Array[String]) {
      println("Hello World !")
   }
}

object HelloWorld extends App {
   println("Hello, world!")
}

Types de base

Les types de base de Scala encapsulent leurs homologues Java ⇒ toutes les opérations Java sont disponibles, avec quelques subtilités (notamment les conversions implicites, qui deviennent moins implicites en Scala 3).

scala> 1 / 2
res0: Int = 0

scala> (1 / 2).toDouble
res1: Double = 0.0     // trop tard !

scala> 1.toDouble / 2
res2: Double = 0.5     // correct

val vs var

// Variable en Scala / Variable en Java
var i   : Int    = 7             |  int i = 7;
var msg : String = "Hello world !"  |  String msg = "Hello world !";

// Valeur en Scala / Valeur en Java
val i   : Int    = 7             |  final int i = 7;
val msg : String = "Hello world !"  |  final String msg = "Hello world !";

Inférence de type (contrairement à Java) : le type n'est pas toujours requis (mais recommandé).

scala> val answer : String = "42"
answer: String = 42

scala> val answer = "42"            // type inféré
answer: String = 42

scala> val answer : Int = "42"
<console>:11: error: type mismatch;
 found   : String("42")
 required: Int

Évaluation standard vs lazy val

scala> val x = {println("x is set") ; 3 + 3}
x is set                    // evalue immediatement
x: Int = 6

scala> lazy val x = {println("x is set") ; 3 + 3}
x: Int = <lazy>             // pas encore evalue

scala> x + 3
x is set                    // evalue maintenant
res0: Int = 9

scala> x
res1: Int = 6                // reste inchange, pas re-evalue

Combiné à un if :

scala> lazy val x = {println("x is set") ; 3 + 3}
x: Int = <lazy>

scala> if (false) x else 0
res0: Int = 0                // x pas evalue

scala> if (true) x else 0
x is set                    // x evalue ici
res1: Int = 6

⇒ Évaluation dynamique, bien que le type checking reste statique.

Tout est expression… donc tout est typé

scala> val e1 = 1
e1: Int = 1

scala> val e0 = println(e1)
1
e0: Unit = ()               // type Unit, valeur ()

scala> if (e1 == e2) e1 else e2
res2: Int = 2

Un bloc crée aussi un scope local : les valeurs déclarées à l'intérieur ne fuitent pas dehors.

scala> val e = {
         val cmPerInch = 2.54
         15 * cmPerInch
       }
e: Double = 38.1

scala> cmPerInch
<console>:12: error: not found: value cmPerInch

Hiérarchie des classes Scala

La hiérarchie Scala : Any au sommet, Nothing tout en bas. Les pointillés représentent les relations « sous-type de ».

Un val x : Any = "abc" est valide (upcasting implicite). Mais val y : String = x renvoie une erreur (downcasting refusé en static typing).

8. Tuples & Option[T]

Tuples

scala> val t = ("The answer", 42, "Douglas Adams")
t: (String, Int, String) = (The answer,42,Douglas Adams)

scala> t._2                // acces 1-indexed
res0: Int = 42

scala> t._4
<console>:13: error: value _4 is not a member of (String, Int, Double)

Option[T]

Deux types d'expression :

• Some(x) — où x est de type T (simple encapsulation)
• None — pour le cas « pas de valeur »

Exemple : conversion String → Int

scala> def toInt(s : String) : Option[Int] = {
         try {
            Some(Integer.parseInt(s.trim))
         } catch {
            case e : Exception => None
         }
       }
toInt: (s: String)Option[Int]

scala> toInt("42")
res0: Option[Int] = Some(42)

scala> toInt("The answer")
res1: Option[Int] = None

★ Réviser le chapitre

🃏 Flashcards

Clique pour retourner la carte. Espace pour la carte focus.

↻ Tout retourner

✎ Quiz éclair

❓ Q/R