Résumé de section

  • Programmer de manière fonctionnelle

    Tout replier Tout déplier

    Code d'honneur

    En vous inscrivant à ce cours, vous vous engagez à respecter les règles suivantes :

    Règle 1: Vous devez être l’auteur·rice des solutions que vous soumettez.
    Si vous copiez le travail d’une autre personne ou si vous vous en inspirez fortement en omettant de le mentionner, vous commettez un acte de plagiat. Par exemple, le fait d’utiliser une solution trouvée dans le web ou la solution d’un·e camarade de votre classe ou d’une année précédente constitue une violation de la présente règle. D’une manière générale, vous ne devez pas chercher à consulter une solution existante à un problème qui vous est posé dans le cadre de ce cours.
    Règle 2: Vous ne devez pas partager vos solutions avec vos camarades.
    Vous ne devez en aucun cas partager vos solutions avec vos camarades, que ce soit à leur demande expresse ou en les publiant d’une manière ou d’une autre.
    Règle 3: Vous devez mentionner toute aide que vous recevez.
    Si vous recevez de l’aide de la part d’une personne autre que votre enseignant·e pour la réalisation d’un travail, vous devez indiquer la nature de cette aide, et la manière dont elle a influencé votre solution. En outre, vous devez veiller à ce que l’aide reçue ne viole pas les règles 1 et 2.
    Règle 4: Vous devez être en mesure d’expliquer dans leur ensemble les solutions que vous soumettez.
    Quelle que soit l’aide que vous recevez pour effectuer un travail, vous devez pouvoir fournir des explications sur l’ensemble de la solution. De plus, dans le cas d’un travail de groupe et sauf indication contraire, vous devez être en mesure d’expliquer non seulement vos propres contributions, mais également celles de vos partenaires.
    Règle 5: Vous devez effectuer vos travaux de manière consciencieuse.
    Pour tous les travaux qui vous sont demandés, vous devez soumettre en temps et heure une solution réalisée avec minutie et application. Dans le cas où vous n’arriveriez pas au bout d’un travail, vous devez rendre la solution inachevée et un compte rendu détaillé des problèmes rencontrés.

  • Pourquoi Purescript ?

    On peut se demander pourquoi utiliser le langage PureScript alors que nous utilisons par ailleurs Java. Dans ce contexte, un langage basé sur la JVM, comme Kotlin, Scala ou Clojure, serait sans doute un choix plus naturel.

    Dans le cadre d'une pédagogie d'inspiration constructiviste et pragmatiste, il est important que le réel résiste. Lorsque l'on aborde la programmation fonctionnelle en 3e année, cette confrontation au réel ne peut pas se faire uniquement sur la base de la passation de tests. En effet, en plus de la fonctionnalité du programme, c'est aussi sa structure que l'on cherche à contraindre. Si la séquence d'instructions est implicite dans la syntaxe du langage (Kotlin, Scala), celle-ci ne contraint pas à penser le programme comme une seule expression.

    En rendant la séquence explicite, Clojure impose cette contrainte. Toutefois, si Clojure rend les effets de bord visibles, il n'impose aucune contrainte sur leur utilisation et ne garantit donc pas la pureté des fonctions. Pour garantir cette pureté, il est nécessaire de se tourner vers un langage fonctionnel pur et, parmi les langages à usage général, Haskell est probablement le choix le plus évident.

    Pourquoi ne pas avoir choisi Haskell ? L'idée était d'avoir un langage qui s'intègre facilement dans un environnement déjà connu (JVM, Node.js, navigateur). Le langage Frege (Haskell pour la JVM) ne semblant plus être activement maintenu, PureScript constitue un bon second choix.

  • Objectifs du module

    Compétence

    Effectuer une description déclarative et une implémentation fonctionnelle d’algorithmes et de parties d’applications.

    Objectif 1

    Analyser et décrire les exigences en vue de la réalisation d'une programmation fonctionnelle.[g4.1, g4.4]
    Connaissances requises
    1. Connaître la différence entre programmation impérative et programmation déclarative/fonctionnelle (paradigme de programmation déclarative).
    2. Connaître des méthodes de description déclarative de problèmes et d’états finaux.
    3. Connaître les avantages et les inconvénients de la programmation fonctionnelle.
    4. Connaître les termes de la programmation fonctionnelle (p. ex. fonction pure, donnée immuable, expression lambda, fonction, fermeture [closure], rappel [callback], foncteur), les comprendre et pouvoir les utiliser correctement.
    5. Connaître des possibilités pour élaborer un concept de réalisation adapté à la programmation fonctionnelle.

    Objectif 2

    Implémenter de manière efficiente des algorithmes et des problèmes d’applications selon le paradigme de programmation fonctionnelle et les exigences données. [g5.2, g5.5]
    Connaissances requises
    1. Pouvoir lire, comprendre, maintenir et étendre un code fonctionnel.
    2. Connaître des concepts de programmation fonctionnelle (p. ex. filter, map, reduce) et des patrons de conception adaptés (p. ex. builder pattern).
    3. Connaître des méthodes pour exécuter un code de manière distribuée, parallèle ou concurrente.

    Objectif 3

    Améliorer et optimiser le code impératif implémenté en utilisant la programmation fonctionnelle (refactorisation)
    Connaissances requises
    1. Connaître des moyens pour déterminer si des parties de programmes peuvent, après examen, être optimisées ou améliorées grâce à l’implémentation fonctionnelle.
    2. Connaître les éléments fonctionnels d’un langage de programmation et pouvoir ainsi développer des applications avec un paradigme de programmation impérative et déclarative.

    Objectif 4

    Vérifier l’exactitude et la qualité de l’implémentation.
    Connaissances requises
    1. Connaître des moyens de tester un code fonctionnel implémenté (p. ex. tests unitaires).
    2. Connaître des directives de code appropriées et les appliquer de manière systématique.
    3. Connaître les meilleures pratiques de la programmation fonctionnelle et pouvoir les appliquer.

  • Séquence 1 — Introduction

    Quand, où :

    Lundi, 5 janvier 2026, 7:55-12:00, Salle F119
    Lundi, 12 janvier 2026, 7:55-12:00, Salle F119

    Objectifs :

    À la fin de cette séquence, vous devez :

    1. Connaître les notions de programme et de langage de programmation.
    2. Connaître la différence entre programme et algorithme.
    3. Connaître la notion d'architecture de von Neumann.
    4. Connaître la notion de programmation impérative.
    5. Connaître les notions de déclaration, de définition, d'expression et d'instruction.
    6. Connaître les notions de variable et de constante.
    7. Connaître les notions de méthode, de fonction et de procédure.
    8. Connaître les notions d'effet de bord (side effect) et de dépendance implicite.
    9. Connaître les inconvénients des effets de bord.
    10. Connaître les notions de fonction pure, de transparence référentielle et d'immutabilité.
    11. Connaître les avantages et les inconvénients de la transparence référentielle et de l'immutabilité.
    12. Connaître la notion de structure de données persistante.
    13. Connaître la notion d'opération d'entrée-sortie et les particularités de ces opérations (les effets de bord sont incontournables)
    14. Connaître les notions de programmation fonctionnelle et de langage fonctionnel.
    15. Connaître les notions de machine de Turing et de Turing-completeness.
    16. Connaître la notion de λ-calcul.
    17. Connaître la notion de paradigme de programmation.

  • Séquence 2 - Purescript : Expressions spéciales, record et Maybe a

    Quand, où :

    Lundi, 19 janvier  2026, 7:55-12:00, Salle F119

    Objectifs :

    À la fin de cette séquence vous devez :

    1. Connaître la notion d'expression conditionnelle (if-then-else)
    2. Connaître la différence entre une expression conditionnelle et une structure de choix.
    3. Connaître une manière de définir des variables locales dans un langage fonctionnel (expression let)
    4. Connaître la notion d'associativité à gauche dans l'application d'une fonction.
    5. Connaître la différence entre un littéral de nombre négatif (le moins fait partie du littéral) dans un langage comme Java et un opérateur de négation appliqué à un littéral de nombre positif dans les langages de la famille ML (Purescript, Haskell, etc.).
    6. Connaître la notion d'enregistrement (record).
    7. Connaître la notion de synonyme de type.
    8. Connaître le type Maybe a

    • Activités

    • Réaliser une fonction qui permet de résoudre une équation du deuxième degré :

      a x2 + b x + c = 0

  • Séquence 3 - Purescript : Pattern matching et récursion

    Quand, où :

    Lundi, 26 janvier  2026, 7:55-12:00, Salle F119
    Lundi, 2 février 2026, 7:55-12:00, Salle F119

    Objectifs :

    À la fin de cette séquence vous devez :

    1. Connaître la notion de pattern matching (expression case, définition de fonction)
    2. Connaître une autre manière de définir des variables locales dans un langage fonctionnel (clause where)
    3. Connaître la manière de réaliser une répétition en programmation fonctionnelle (appel récursif)
    4. Connaître le problème des appels récursifs (pile d'exécution).
    5. Connaître la notion de récursion terminale (tail recursion).
    6. Connaître la notion de « tail call elimination » ou « tail call optimization ».

    • Activités

      1. Réaliser une fonction qui calcule la somme des N premiers entiers.
      2. Réaliser une fonction qui calcule la somme des N premiers nombres impaires.
      3. Réaliser une fonction qui calcule le plus grand commun diviseur de deux nombres à l'aide de l'algorithme d'Euclide.
      4. Réaliser une fonction qui calcule la n valeur de la suite de Fibonacci. La suite de Fibonacci est définie comme suit :
        fib(0) = 0
        fib(1) = 1
        fib(\(n\)) = fib(n-2) + fib(n-1)

    • Ressources

  • Séquence 4 - Purescript : Type de données algébriques

    Quand, où :

    Lundi, 9 février  2026, 7:55-12:00, Salle F119

    Objectifs :

    À la fin de cette séquence vous devez :

    1. Connaître la notion de type algébrique.
    2. Connaître les notion de type produit (enregistrement) et type sum (union disjointe)
    3. Connaître la notion de classe de type (Eq, Show, etc.)

    • Activités

    • Modifier la fonction Quadratic en utilisant un type algébrique (TDA) afin de rendre explicites les différents cas.

    • Ressources

    • Exemple de type somme en Java (Optional<T> et sealed interface)
      git clone https://gitlab.epai-ict.ch/m323/java/quadratic.git
      Exemples en PureScript
      git clone https://gitlab.epai-ict.ch/m323/purescript/exemples.git

  • Séquence 5 - Purescript : Listes et fonctions d'ordre supérieures

    Quand, où :

    Lundi, 23 février  2026, 7:55-12:00, Salle F119

    Objectifs :

    À la fin de cette séquence vous devez :

    1. Connaitre le type List et la notion de liste chaînée (linked list).
    2. Connaitre les constructeurs de liste Cons et :
    3. Connaitre la notion de fonction d'ordre supérieur
    4. Connaitre la fonction map appliquée aux listes.
    5. Connaitre les fonctions foldl et foldr (reduce) appliquées aux listes.
    6. Connaitre la fonction filter appliquée aux listes.
    7. Connaitre des fonctions réalisables avec fold (length, find, any, all, etc.)
    8. Connaitre l'opérateur # (reverse application) qui permet d'enchaîner des opérations comme avec l'opérateur | (pipe) en Bash.

    • Activités

    • Ressources

    • Exemples en PureScript
      git clone https://gitlab.epai-ict.ch/m323/purescript/exemples.git

  • Séquence 5 - Purescript : foncteurs et monades

    Quand, où :

    Lundi, 23 février  2026, 7:55-12:00, Salle F119

    Objectifs :

    À la fin de cette séquence vous devez :

    1. Connaitre la notion de foncteur (un type qui supporte la fonction map).
    2. Connaitre des exemples de foncteurs (List, Seq, Array, Maybe, Either, etc.).
    3. Connaitre les limites de map lorsque l'on enchaîne des opérations.
    4. Connaitre les fonction bind (ou >>=) et pure (ou return).
    5. Connaitre le fait que bind est souvent appelé flatMap dans d'autre langage (notamment Java et JavaScript)
    6. Connaitre la notion de monade (un foncteur qui supporte les méthodes bind et pure).
    7. Connaitre des exemples de monades (List, Seq, Array, Maybe, Either, etc.)
    8. Connaitre l'utilité du bloc do (sucre syntaxique) pour les bind.
    9. Connaitre la notion de monade d'effet (Effect / IO) et ce que cela représente.

    • Activités

    • Ressources

    • Exemples en PureScript
      git clone https://gitlab.epai-ict.ch/m323/purescript/exemples.git