2.3 Currying Functional Programming Principles in Scala English French

2.3 CurryingYouTube↗ IA↗(long shot)
Education 1.1K views 8 likes 1 dislikes 11 Sep 2017

Functional Programming Principles in Scala 1.3K subscribers N/A YouTube↗

Click to Play Video

Last session we have introduced high order functions as building blocks of programs.

Lors de la derniere session, nous avons introduit les fonctions d'ordre superieur comme blocs de construction de programmes.

High order functions are essential in many functional programming languages.

Les fonctions d'ordre superieur sont indispensables dans de nombreux langages de programmation fonctionnelle.

So much so that there's a special form to write them.

Tant et si bien, qu'il y a une forme speciale de les ecrire

Which we are going to cover in this session.

que nous allons couvrir dans cette session.

So the topic of this session is currying, and I do not mean the food with that.

Donc le theme de cette seance est la curryfication, et je ne parle pas le la nouriture.

You'll find out in a second what that is. For our motivation, let's look again at

Vous decouvrirez dans une seconde ce que c'est.Regardons a nouveau

our summation functions, sumInts, sumCubes, sumFactorials.

nos fonctions de sommation, sumInts, sumCubes, sumFactorials.

We could factor out the body of these functions and now simply pass the function

Nous pourrions factoriser le corps de ces fonctions et ensuite simplement passer la fonction

to apply to each element in the interval. And the two pounds in the intervals.

a appliquer a chaque element dans l'intervalleet aux deux bornes de l' intervalle.

But there's still repetition. Each of the three functions takes two

Mais il y a encore des repetitions.Chacune des trois fonctions prend deux

parameters A and B and then passes them on to the sum functions.

parametres, A et B et les transmet ensuite aux fonctions sum.

Can we get rid of these parameters and thereby become even shorter?

Peut-on se debarrasser de ces parametres et ainsi raccourcir encore plus ?

To see how that could be done, let's rewrite the sum functions as you see here.

Pour voir comment cela pourrait se faire, nous allons reecrire les fonctions sum comme vous le voyez ici.

So that sum function now takes only a single parameter, F, of type n to n as

La fonction sum prend desormais uniquement un seul parametre, F, de type int a int comme

before, and it returns a function. As its result indicated by this function

auparavant et retourne une fonction comme resultat.Comme l'indique le

type here. So how can it return a function as a

type de cette focntion.Comment peut-elle retourner une fonction comme

result? Well, it defines a function in this body,

resultat ?Eh bien, on definit une fonction dans ce corps,

sum F, which takes the two bounds and does the usual computation that you've seen

sumF, qui prend les deux limites et fait le calcul habituel que vous avez vu

before. And that function sum F will be returned

avant.Et cette focntion sumF sera retournee

from sum. So sum is now a function that returns

depuis sum.Somme est donc maintenant une fonction qui retourne

another function. In particular, a locally defined function.

une autre fonction.En particulier, une fonction definie localement.

So if you do that, then we can in fact define sumInts to be simply sum of x,

Donc si vous faites cela, alors nous pouvons en effet definir sumInts pour etre simplement sum(x=>x)

arrow x, sum cubed is sum of the cubing function, and SUM factorial is sum of the

sumCubes est la somme de la fonction de cubage et sumFactorials est la somme de la

fact function. It turns out that these functions, they

fonction fact.Il s'avere que ces fonctions

are just exactly the same as the functions we defined before, and they can applied

sont exactement les memes que les fonctions que nous avons definies avant, et elles peuvent etre appliquees,

just like the functions we defined before. So, we could say, SUM cubes one, ten, plus

tout comme les fonctions nous avons definies avant.Alors, on pourrait dire sumCubes(1, 10) +

SUM factorials ten, twenty. Next question.

sumFactorials(10, 20)Question suivante.

In the previous example can we avoid the middleman, sum N, sum cubes, and the like.

Dans l'exemple precedent pouvons-nous eviter les intermediaires, sumInts, sumCubes et autres.

Can we use directly the general sum function?

Pouvons-nous utiliser directement la fonction generale sum ?

Of course. We simply write, sum of, in this case

Bien sur.Nous ecrivons simplement somme de, dans ce cas,

cube, and then the bounds one to ten. Let's analyze that a, a little bit more.

cube, puis les bornes de 1 a 10.Analysons cela un peu plus.

So sum of cube applies to sum function. To the cube function.

Donc sum(cube) applique a la fonction sumla fonction cube.

And returns the sum of cube's function. Sum of cube is therefore equivalent to sum

et retourne la somme de fonction cube.sum(cube) est donc equivalent a sumCubes.

