[Java] Programmation fonctionnelle

[Fabienne]

Avec Java 8, une discrète (r)évolution s'est opérée, avec l'arrivée des functors et des expressions lambda, qui permettent (enfin) une programmation plus ou moins fonctionnelle. Qu'est-ce qu'un functor ? Rien de plus qu'une fonction encapsulée dans un objet ! Quel intérêt ? Avant Java 8, il était impossible de passer une fonction en paramètre à une autre fonction. Depuis Java 8, c'est possible (et facile) parce qu'un functor est un objet ! Prenons un exemple simple, on va définir un functor qui multiplie un entier par 2, et on va le passer en argument à la fonction bien connue println (voir code ci-dessous).

Les interfaces des functors sont dans le package java.util.function, ne pas oublier l'import !
La définition de mult2 (i -> i * 2) est ce qu'on appelle une expression lambda. Noter qu'on n'a pas besoin de préciser le type de i, parce qu'il peut être inféré à partir de celui de mult2 !

Code: Tout sélectionner

package functordemo1;

import java.util.function.Function;

public class FunctorDemo1
{
   public static Function<Integer, Integer> mult2 = i -> i * 2;
   public static void main(String[] args)
   {
      System.out.println(mult2.apply(3));
   }
}

[Fabienne]

De nombreuses interfaces fonctionnelles (appellation plus correcte que functor qui peut porter à confusion avec d'autres langages) sont disponibles dans le package java.util.function, couvrant tous les types de fonctions dont on peut avoir besoin. Voici une mini-démo de quelques unes d'entre elles :
Function<U, R> : fonction à un argument de type U ; résultat de type R
BiFunction<U, V, R> : fonction à deux arguments de types U et V ; résultat de type R
Consumer<U> : fonction à un argument de type U ; pas de résultat renvoyé
BiConsumer<U, V> : fonction à deux arguments de types U et V ; pas de résultat renvoyé
Supplier<R> : fonction sans argument ; résultat de type R

Code: Tout sélectionner

package functordemo2;

import java.util.function.Function;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.BiConsumer;
import java.util.function.Supplier;

public class FunctorDemo2
{
   public static Function<Integer, Integer> mult2 = i -> i * 2;
   public static BiFunction<Integer, Integer, Integer> sum = (i, j) -> i + j;
   public static Consumer<Integer> plus1 = i -> System.out.println(i + 1);
   public static BiConsumer<String, Object> display = (n, v) -> System.out.println(n + " = " + v);
   public static Supplier<String> hello = () -> "Hello world";
   public static void main(String[] args)
   {
      System.out.println(mult2.apply(3));
      System.out.println(sum.apply(5, 6));
      plus1.accept(7);
      display.accept("X", 3.5);
      System.out.println(hello.get());
   }
}

[Fabienne]

Les interfaces fonctionnelles sont (entre autres) très utiles lorsqu'il s'agit d'itérer une liste, de la filtrer, d'effectuer des opérations sur ses éléments, etc. C'est l'objet de la petite démo du jour : on part d'une liste de nombres entiers (lsx, on la filtre, on multiplie le résultat par une certaine valeur, et on collecte le résultat dans une nouvelle liste (lsy), le tout sans avoir à utiliser un itérateur ! Vous remarquerez que, contrairement à l'exemple précédent, les interfaces fonctionnelles sont paramétrées, ce qui décuple les possibilités...

Ci-dessous le code de l'exemple, et ensuite le résultat affiché à l'exécution :

Code: Tout sélectionner

package functordemo3;

import java.util.List;
import java.util.Arrays;
import java.util.stream.Collectors;

import java.util.function.BiConsumer;
import java.util.function.Predicate;
import java.util.function.Function;

public class FunctorDemo3
{
   // functor pour la fonction d'affichage
   public static BiConsumer<String, Object> disp = (n, o) -> System.out.println(n + " = " + o);
   public static List<Integer> lsx = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
   public static List<Integer> lsy;
   
   // functors pour les filtres
   public static Predicate<Integer> max(int maxv)
   {
      return i -> i <= maxv;
   }
   public static Predicate<Integer> min(int minv)
   {
      return i -> i >= minv;
   }
   public static Predicate<Integer> interv(int minv, int maxv)
   {
      return i -> i >= minv && i <= maxv;
   }
   // functor pour la multiplication
   public static Function<Integer, Integer> mult(int multv)
   {
      return i -> i * multv;
   }
   
   // fonction d'affichage
   public static void display(String name, Object object)
   {
      disp.accept(name, object);
   }

   public static void main(String[] args)
   {
      display("lsx", lsx);
      lsy = lsx.stream()
         .filter(max(3).or(min(7)))
         .map(mult(3))
         .collect(Collectors.toList());
      display("lsy", lsy);
      lsy = lsx.stream()
         .filter(interv(4, 6))
         .map(mult(2))
         .collect(Collectors.toList());
      display("lsy", lsy);
   }
}

Code: Tout sélectionner

lsx = [1, 2, 3, 4, 5, 6, 7, 8, 9]
lsy = [3, 6, 9, 21, 24, 27]
lsy = [8, 10, 12]

Pour info, la fonction display est un petit utilitaire d'affichage, lui-même écrit avec un functor !

Si vous avez des questions, n'hésitez surtout pas...

[Fabienne]

Petite parenthèse philosophique !
Cette ”couche fonctionnelle" apparue dans Java 8 (donc il y a presque 10 ans...) n'a cessé de s'attirer les foudres des intégristes de la programmation fonctionnelle, qui ne la trouvent pas assez "pure", et concluent que ça ne fait pas de Java un langage fonctionnel digne de ce nom. D'une certaine façon, ils ont raison, mais oublient que le but n'était pas de transformer Java en vrai langage fonctionnel, mais de le doter d'une boîte à outils supplémentaire (que personne n'est obligé d'utiliser), sans compromettre sa polyvalence et ses fondamentaux. De ce point de vue, il me semble que le pari est réussi.

Et si vous voulez découvrir un vrai langage fonctionnel, intéressez-vous plutôt à Haskell, qui est un des plus abouti.