La programmation fonctionnelle, c’est juste pour faire des preuves ?

Julien Richard-Foy

http://julienrf.github.io/breizhcamp-2016

BreizhCamp 2016

Plan

Composition
Modélisation
Abstraction
Adéquation (avec les besoins d’aujourdhui)

Compositionnalité

Principe selon lequel la signification d’une expression complexe est définie par les significations des expressions la composant, et par les règles employées pour les combiner.

Wikipedia

La composition appliquée aux programmes

Créer un programme complexe en combinant des programmes plus simples

La composition appliquée aux programmes (variante)

Décomposer un problème complexe en problèmes plus simples (et indépendants)

`IllegalStateException`

(existe aussi sous la forme d’une NullPointerException, IOException, etc.)

User user = new User();
println(user.name);

Toute valeur doit être initialisée dans un état valide

User user = new User("Julien");
doSomething(user);
println(user.name);

La valeur associée à un nom donné ne doit pas changer au cours du temps

Immuabilité

L’immuabilité contraint le code appelé ;
L’immuabilité libère le code appelant.

Integer n = 1;

n + n == 1 + 1;

Image img = new Circle(5);

img.beside(img) == (new Circle(5)).beside(new Circle(5));

Alias vs copie superficielle vs copie profonde

Image ear = new Circle(8);
Image face = new Circle(10);
Image mickey =
  ear.beside(ear)
    .above(face);

Travailler avec des valeurs

ie. Éviter de ne « rien » retourner

Composition(nalité) : synthèse

Arme pour gérer la complexité ;
Élimine toute une classe de problèmes d’intégration ;
S’obtient en travaillant avec des valeurs immuables.

When you program you have to think about how someone will read your code, not just how a computer will interpret it.

Kent Beck

Un domaine métier doit pouvoir être traduit facilement en code ;
Réciproquement, le code doit permettre de reconstruire, mentalement, le domaine métier.

Partition de musique (en français)

Une partition de musique a une clé et une suite de notes
Une note a un nom (« do », « ré », etc.) et un rythme (« noire », « blanche », etc.)

public class Note {
  public Name name;
  public Rhythm rhythm;
}

public class Note {
  public final Name name;
  public final Rhythm rhythm;

  public Note(Name name, Rhythm rhythm) {
    this.name = name;
    this.rhythm = rhythm;
  }
}

Note do1 = new Note(C, Quarter);
Note do2 = new Note(C, Quarter);
assert(do1.equals(do2)); // ???

public final class Note {
  public final Name name;
  public final Rhythm rhythm;

  public Note(Name name, Rhythm rhythm) {
    this.name = name;
    this.rhythm = rhythm;
  }

  @Override
  public Boolean equals(that) {
    if (that instanceof Note) {
      return this.name.equals(that.name) && this.rhythm.equals(that.rhythm);
    } else return false;
  }

  @Override
  public Long hashCode() {
    return (17 + name.hashCode()) * 31 + rhythm.hashCode(); 
  }
}

Scala :

case class Note(
  name: Name,
  rhythm: Rhythm
)

Haskell :

data Note = Note Name Rhythm

« Un symbole musical est soit un silence, soit une note »

public abstract class Symbol {
  private Symbol() {}

  public abstract void accept(Visitor visitor);

  public static final class Note extends Symbol {
    …
    @Override
    public void accept(Visitor visitor) {
      visitor.visitNote(this);
    }
  }
  public static final class Rest extends Symbol {
    …
    @Override
    public void accept(Visitor visitor) {
      visitor.visitRest(this);
    }
  }

  public static interface Visitor {
    void visitNote(Note note);
    void visitRest(Rest rest);
  }
}

Sum Types

a.k.a. union types

Scala :

sealed trait Symbol
case class Note(name: Name, rhythm: Rhythm) extends Symbol
case class Rest(rhythm: Rhythm) extends Symbol

def doSomething(symbol: Symbol): Unit =
  symbol match {
    case Note(name, rhythm) => …
    case Rest(rhythm) => …
  }

Haskell :

data Symbol = Note Name Rhythm | Rest Rhythm

doSomething (Note name rhythm) = …
doSomething (Rest rhythm) = …

Modélisation : synthèse

Les types de données algébriques (c’est leur nom…) permettent de modéliser efficacement un domaine métier ;
Les concepts du domaine se traduisent directement en code, et vice versa.

Définition

The purpose of abstraction is not to be vague, but to create a new semantic level in which one can be absolutely precise

Edsger W. Dijkstra

On est déjà à mi-chemin !

Le découpage du code de manière compositionnelle aide à construire de petites abstractions réutilisables ;
Les types de données algébriques permettent de représenter un domaine métier (c.-à-d. une abstraction du monde réel).

Principe d’abstraction

Each significant piece of functionality in a program should be implemented in just one place in the source code.

Where similar functions are carried out by distinct pieces of code, it is generally beneficial to combine them into one by abstracting out the varying parts.

Benjamin C. Pierce

Double earArea = earRadius * earRadius * Math.PI;