cubes, and that function is next applied to the arguments one and ten.

Et cette fonction est ensuite appliquee sur les arguments (1, 10).

So what that shows is that function application associates to the left.

Donc ce que cela montre est que l'application de fonction associe a gauche.

If we write, sum of cube 110, then that's really the same thing as sum of cube.

Si nous ecrivons, sum(cube)(1, 10), alors c'est vraiment la meme chose que (sum(cube)).

This expression returns a function and that function then is applied to one and

Cette expression retourne une fonction et cette fonction est ensuite appliquee a 1 et 10

ten. So here's another piece of syntactic

Alors, Voici un autre morceau de sucre

sugar. The definition of functions that return

syntaxique.La definition des fonctions qui retournent

functions is so useful in functional programming that we have a syntax for it

des fonctions est tellement utile en programmation fonctionnelle que nous avons une syntaxe pour elle

in skylar. So the A previous definition of sum

en scala.Si l'ancienne definition de sum

actually can be written shorter like that. We can just combine the, two parameter

en fait peut etre ecrite plus courte comme �a.Nous pouvons juste combiner les deux listes de parametres

lists of the outer function and the nested function and write them one after the

de la fonction externe et la fonction imbriquee et les ecrire les uns apres les

other. It would say sum of F int and then comes

autres.On dirait sum(f: int => int) et ensuite

another parameter list with A and B. And the body of the sum function is very

vient un autre parametre de la liste avec A et b.Et le corps de la fonction somme est tres

much like it was before. You might ask, well what's the point of

semblable a avant.Vous pourriez demander, quel est le but de

doing it that way instead of simply writing the function with three parameters

faire de cette fa�on au lieu d'ecrire simplement la fonction avec trois parametres

like we did at the beginning? Well the idea is that if you do that then

comme nous l'avons fait au debut ?Eh bien l'idee est que si vous faites �a alors

actually you can write sum of, let's say cube, separately.

en fait, vous pouvez ecrire somme de, disons cube, separement.

That's a valid expression by itself and you can avoid passing the other arguments.

C'est une expression valide en soi, et vous pouvez eviter de passer les autres arguments.

They will arrive in a different parameters list that can be applied later on in a

Ils arriveront dans une liste differente de parametres qui peut etre appliquee par la suite dans

different context. So I've said that functions with multiple

contexte different.Donc j'ai deja dit que les fonctions avec plusieures

parameter lists are syntactic sugar. Let's see how they expand.

listes de parametres sont du sucre syntaxique.Nous allons voir comment elles se developpent.

If you have a function with multiple parameter lists like that, RX1, RXN equals

Si vous avez une fonction avec plusieures listes de parametres comme �a, RX1, RXN = E

E, where N is greater than zero, that's, in fact, equivalent to taking the first N

ou N est superieur a zero, c'est, en fait, equivalent a prendre le premier N

minus one number of parameter lists. And for the last one, you create a fresh

moins un nombre de listes de parametres.Et pour le dernier, vous creez une nouvelle

function called G, that takes the last list.

fonction appelee G, qui prend la derniere liste,

Maps it to the body E, and G is the function that gets returned from F.

la fait correspondre au corps E, et G est la fonction qui est retournee par F.

That was exactly the definition we did with sum F when we modeled the sum

C'est exactement la definition que nous avons fait avec sumF lorsque nous avons modelise la fonction

function that dropped its second parameter list by having the inner function, sum F.

sum qui a laisse tomber sa seconde liste de parametres en ayant la fonction interne, sumF.

Or for short, we can just write an anonymous function.

Ou pour faire court, on peut simplement ecrire une fonction anonyme.

So the, the, the definition up here would also be equivalent to the definition that

La definition ici serait equivalente a la definition que

you see down here, where the last parameter list is, the parameter list of

vous voyez ici, ou la derniere liste de parametres est la liste de parametres

anonymous function that maps to E. Now, if you repeat that process n times,

d'une fonction anonyme qui mappe vers E.Maintenant, si vous repetez que ce processus n fois,

then our original n parameter list function is mapped to a function that has

alors notre liste originale de n parametres est mappee a une fonction qui n'a

no parameter list at all, but on the right hand side we have n nested anonymous

aucune liste de parametre, mais sur la partie droite nous avons n fonctions

functions. This style of definition in function

imbriquees.Ce style de definition en application

application where essentially every function is mapped to an expression that

de fonction ou essentiellement chaque fonction est mappee a une expression qui

consists of anonymous functions, nested anonymous functions, that each take one

se compose de fonctions anonymes, de fonctions anonymes imbriquees, qui prennent chacune un

