FP is coming... le 19/05/2016

Loïc Knuchel
Freelance
Développeur web full-stack
Entrepreneur
Cookers / SalooN
loicknuchel@gmail.com
@loicknuchel
http://loic.knuchel.org/
Geek passionné

Fonctions pures
Immutabilité
Modifier une variable ?
Accès BDD ?
Logs ? Exceptions ?
CRUD ?

Au fait, c’est quoi la programmation fonctionnelle ?
“La programmation fonctionnelle est un paradigme de programmation qui
considère le calcul en tant qu'évaluation de fonctions mathématiques.”
Wikipedia

Wikipedia
“La programmation fonctionnelle est un style de programmation qui met l’accent
sur les fonctions qui ne dépendent pas de l’état du programme.” Functionnal
programming in scala

Wikipedia
“La programmation fonctionnelle est un style de programmation qui met l’accent
sur les fonctions qui ne dépendent pas de l’état du programme.” Functionnal
programming in scala
“La programmation fonctionnelle permet de coder de manière plus productive et
plus modulaire, avec moins de bugs.” Moi

Transformer un tableau
function toUpperCase(list){
var ret = [];
for(var i=0; i<list.length; i++){
ret[i] = list[i].toUpperCase();
}
return ret;
}
var names = ['Finn', 'Rey', 'Poe'];
console.log(toUpperCase(names));
// ['FINN', 'REY', 'POE']
public List<String> toUpperCase(List<String> list) {
List<String> ret = new ArrayList<>();
for(String item : list){
ret.add(item.toUpperCase());
}
return ret;
}
List<String> names = Arrays.asList("Finn", "Rey",
"Poe");
System.out.println(Arrays.toString(toUpperCase(names).
toArray()));
// [FINN, REY, POE]

return list.map(function(item){
return item.toUpperCase();
});
}
def toUpperCase(list: List[String]): List[String] =
list.map(item => item.toUpperCase)
val names = List("Finn", "Rey", "Poe")
println(toUpperCase(names))
// List(FINN, REY, POE)

return list.map(function(item){
});
}
def toUpperCase(list: List[String]): List[String] =
list.map(_.toUpperCase)
val names = List("Finn", "Rey", "Poe")
println(toUpperCase(names))
// List(FINN, REY, POE)

Créer son .map()
Array.prototype.map = function(callback){
var array = this;
var result = [];
for(var i=0; i<array.length; i++){
result[i] = callback(array[i]);
}
return result;
};

Séparation technique / métier
var array = this;
var result = [];
}
return result;
};
list.map(function(item){
});

var array = this;
var result = [];
}
return result;
};
});
Générique
Haut niveau d’abstraction
Un maximum de libraires externe

var array = this;
var result = [];
}
return result;
};
});
Générique
Haut niveau d’abstraction
Un maximum de libraires externe
Concis / Expressif
Focalisé sur le domaine
Un minimum de libraires externe

Manipuler des données
var data = [{
id: '123',
actions: [
{name: 'sendPicture', pictures: [
{path: '123/1.jpg', deleted: true, sync: false},
{path: '123/2.jpg', deleted: false, sync: true},
]},
{path: '123/4.jpg', deleted: false, sync: true}
]},
{path: '123/6.jpg', deleted: false, sync: false}
]}
]
}, {
id: '456',
actions: [
]},
{path: '123/4.jpg', deleted: true, sync: false}
]}
]
}];
function doSomething(items, id){
var pictures = [];
for (var i=0; i<items.length; i++) {
var item = items[i];
if (item.id === id) {
for (var j=0; j<item.actions.length; j++) {
var action = item.actions[j];
if (action.name === 'sendPicture') {
for (var k=0; k<action.pictures.length; k++) {
var picture = action.pictures[k];
if (!picture.deleted) {
pictures.push(picture);
}
}
}
}
}
}
return pictures;
}

var pictures = [];
}
}
}
}
}
}
return pictures;
}
}
}
}
}
}
}
return pictures;
}
Duplication !
Duplication !

var pictures = [];
}
}
}
}
}
}
return pictures;
}
}
}
}
}
}
}
return pictures;
}
Find item by id
Filter actions by name
Filter pictures not deleted

var pictures = [];
}
}
}
}
}
}
return pictures;
}
}
}
}
}
}
}
return pictures;
}
Find item by id
Filter actions by name
Filter pictures not deleted
Level up your abstraction !

