Discussion :

[Overcrash]

Bonsoir,

Je sais pas si je suis dans la bonne section j'ai hésité a poster

Je suis tombé sur une méthode de programmation donc cela ne concerne pas vraiment de langage en particulier, et c'est uniquement pour moi, pour ma culture.

Donc en clair qu'est ce que la Curryfication ?

J'ai bien sur cherché sur google je suis tombé notamment la dessus :
http://fr.wikipedia.org/wiki/Curryfication

J'ai pas très bien compris la définition mais encore moins quand/pourquoi l'utiliser

Si un d'entre pourrait reformuler/expliquer avec un exemple je lui en serais reconnaissant. Par exemple je sous entends un exemple d'utilisation pas de code

Merci.

[Médinoc]

Déjà, c'est de la programmation fonctionnelle, donc impossible à faire directement dans des langages comme C ou C++: il est question de générer des fonctions en run-time.

Si j'ai bien compris, la currification, c'est remplacer une fonction genre ajouter(x, y) par un truc du genre creer_fonction_ajouter_x(x) qui retourne une fonction.

Ainsi, imaginons que je veuille ajouter 3 + 5, au lieu de faire ceci:

Code non-currifié :

Sélectionner tout - Visualiser dans une fenêtre à part

int resultat = ajouter(3, 5)

j'appellerais une telle fonction ainsi:

Code curryfié :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Fonction f = creer_fonction_ajouter_x(3)
int resultat = f(5)

[Overcrash]

plop,

Ha ok je comprend mieux mais alors ca sert a quoi ? Concrètement ?

[Médinoc]

Il me semble qu'en programmation fonctionnelle, pratiquement tout est basé sur ce genre de truc. Je ne peux pas t'en dire plus, là: C'est aussi alien pour moi que pour quiconque a grandi avec la programmation impérative.

[Twinside]

C'est principalement utilisé pour les fonctions d'ordre supérieur, tel que map, filter ou les fold_left/fold_right.

par exemple pour ajouter 5 à tous les nombres d'une liste de nombre, on va utiliser l'opérateur (+) qui est une fonction qui prend 2 entiers et en renvoit 1, et qui a pour type sous sa forme curryfié :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(+) :: Int -> Int -> Int

où la flèche représente l'application d'une fonction. L'opération d'ordre supérieure pour transformer les éléments d'une liste s'appelle map, ici décrit pour les listes d'entier uniquement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

map :: (Int -> Int) -> [Int] -> [Int]

Elle prend en premier paramètre une fonction qui pour entier donné retourne un autre entier, et une liste. Map retourne une liste d'entier. Au final nous obtenons :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
map ((+) 5) [1, 2, 3, 4]
=> [6, 7, 8, 9]

Ici on utilise la curryfication pour grandement simplifier l'écriture. Dans la pratique, on appelle souvent des fonctions plus complexes, conçue pour tirer partie de la curryfication, typiquement placer les arguments de paramétrage au début des paramètres et l'argument "manipulé" à la fin.

En respectant cette forme d'écriture, on peut même arriver à créer des "pipeline" de fonction (un peu comme en shell), où l'on combine des fonctions curryfiée, en laissant juste le dernier argument manquant.

Par exemple en Haskell, on peut écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
normalizeList = map (/ 10) . filter (< 0) . filter (> 10)

normalizeList [0, -10, 15, 5, 2]
=> [0, 0.5, 0.20]

Qui est une fonction créé en combinant 3 fonctions currifyé, chaque fonction a besoin d'une liste en dernier paramètre et retourne un fonction, et le . sert à combiner les fonctions, créant ainsi un pipeline.

C'est très puissant et pratique d'utilisation, mais il faut juste s'habituer un peu au mécanisme, un peut "alien" au début, indispensable par la suite.

Déjà, c'est de la programmation fonctionnelle, donc impossible à faire directement dans des langages comme C ou C++: il est question de générer des fonctions en run-time.

Il n'y a pas de création de fonction au runtime, mais il y a allocation de donnée, pour reprendre l'éxemple de l'opérateur d'addition, voici comment on pourrait écrire l'équivalent en C++ :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
struct Add
{
    int  n1;
    Add( int nn1 ) : n1( nn1 ) {}
    int   operator() ( n2 ) { return n1 + n2; }
};

struct Add3
{
    int  n1;
    Add3( int nn1 ) : n1( nn1 ) {}
    Add   operator() ( int n2 ) { return Add( n1 + n2 ); }
};

...
Add3( 4 )( 9 )( 2 )
...

Add représente vraiment l'opérateur +, l'appel au constructeur représente le premier argument, le deuxième est donné lors de l'appel de l'opérateur surchargé. On peut imaginer le cas où on veut additionner 3 chiffres, comme pour Add3. Dans la réalité, lorsqu'on appelle une fonction curryfiée, ça donne lieu à une fermeture, on alloue de l'espace pour garder traces des arguments successifs (du moins dans l'idée, dans la pratique cela peut être optimisé).

[Médinoc]

^C'est ce que je voulais dire par "pas directement": Pour faire ça en C++, tu dois reproduire toutes les fonctions et le moteur pour les évaluer.