Philosophie Fonctionnelle – Touraine Tech 2018

Philosophie Fonctionnelle – Touraine Tech 2018

Et si, au lieu de vous présenter l’outillage du paradigme fonctionnel parfois compliqué à prendre en main et fortement chargé en jargon, nous parlions de comment « penser en fonctionnel » ?

Et si, nous parlions du paradigme et non d’une implémentation spécifique ? 

Et si, on explicitait les idées qui font de ce paradigme une solution de choix pour certain type d’applications et qui explique sa popularité grandissante ? 

Contrairement à trop de présentation sur la programmation fonctionnelle, je vous propose de découvrir ce paradigme à travers son modèle de pensée et non de ses outils ou implémentations spécifiques.
Une présentation accessible à tous, sans jargon ou concepts complexes. Et qui présente un usage du fonctionnel, possible au quotidien, dans vos langages préférés.

Beb422437c1dfb5366f197919e41ac50?s=128

Arnaud LEMAIRE

February 23, 2018
Tweet

Transcript

  1. Church vs Turing mechanical computation (algorithm)

  2. Declarative vs Imperative recette de cuisine vs description du monde

  3. Impératif Objet Fonctionnel

  4. « 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 »
  5. « Then came object oriented programming, which is all about

    composing objects. »
  6. -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. »
  7. None
  8. None
  9. Philosophie Fonctionnelle @lilobase | arpinum.fr

  10. C’est quoi un état ?

  11. let variable;
 
 variable = "foo";
 console.log(variable);
 
 variable =

    "bar";
 console.log(variable); "foo" "bar" temps
  12. let min = 0; for (item in array) { if

    (item < min) min = item; } console.log(min);
  13. "foo" "bar" invalid value context A context B

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

  15. None
  16. None
  17. Global shared mutable datastore Database

  18. Shared state concurrency Race conditions Synchronization by blocking Mutual exclusion

    blocking Starvation DeadLock Priority Inversion Lock Thread
  19. Plop vs Vlop Place Oriented Programming vs Value Oriented Programming

  20. temps x valeur = variable valeur = constante

  21. variable constante

  22. variable constante

  23. variable constante

  24. -Michael Feathers « OO makes code understandable by encapsulating moving

    parts. FP makes code understandable by minimizing moving parts »
  25. C’est quoi la différence entre une valeur et une fonction

    ?
  26. valeur accessible maintenant = constante const hello = "world"; valeur

    accessible « plus tard » = fonction const pow2 = (x) => x ** 2;
  27. 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)
  28. 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));
  29. 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);
  30. 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
  31. Quelles différences entre l’objet et le fonctionnel ?

  32. 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
  33. 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)
  34. Ce qui permet d’exprimer un algorithme complex composant des fonctions

    existantes move_to_and_scale = 
 -> (circle) { 
 move_to(scale(circle, 20), 3, 10) 
 }
  35. 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)
  36. 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
  37. 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
  38. -Alan Perlis « It is better to have 100 functions

    operate on one data structure than 10 functions on 10 data structures »
  39. C’est quoi un objet ?

  40. 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);
 }
  41. const triangle = {
 
 rotate: (d) => (…),
 


    move: (x, y) => (…),
 
 //...
 };
  42. class Triangle:
 
 def rotate(self, degrees):
 //...
 
 def move(self,

    x, y):
 //...
 
 //...
  43. 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(…);
  44. 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)
  45. C’est quoi une fonction ?

  46. Ensemble de départ Ensemble d’arrivé fonction Type de départ Type

    d’arrivée
  47. f() g() compose(f,g) type A type B type C type

    A type C
  48. Composition de transformation

  49. Séquentiel

  50. Ok, mais moi demain je fais quoi ?

  51. Less moving parts

  52. Immutabilité partout const constant = "everywhere"; Y compris sur les

    collections de données (map, filter, reduce, …)
  53. 
 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
  54. 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
 }
  55. 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
  56. <R, C extends Command<R>> Try<R> dispatch(C command) { return handlers.get(command.getClass())

    .map(h -> (CommandHandler<R, C>) h) .map(h -> execute(h, command)) .getOrElse(() -> Try.failure(
 new HandlerNotFoundException(command)) ); }
 
 private final Map<Class, CommandHandler> handlers;
  57. Business domain (functional)

  58. None
  59. Merci Arnaud LEMAIRE | @lilobase