Philosophie Fonctionnelle – Touraine Tech 2018

Slide 1

Slide 1 text

Church vs Turing mechanical computation (algorithm)

Slide 2

Slide 2 text

Declarative vs Imperative recette de cuisine vs description du monde

Slide 3

Slide 3 text

Impératif Objet Fonctionnel

Slide 4

Slide 4 text

« Composition is the essence of programming. We’ve been composing things forever.  The principles of structural programming revolutionized programming because they made blocks of code composable »

Slide 5

Slide 5 text

« Then came object oriented programming, which is all about composing objects. »

Slide 6

Slide 6 text

-Bartosz Milewski « Functional programming is not only about composing functions and algebraic data structures — it makes concurrency composable — something that’s virtually impossible with other programming paradigms. »

Slide 7

Slide 7 text

No content

Slide 8

Slide 8 text

No content

Slide 9

Slide 9 text

Philosophie Fonctionnelle @lilobase | arpinum.fr

Slide 10

Slide 10 text

C’est quoi un état ?

Slide 11

Slide 11 text

let variable;    variable = "foo";  console.log(variable);    variable = "bar";  console.log(variable); "foo" "bar" temps

Slide 12

Slide 12 text

let min = 0; for (item in array) { if (item < min) min = item; } console.log(min);

Slide 13

Slide 13 text

"foo" "bar" invalid value context A context B

Slide 14

Slide 14 text

Il faut construire l’état dans le bon ordre Programmation séquentielle

Slide 15

Slide 15 text

No content

Slide 16

Slide 16 text

No content

Slide 17

Slide 17 text

Global shared mutable datastore Database

Slide 18

Slide 18 text

Shared state concurrency Race conditions Synchronization by blocking Mutual exclusion blocking Starvation DeadLock Priority Inversion Lock Thread

Slide 19

Slide 19 text

Plop vs Vlop Place Oriented Programming vs Value Oriented Programming

Slide 20

Slide 20 text

temps x valeur = variable valeur = constante

Slide 21

Slide 21 text

variable constante

Slide 22

Slide 22 text

variable constante

Slide 23

Slide 23 text

variable constante

Slide 24

Slide 24 text

-Michael Feathers « OO makes code understandable by encapsulating moving parts. FP makes code understandable by minimizing moving parts »

Slide 25

Slide 25 text

C’est quoi la différence entre une valeur et une fonction ?

Slide 26

Slide 26 text

valeur accessible maintenant = constante const hello = "world"; valeur accessible « plus tard » = fonction const pow2 = (x) => x ** 2;

Slide 27

Slide 27 text

Calcul immédiat au résultat (eager evaluation) const result =   heavy_process(some, args); const lazy_result = () =>   heavy_process(some, args); Calcul au moment de l’utilisation (lazy evaluation)

Slide 28

Slide 28 text

Fonctions et valeurs sont considérées à équivalences = fonctions d’ordre supérieures const pow = x => y => y ** x;  const pow3 = pow(3);   console.log(pow3(3));

Slide 29

Slide 29 text

Calculée, une fonction peut être remplacée par sa valeur = mémoïzation const memoize = (f) => {  const memo = {};  return (...args) => (args in memo) ?   memo[args] : (memo[args] = f(...args));  };    const add = (x, y) => x + y;  const memoized_add = memoize(add);  memoized_add(3, 4);

Slide 30

Slide 30 text

La différence se trouve l’immédiateté de l’accès à l’information contenue dans la référence associée Il devient possible de manipuler les fonctions comme des valeurs

Slide 31

Slide 31 text

Quelles différences entre l’objet et le fonctionnel ?

Slide 32

Slide 32 text

En poo les types sont très souvent associés à des structures de données nommées Il n’y a pas de différence entre la « forme » de la donnée et ses comportements circle = Circle.new(5, 7, 15) circle.move(3, 10)  circle.scale(20) Deux types sont égaux si ils portent le même nom

Slide 33

Slide 33 text

Les objets proposent une interface à des types de données « complexes » Le style fonctionnelle utilise peu de type différents mais manipulés par des fonctions génériques circle = Circle.new(5, 7, 15)  circle.move(3, 10)  circle.scale(20) circle = [5, 7, 15]  move_to(circle, 3, 10)  scale(circle, 20)

Slide 34

Slide 34 text

Ce qui permet d’exprimer un algorithme complex composant des fonctions existantes move_to_and_scale =   -> (circle) {   move_to(scale(circle, 20), 3, 10)   }