Double faceArea = faceRadius * faceRadius * Math.PI;

Double earArea = earRadius * earRadius * Math.PI;

Double faceArea = faceRadius * faceRadius * Math.PI;

public Double disqArea(Double radius) {
  return radius * radius * Math.PI;
}

Généraliser une procédure permet de prendre du recul

Double earArea = earRadius * earRadius * Math.PI;

Double faceArea = faceRadius * faceRadius * Math.PI;

public Double disqArea(Double radius) {
  return radius * radius * Math.PI;
}

Double earArea = disqArea(earRadius);

Double faceArea = disqArea(faceRadius);

public Double disqArea(Double radius) {
  return radius * radius * Math.PI;
}

Nommer les choses améliore la lisibilité

public Integer sum(List<Integer> numbers) {
  Integer result = 0;
  for (Integer n : numbers) {
    result = result + n;
  }
  return result;
}

public Integer product(List<Integer> numbers) {
  Integer result = 1;
  for (Integer n : numbers) {
    result = result * n;
  }
  return result;
}

public Integer reduce(
    List<Integer> numbers,
    Integer init,
    BiFunction<Integer, Integer, Integer> op
) {
  Integer result = init;
  for (Integer n : numbers) {
    result = op.apply(result, n)
  }
  return result;
}

public Integer sum(List<Integer> numbers) {
  return reduce(numbers, 0, (n1, n2) -> n1 + n2);
}

public Integer product(List<Integer> numbers) {
  return reduce(numbers, 1, (n1, n2) -> n1 * n2);
}

public Image allBeside(List<Image> images) {
  Image result = Image.EMPTY;
  for (Image image : images) {
    result = result.beside(image);
  }
  return result;
}

public Image allBeside(List<Image> images) {
  return reduce(images, Image.EMPTY, (i1, i2) -> i1.beside(i2));
}

Scala :

def reduce(numbers: List[Int], init: Int, op: (Int, Int) => Int): Int

def sum(numbers: List[Int]): Int =
  reduce(numbers, 0, (x, y) => x + y);

Haskell :

reduce :: Integer -> (Integer -> Integer -> Integer) -> [Integer] -> Integer
reduce init op numbers = …

sum :: [Integer] -> Integer
sum = reduce 0 (\x y -> x + y)

(Principe d’)abstraction : synthèse

Rend le code plus lisible et plus maintenable ;
Sa mise en œuvre est facilitée si le langage permet aux fonctions de prendre en paramètre des fonctions.

Applications pratiques

Architectures

Machines multi-cœurs ;
Architectures Web.

Tirer parti de ces ressources

Gérer la concurrence

Gérer l’intermittence des traitements

Logiciels

Systèmes de recommandation (Google, Facebook, etc.) ;
Économie collaborative (BlaBlaCar, AirBnB, Uber, etc.) ;
Intelligence artificielle (voiture autonome, reconnaissance de la parole, etc.).

Modéliser et traiter de l’information

Résumé

La programmation fonctionnelle est pratique pour :

prouver des propriétés sur des programmes ;
découper un problème complexe en problèmes plus simples indépendants ;
modéliser un domaine métier ;
écrire du code « au bon niveau d’abstraction » ;
tirer parti des machines multi-cœurs ou architectures distribuées ;
traiter de l’information intermittente.

Questions ?

julien@richard-foy.fr

Persistent data structures

Inconvénients de l’immuabilité

Écrire une interface homme-machine est difficile
- Toutefois, certains langages rendent ce problème étonnamment facile (p. ex. Elm)

Langage fonctionnel ?

Java

interface Optional<T> {
  public <U> Optional<U> map(Function<? super T, ? extends U> mapper);
}

Scala

trait Option[A] {
  def map[B](f: A => B): Option[B]
}

Haskell

fmap :: (a -> b) -> Maybe a -> Maybe b

La programmation fonctionnelle, c’est juste pour faire des preuves ?

Plan

Composition

Compositionnalité

La composition appliquée aux programmes

La composition appliquée aux programmes (variante)

`IllegalStateException`

Toute valeur doit être initialisée dans un état valide

La valeur associée à un nom donné ne doit pas changer au cours du temps

Immuabilité

Alias vs copie superficielle vs copie profonde

Travailler avec des valeurs

Composition(nalité) : synthèse

Modélisation

Partition de musique (en français)

Value Classes

« Un symbole musical est soit un silence, soit une note »

Sum Types

Modélisation : synthèse

Abstraction

Définition

On est déjà à mi-chemin !

Principe d’abstraction

Généraliser une procédure permet de prendre du recul

Nommer les choses améliore la lisibilité

(Principe d’)abstraction : synthèse

Applications pratiques

Architectures

Tirer parti de ces ressources

Paralléliser

Gérer la concurrence

Gérer l’intermittence des traitements

Logiciels

Modéliser et traiter de l’information

Résumé

Questions ?

Bonus

Persistent data structures

Inconvénients de l’immuabilité

Langage fonctionnel ?