parameter, is called currying. It's named after its promoter, Haskell

parametre, est appele curryfication.Il est nomme d'apres son promoteur, Haskell

Brooks Curry, who was a logician in the twentieth century.

Brooks Curry, qui etait un logicien au XXe siecle.

It's no coincidence that Haskell Brooks Curry shares his first name with the

Ce n'est pas par hasard que Haskell Brooks Curry partage son prenom avec le

Haskell programming language. In fact, the, this idea goes back even

Langage de programmation Haskell.En cette idee remonte meme

further to Shawn Finkel and probably Fricke, but the term Currying has stuck.

a Shawn Finkel et probablement Fricke, mais le terme est reste Curryification.

So let's take one more look at types. Given this function, sum f int and with it

Jetons un coup d'oeil de plus aux types.Compte tenu dde cette fonction, sumF int et avec elle

two arguments, what is its type? The answer would be, it first, it is the

deux arguments, quel est son type ?La reponse serait, tout d'abord, que c'est

function that takes the function's argument, so that would be the argument

fonction qui prend une fonction comme argument, qui serait donc le type de l'argument.

pipe. And that returns a function, that takes

Et elle retourne une fonction, qui prend

two integers as arguments that would both be those two, and that returns finally an

deux entiers comme arguments, ce seraient ces deux-la, et qui retourne finalement un

int. So note that functional pipes associate to

int.Notez donc que les types fonctionnels associent a

the right. Here I could have written also.

droite.Ici j'aurais pu ecrire aussi

Type like this. So, we take the intuitive function and we

le type comme ceci.Donc, nous prenons la fonction int=>int et nous

return this function, but this blue parenthesis here are actually redundant.

Cette retournons cette fonction, mais ces parentheses bleues ici sont en fait redondantes.

Because, in general, at types such as int, arrow int, arrow int is read as int arrow,

Parce que, en general, un type tel que int=>int est lu comme

and then the second pairs of ins are in parenthesis.

int => (int => int)

So we put the parenthesis for function types on the right.

Nous mettons les parentheses pour les types de fonction a droite.

Let's do an exercise. We have seen the sum function.

Nous allons faire un exercice.Nous avons vu la fonction sum.

Can we write a product function that calculates the product of the values of a

Pouvons-nous ecrire une fonction product qui calcule le produit des valeurs d'une

function for the points on a given interval?

fonction pour les points d'intervale donne ?

As a second exercise, once you have product can you write factorial in terms

Une fois que vous avez product, pouvez-vous ecrire comme deuxieme exercice, factorial en termes

of it? And the third part of the exercise would

de celle-ci ?Et la troisieme partie de l'exercice serait:

be, can you think of a more general function which generalizes both sum and

pouvez-vous penser a une fonction plus generale qui generalise sum et product?

product? So let's see how we would answer that

Voyons donc comment nous repondrions a cet

exercise. I have already opened a new worksheet and

exercice.J'ai deja ouvert une nouvelle feuille de calcul et

given you the product function and the parameters and results it takes.

donne la fonction product et les parametres et les resultats qu'il faut.

So that's analogous to some product would take a function that goes from end to end

C'est analogue a sum, product prendrait une fonction qui va de int a int

into two pounds, which are in ints, and we would return an int.

dans deux bornes, qui sont des ints, et nous retournerions int.

How would we define it? So we would go analogous to sum function.

Comment le definirait-on ?On le ferait de maniere analogue a la fonction sum.

First ask, well, if the bounds are empty, then we want to return the unit value for

Demandez tout d'abord, Eh bien, si les bornes sont vides, nous voulons retourner la valeur unitaire de

multiplication. So for sum, the unit value was a zero, but

multiplication.Pour la somme, la valeur unitaire etait un zero, mais

for multiplication, it's a one. So we return a one here.

pour la multiplication, c'est un 1.Nous retournons donc un 1.

And otherwise, we take f of a, and now times product of f and a, plus one, and b.

Et dans le cas contraire, nous prenons f(a) product(f)(a + 1, b).

Let's test it. Oh, forgot the function.

Nous allons le tester.Oh, j'ai oublie la fonction.

Let's take the squares of all. Ints between three and seven.

Nous allons prendre les carres de tous lesints allant de trois a sept.

That gives us a value which is hard to check, so let's do a smaller, 144.

Nous obtenons une valeur qui est difficile a verifier, donc nous allons faire un plus petit, 144,

That looks correct. Let's come to the second part of the

Cela semble correct.Venons-en a la deuxieme partie de

exercise. Second part of the exercise was, can we