Slide 35

Slide 35 text

Un objet est de la donnée sur laquelle l’on va venir appliquer du comportement Une closure est du comportement qui attend de la donnée circle = Circle.new(5, 7, 15)  circle.move(3, 10) move_to_parametrized = ->(x, y) {  -> (circle) {   move_to(circle, x, y)   }}  circle = [5, 7, 15]  move_to_5_15 = move_to_parametrized(5, 15);  move_to_5_15(circle)

Slide 36

Slide 36 text

type 'a tree = | Node of 'a tree * 'a * 'a tree | Leaf;; let rec fold_tree f a t = match t with | Leaf -> a | Node (l, x, r) ->   f x (fold_tree f a l) (fold_tree f a r);; Le pattern matching permet d’adapter un comportement en se basant sur la structure ou le type de la donnée

Slide 37

Slide 37 text

La programmation fonctionnelle possède des structure de donnée très simple, sur lesquelles des fonctions vont pouvoir adapter leurs comportement Smart data-type vs smart functions

Slide 38

Slide 38 text

-Alan Perlis « It is better to have 100 functions operate on one data structure than 10 functions on 10 data structures »

Slide 39

Slide 39 text

C’est quoi un objet ?

Slide 40

Slide 40 text

function copyF($fromPath, $toPath) {  $from = fopen($fromPath, 'r');  $to = fopen($toPath, 'w+');  $content = fread($from,  filesize($fromPath));  fwrite($toHandle, $contentToCopy);  }   function copyO($fromPath, $toPath) {  $from = new SplFileObject($fromPath);  $to = new SplFileObject($toPath);  $content = $from->fread($from->getSize());  $to->fwrite($content);  }

Slide 41

Slide 41 text

const triangle = {    rotate: (d) => (…),    move: (x, y) => (…),    //...  };

Slide 42

Slide 42 text

class Triangle:    def rotate(self, degrees):  //...    def move(self, x, y):  //...    //...

Slide 43

Slide 43 text

const square = (l, x, y) => {  const this = [l, x, y];    const rotate = (self, d) => (…);  const move = (self, x, y) => (…);    return {  rotate: (d) => rotate(this, d),  move: (x, y) => move(this, x, y)  //...  }  };    const obj = square(5, 10, 15);  obj.rotate(…);

Slide 44

Slide 44 text

Un langage fonctionnel pourra toujours exprimer la notion « d’objet », mais un langage objet ne garantie pas la possibilité d’utiliser un style fonctionnel (La plupart des langages possèdent maintenant des constructions fonctionnelles)

Slide 45

Slide 45 text

C’est quoi une fonction ?

Slide 46

Slide 46 text

Ensemble de départ Ensemble d’arrivé fonction Type de départ Type d’arrivée

Slide 47

Slide 47 text

f() g() compose(f,g) type A type B type C type A type C

Slide 48

Slide 48 text

Composition de transformation

Slide 49

Slide 49 text

Séquentiel

Slide 50

Slide 50 text

Ok, mais moi demain je fais quoi ?

Slide 51

Slide 51 text

Less moving parts

Slide 52

Slide 52 text

Immutabilité partout const constant = "everywhere"; Y compris sur les collections de données (map, ﬁlter, reduce, …)

Slide 53

Slide 53 text

  class Circle   def initialize r, x, y  @r = r  @x = x  @y = y  end    def move x, y  Circle.new(@r, @x + x, @y + y)  end  end

Slide 54

Slide 54 text

const todos = (state = [], action) =>  switch (action.type) {  case ADD_TODO:  [  ...state,  {  text: action.text,  completed: false  }  ]  case TOGGLE_TODO:  state.map((todo, index) =>  index === action.index) ?   {  …todo,   completed: !todo.completed  } : todo  })  default: state  }

Slide 55

Slide 55 text

const Min = t.refinement(  t.String, (s) => s.length > 2);  const Max = t.refinement(  t.String, (s) => s.length < 5);    const MinMax = t.intersection([Min, Max]);    MinMax.is('abc'); // => true  MinMax.is('a'); // => false  MinMax.is('abcde'); // => false

Slide 56

Slide 56 text

> Try dispatch(C command) { return handlers.get(command.getClass()) .map(h -> (CommandHandler) h) .map(h -> execute(h, command)) .getOrElse(() -> Try.failure(  new HandlerNotFoundException(command)) ); }    private final Map handlers;