// Finds the 1st elt of the sequence satisfying a predicate, if any
def find[A](p: (A) => Boolean): Option[A]
// Selects all elts of this collection which satisfy a predicate
def filter[A](p: (A) => Boolean): List[A]
// Builds a new list by applying a function to all elements of the list
def map[A, B](f: (A) => B): List[B]
// Applies a binary operator to all elts of this list
def reduce[A, B](f: (B, A) => B, b: B): B

return items
.find(function(item){ return item.id === id; }).actions
.filter(function(action){ return action.name === 'sendPicture'; })
.map(function(action){ return action.pictures; })
.reduce(function(a, b){ return a.concat(b); }, [])
.filter(function(picture){ return !picture.deleted; });
}
def getPictures(items: List[Item], id: String): List[Picture] =
items
.find(_.id == id)
.map(_.actions).getOrElse(List())
.filter(_.name == "sendPicture")
.flatMap(_.pictures)
.filter(!_.deleted)

}
}
}
}
}
}
return pictures;
}
items
.find(_.id == id)
.filter(!_.deleted)
var pictures = [];
for(var i=0; i<items.length; i++){
if(item.id === id){
for(var j=0; j<item.actions.length; j++){
if(action.name === 'sendPicture'){
for(var k=0; k<action.pictures.length; k++){
if(!picture.deleted){
}
}
}
}
}
}
return pictures;
}
return items
}
Safe ?

}
}
}
}
}
}
return pictures;
}
items
.find(_.id == id)
.filter(!_.deleted)
var pictures = [];
if(item.id === id){
}
}
}
}
}
}
return pictures;
}
return items
}
Cannot read property 'xxx' of
undefined x 6 !!!

}
}
}
}
}
}
return pictures;
}
items
.find(_.id == id)
.filter(!_.deleted)
var pictures = [];
if(item.id === id){
}
}
}
}
}
}
return pictures;
}
return items
}
undefined x 6 !!!
java.lang.NullPointerException x 6 !!!

}
}
}
}
}
}
return pictures;
}
items
.find(_.id == id)
.filter(!_.deleted)
var pictures = [];
if(item.id === id){
}
}
}
}
}
}
return pictures;
}
return items
}
undefined x 6 !!!
java.lang.NullPointerException x 6 !!!
Safe code o/

Java “Safe”
if (items != null) {
if (item != null && item.getId() == id && item.getActions() != null) {
if (action != null && action.getName() == "sendPicture" && action.getPictures() != null) {
if (picture != null && !picture.getDeleted()) {
}
}
}
}
}
}
}
return pictures;
}
items
.find(_.id == id)
.filter(!_.deleted)

Le problème
function getName(user) {
return user.name;
}

Le problème
return user.name;
}
public String getName(User user) {
return user.getName();
}

Le problème
return user.name;
}
}
def getUser(user: User): String = user.name

Le problème
return user.name;
}
getName();
// Cannot read property 'name' of
undefined
}
getName(null);
// java.lang.NullPointerException
// no null (used) in scala !

Le problème
return user.name;
}
getName();
undefined
getName(localStorage.getItem('user'));
// ERROR ???
}
getName(null);
getName(getUser());
// ERROR ???

Le problème
return user.name;
}
getName();
undefined
// ERROR ???
return user ? user.name : '';
}
return (user || {}).name;
}
}
getName(null);
getName(getUser());
// ERROR ???
if(user != null){
} else {
return "";
}
}

Le problème
return user.name;
}
getName();
undefined
// ERROR ???
return user ? user.name : '';
}
return (user || {}).name;
}
}
getName(null);
getName(getUser());
// ERROR ???
if(user != null){
} else {
return "";
}
}
def getUser(user: Option[User]): Option
[String] =
user.map(_.name)
def getUser(user: Option[User]): String =
user.map(_.name).getOrElse("")

Monad
● Wrapper (context) M[A]
● Fonction map def map[B](f: A => B): M[B]
● Fonction flatMap def flatMap[B](f: A => M[B]): M[B]

Monad
● List
● Option
● Future
● Try
● ...

Typage fort
● Filet de sécurité pour garantir la cohérence du programme

Typage fort
● Documentation pour le développeur

Typage fort
● Implémentent certains concepts

Typage fort
● null => Option

Typage fort
● null => Option
● exception => Either / Try

Typage fort
● null => Option
● exception => Either / Try
● async => Future
● ...

Typage fort
● Type Driven Development

Type all the things !!!
case class Contact(
firstName: String,
middleInitial: String,
lastName: String,
emailAddress: String,
isEmailVerified: Boolean
)

case class Contact(
firstName: String,
lastName: String,
)
Optionnel ?

case class Contact(
firstName: String,
lastName: String,
)
Optionnel ?
Contrainte ?