l'exercice.La deuxieme partie de l'exercice etait, peut-on

define factorial in terms of product? So let's see how we would do that.

fefinir factorial en termes de product ?Voyons donc comment nous ferions cela.

You have the factorial, which takes an int.

Vous avez la factorielle, qui prend un int.

And what would that be? So it would be, the definition would be,

Et quelle serait-elle ?La definition serait

it's a multiplication of all numbers between one and m.

une multiplication de tous les nombres entre 1 et m.

So it's a product where we pass as the function parameter the identity, and the

Donc c'est un produit ou nous passons comme parametre de la fonction l'identite, et les

balance would be one and N. Again let's test that.

bornes seraient un et N.Encore une fois, nous allons tester que.

Factorial of five, would be 120, which is also correct.

factoial de cinq serait 120, qui est egalement correcte.

The third part of the exercise was, can we find a function that generalizes sum and

La troisieme partie de l'exercice etait: pouvons-nous trouver une fonction qui generalise sum et

product? Using that function we should be able to

product ?En utilisant cette fonction, nous devrions etre en mesure

express both sum and product. What could that be?

d'exprimer la somme et le produit.Qu'est-ce que �a pourrait etre ?

Well that function would then be parametrized in the type of mapping that

Eh bien cette fonction serait alors parametree dans le type de correspondance que

we want to apply, because that was something that was common in some end

nous voulons appliquer, parce que c'etait quelque chose qui etait courant dans sum et

product, plus the two bounds, plus the two things that differ.

product, plus les deux bornes, ainsi que les deux choses differentes.

The two things that differ were, what was the unit value and what was the combining

Les deux choses differentes etaient, quelle etait la valeur unitaire ? et quelle etait la fonction de

function with which we combined individual values of f?

combinaison avec laquelle nous avons combine les valeurs individuelles de f ?

In fact that what, what we are after is a version of map reduce.

En fait ce que nous cherchons est une version de mapReduce

We want to have a function, the function f would map values in the interval to new

Nous voulons avoir une fonction, la fonction f devrait mapper les valeurs de l'intervalle vers de nouvelles

values, and reduce, then would combine them.

valeurs et les reduire, puis les combiner.

So let's call this new function map reduce.

Nous allons donc appeler cette nouvelle fonction mapReduce.

And what should we get as parameters? Well, it needs to get the f parameter and

Et ce que nous devrions obtenir comme parametres ?Eh bien, on a besoin d'obtenir le parametre f et

it needs to get a new parameter called det combine that takes two ints and returns an

un nouveau parametre appele combine qui prend deux ints et retourne un

int. And finally, it needs to have a unit

int.Et enfin, il doit avoir une valeur

value. We'll call it a zero value, which is an

unitaire.Nous allons l'appeler une valeur zero, qui est un

int. So that's the value to return if the

int.C'est la valeur a retourner si la

interval is empty. And after that, we would have the same

intervalle est vide.Et apres cela, nous aurions la meme

thing as before. So we would have the two values of A and

chose qu'avant.Alors nous aurions deux valeurs de A et

B. How would we define it?

B. Comment la definirions-nous ?

Well, let's take the definition of product as a template.

Eh bien, nous allons prendre la definition de product en tant que modele.

So if A is greater than B, then what do we return?

Donc si A est superieur a B, que retournons-nous ?

The zero value. Otherwise, we take F of A, and what we do,

La valeur zero.Dans le cas contraire, nous prenons f(a), et que faisons-nous

we do with F of A, we're neither summing nor multiplying, but we now combine it

avec f(a) ? Nous ne l'aditionons ni ne le multiplions pas mais nous le combinons

with the map reduce value of the same three parameters that we had initially.

avec la valeur mapReduce des trois memes parametres que nous avions au depart.

And a + one and b. And it seems I'm missing, apparently.

Et a + 1 et b.Et il semble que j'oublie une parenthese.

Good. So that was the map reduce example.

C'etait l'exemple de mapReduce.

Let's test it. Well a good way to test it actually would

Nous allons le tester.Un bon moyen de le faire serait en fait

be to say well let's define product in terms of map reduce, because after all, we

de definir product en termes de mapReduce, car apres tout, nous

wanted a function that generalizes both sum and product.

voulions une fonction qui generalise la somme et le produit.

So product then would be map reduce. Off.

product serait alors mapReduce de...

What's the function, the given function? F is the mapping function.

Quelle est la fonction? la fonction donnee F est la fonction de mappage.

The combining function would be a function that takes x and y and returns the product

La fonction de combinaison serait une fonction qui prend x et y et retourne le produit

