Le retour de la fonction

@loicknuchel

High-order function

Currying

Pure function

Functor Monad

Monoid

Immutable

Récursif

Programmation générique

for loop is everywhere

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']

for loop is everywhere

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']

Boilerplate !!!

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;};

for loop is everywhere

(High-order function)

for loop is everywhere

function toUpperCase(list){ return list.map(function(item){ return item.toUpperCase(); });}

for loop is everywhere

function toUpperCase(list){ return list.map(item => item.toUpperCase());}

Séparation technique vs métier

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;};

list.map(item => item.toUpperCase());

Générique / RéutilisableHaut niveau d’abstraction

Concis / ExpressifFocalisé sur le domaine

Scala collection API (en partie)def map[B](f: (A) => B): List[B]def filter(p: (A) => Boolean): List[A]def partition(p: (A) => Boolean): (List[A], List[A])def zip[B](that: List[B]): List[(A, B)]def sliding(size: Int): Iterator[List[A]]

def find(p: (A) => Boolean): Option[A]def exists(p: (A) => Boolean): Boolean

def flatten[B]: List[B]def flatMap[B](f: (A) => List[B]): List[B]

def groupBy[K](f: (A) => K): Map[K, List[A]]def grouped(size: Int): Iterator[List[A]]

def fold[A1 >: A](z: A1)(op: (A1, A1) => A1): A1def reduce[A1 >: A](op: (A1, A1) => A1): A1def forall(p: (A) => Boolean): Boolean

def take(n: Int): List[A]def drop(n: Int): List[A]def distinct: List[A]

The billion dollar mistake !

function toUpperCase(list){ var ret = []; for(var i=0; i<list.length; i++){ ret[i] = list[i].toUpperCase(); } return ret;}

Safe ?

The billion dollar mistake !

function toUpperCase(list){ var ret = []; for(var i=0; i<list.length; i++){ ret[i] = list[i].toUpperCase(); } return ret;}

Unsafe !

Cannot read property 'xxx'

of undefined !!!

The billion dollar mistake !

function toUpperCase(list){ var ret = []; for(var i=0; i<list.length; i++){ ret[i] = list[i].toUpperCase(); } return ret;}

function toUpperCase(list){ var ret = []; if(Array.isArray(list)) { for(var i=0; i<list.length; i++){ if(typeof list[i] === 'string'){ ret[i] = list[i].toUpperCase(); } else { ret[i] = list[i]; } } } return ret;}

Unsafe ! Unreadable !

The billion dollar mistake !

function toUpperCase(list){ var ret = []; for(var i=0; i<list.length; i++){ ret[i] = list[i].toUpperCase(); } return ret;}

function toUpperCase(list){ var ret = []; if(Array.isArray(list)) { for(var i=0; i<list.length; i++){ ret[i] = list[i].toUpperCase(); } } return ret;}

function toUpperCase(list){ var ret = []; if(Array.isArray(list)) { for(var i=0; i<list.length; i++){ if(typeof list[i] === 'string'){ ret[i] = list[i].toUpperCase(); } else { ret[i] = list[i]; } } } return ret;}

Unsafe ! Unreadable ! (not so) smart

The billion dollar mistake !// no null !

def toUpperCase(list: List[String]) = list.map(_.toUpperCase)

def toUpperCase(list: List[Option[String]]) = list.map(_.map(_.toUpperCase))

List.map() vs Option.map() ???

List.map() vs Option.map() ???

Fonctors !!!

def toWords(sentences: List[String]): List[List[[String]] = sentences.map(_.split(" ").toList)

def toWords(sentences: List[String]): List[String] = sentences.flatMap(_.split(" ").toList)

def toWords(sentences: List[String]): List[List[[String]] = sentences.map(_.split(" ").toList)

def toWords(sentences: List[String]): List[String] = sentences.flatMap(_.split(" ").toList)

Applicative !

def toWords(sentences: List[String]): List[List[[String]] = sentences.map(_.split(" ").toList)

def toWords(sentences: List[String]): List[String] = sentences.flatMap(_.split(" ").toList)

Applicative !

Fonctor + Applicative = Monad

def toWords(sentences: List[String]): List[List[[String]] = sentences.map(_.split(" ").toList)

def toWords(sentences: List[String]): List[String] = sentences.flatMap(_.split(" ").toList)

Monads !

Option[A]

List[A]Future[A]Page[A]

Take away

● Monter son niveau d’abstration (ASM -> IMP -> OOP -> FUN !)

● Bannir null !!!

● Remplacer les ‘for’ par des fonctions de plus haut niveau

● Séparer le code technique de la logique métier