case class Contact(
firstName: String,
lastName: String,
)
Optionnel ?
Contrainte ?
Lien ?

case class Contact(
firstName: String,
lastName: String,
)
Optionnel ?
Contrainte ?
Lien ?
Logique métier ?

case class Contact(
firstName: String,
lastName: String,
)
case class Contact(
name: PersonalName,
email: EmailAddress)
Optionnel ?
Contrainte ?
Lien ?
Logique métier ?

case class Contact(
firstName: String,
lastName: String,
)
case class Contact(
name: PersonalName,
case class PersonalName(
firstName: String_50,
middleInitial: Option[String_1],
lastName: String_50)
sealed trait EmailAddress
case class VerifiedEmail(value: Email) extends EmailAddress
case class UnverifiedEmail(value: Email) extends EmailAddress
Optionnel ?
Contrainte ?
Lien ?
Logique métier ?

case class Contact(
firstName: String,
lastName: String,
)
case class Contact(
name: PersonalName,
case class PersonalName(
firstName: String_50,
middleInitial: Option[String_1],
lastName: String_50)
sealed trait EmailAddress
case class VerifiedEmail(value: Email) extends EmailAddress
case class UnverifiedEmail(value: Email) extends EmailAddress
case class String_1(value: String) {
require(value.length <= 1, s"String_1 should be <= 1 (actual: $value)")
override def toString: String = value
}
case class String_50(value: String) {
require(value.length <= 50, s"String_50 should be <= 50 (actual: $value)")
}
case class Email(value: String) {
require(value.contains("@"), s"Email should contain '@' (actual: $value)")
}
Optionnel ?
Contrainte ?
Lien ?
Logique métier ?

Stateless
Passer toute les données nécessaires à chaque fois

Stateless
● Testabilité

Stateless
● Testabilité
● Plus facile à comprendre

Immutabilité
● Scalabilité / Multithreading

Immutabilité
● Meilleur nommage

Immutabilité
● Séparation données / calculs
Types et Fonctions plutôt que Classes :
● Entity
● Value Object
● Service

Immutabilité
● Séparation données / calculs
Types et Fonctions plutôt que Classes :
● Entity
● Value Object
● Service
case class Person(
firstName: String,
lastName: String) {
val fullName = Person.fullName(this)
}
object Person {
def fullName(p: Person): String =
p.firstName+" "+p.lastName
}

No side effect
Effet de bord: lancer une exception, faire un appel (bdd, http, fichier…), récupérer la date actuelle,
modifier un paramètre, accéder à une variable “globale”, afficher un log...

No side effect
● Fonctions plus faciles à comprendre et à composer
● Possibilité de construire des choses complexes à partir d’éléments simples
● Local reasoning

● Lancer une exception ?
No side effect

No side effect
Renvoyer un Type d’erreur :
● Option[A] : un type ou pas
● Try[A] : un type ou un Throwable
● Either[A, B] : un type ou un autre
● Validation[A, Seq[ValidationError]] : un type ou une liste d’erreur

● Accès à une base de données ?
No side effect

No side effect
Effet de bord fait :
● en “bordure du système”
● idéalement par une librairie
● représenté par un type (Future, IO…)
Ex : def getDBUser(id: UserId): Future[Option[User]] = ???

● Afficher un log ?
No side effect

● Afficher un log ?
No side effect
On peut éventuellement se permettre un peu de liberté...

Architecture Hexagonale
strict FP
soft FP

“Easy to learn/write”
vs
“Easy to maintain”

DDD
Hexagonal architecture
Event Storming
Property based testing
Event Sourcing
Clean code
TDD
BDD
Craftsmanship
Living Documentation
CQRS

Take away
● Paramètre de fonction plutôt que donnée globale (même de classe)
● Créer des objets plutôt que de les modifier (immutable)
● Option plutôt que ‘null’
● Either/Try plutôt qu’une exception
● Collection API / recursivité plutôt que boucles for/while
● Eviter les ‘if’ autant que possible
● Séparation métier / technique

Références
Does the Language You Use Make a Difference ?
When DDD meets FP, good things happen
Ur Domain Haz Monoids (vidéo)
DDD: et si on reprenait l'histoire par le bon bout ?
DDD, en vrai pour le développeur
Functional programming Illustrated by Scala
Scala School!

loicknuchel@gmail.com @loicknuchel http://loic.knuchel.org/

FP is coming... le 19/05/2016

FP is coming... le 19/05/2016

Recommended

More Related Content

Viewers also liked

Viewers also liked(20)

More from Loïc Knuchel

More from Loïc Knuchel(14)

FP is coming... le 19/05/2016