of x and y. And the zero would be one for a product.

de x et y.Et le zero serait 1 pour un produit.

And we pass the parameters like this. And we delete the previous version of

Et nous passons les parametres comme suit.Et on supprime la version precedente de

I had, had a problem here, where, let's see what it says.

Il y a un probleme ici, voyons ce que c'est.

In fact what happened here, we get two errors, which says we have a forward

En fait ce qui s'est passe ici, nous obtenons deux erreurs, qui dit que nous avons une

reference, that extends over two definitions of values, reds zero and reds

"forward reference", qui s'etend sur deux definitions de valeurs, res$0 et res$1

one. If you remembered off the worksheet so

Si vous vous rappele de la feuille de clacul jusqu'a present,

far, reds zero and reds one, where the values that named these individual

res$0 et res$1 etaient les valeurs qui nomaient ces

parameters. What happens here is that if you define a

parametres.Ce qui se passe ici, c'est que si vous definissez une

function then in fact that function can refer to other functions but only as long

fonction puis en fait cette fonction peut faire reference a d'autres fonctions, mais seulement

as there, that there are no definitions or expressions between two, the two

s'il n'y a aucune definition ou expression entre les deux fonctions.

functions. So what we need to do then is move the map

Donc ce que nous devons estd e deplacer mapReduce

reviews up in front of the product. So that we wouldn't have a forward

avant product afin que nous n'ayons pas de "forward reference"

reference anymore. So now the program compiles.

Alors maintenant, le programme compile.

And we would get the same value of factorial of 520.

Et on obtiendrait la meme valeur de factorielle de 5, 120.

So that means that we have substituted a correct definition, or seemingly correct

Donc cela signifie que nous avons substitue une definition correcte, ou apparemment correct

definition, for product. You've seen currying as a way to define

pour product.Vous avez vu la curryfication comme moyen de definir des

functions piecewise, one parameter section after the other.

fonctions par morceaux, une section de parametre apres l'autre.

In the next session we are going to take what we've learned with high order

Lors de la prochaine session, nous allons utiliser ce que nous avons appris avec les fonctions d'ordre

functions, in another concrete example.

superieur, dans un autre exemple concret.

Similar videos:

Currying
Functional Programming in Haskell
2.6K views 12 likes 1 dislikes 28 Sep 2017100% match

1.1 Programming Paradigms
Functional Programming Principles in Scala
1.7K views 16 likes 0 dislikes 11 Sep 201742% match

1.2 Elements of Programming
Functional Programming Principles in Scala
1.3K views 6 likes 0 dislikes 11 Sep 201742% match

3.2 More Fun With Rationals
Functional Programming Principles in Scala
766 views 3 likes 0 dislikes 29 Sep 201738% match

4.1 Polymorphism
Functional Programming Principles in Scala
1.3K views 7 likes 0 dislikes 11 Sep 201736% match

3.4 Evaluation and Operators
Functional Programming Principles in Scala
788 views 3 likes 0 dislikes 11 Sep 201731% match

3.5 How Classes Are Organized
Functional Programming Principles in Scala
711 views 2 likes 0 dislikes 11 Sep 201731% match

2.1 Tail Recursion
Functional Programming Principles in Scala
2.5K views 19 likes 0 dislikes 11 Sep 201731% match

3.1 Functions and Data
Functional Programming Principles in Scala
1.2K views 2 likes 0 dislikes 29 Sep 201731% match

2.2 Higher Order Functions
Functional Programming Principles in Scala
1.5K views 5 likes 0 dislikes 11 Sep 201730% match

1.5 Example, square roots with Newton's method
Functional Programming Principles in Scala
843 views 2 likes 1 dislikes 11 Sep 201729% match

1.6 Blocks and Lexical Scope
Functional Programming Principles in Scala
819 views 7 likes 0 dislikes 11 Sep 201727% match

1.3 Evaluation Strategies and Termination
Functional Programming Principles in Scala
850 views 6 likes 0 dislikes 11 Sep 201727% match

1.4 Conditionals and Value Definitions
Functional Programming Principles in Scala
775 views 3 likes 0 dislikes 11 Sep 201727% match

2.5 Scala Syntax Summary
Functional Programming Principles in Scala
759 views 2 likes 0 dislikes 11 Sep 201727% match

3.4 Class Hierarchies
Functional Programming Principles in Scala
1.2K views 2 likes 0 dislikes 11 Sep 201726% match

2.4 Example, Finding Fixed Points
Functional Programming Principles in Scala
750 views 1 likes 0 dislikes 11 Sep 201724% match

Settings Privacy About Contact Donate