Curryfication

En Haskell, voici une fonction non-curryfiée :

uncurried_add (x, y) = x + y

et la même après curryfication :

curried_add x y = x + y

ou bien :

curried_add x = \y -> x + y

où la barre oblique \ introduit une λ-expression (lambda-expression) et sert à définir des fonctions anonymes. Et voici une application partielle :

main = do
    print (uncurried_add (3, 5)) -- 8
    print ((curried_add 3) 5) -- 8
    print (curried_add 3 5) -- 8
    let add_three = curried_add 3
    print (add_three 5) -- 8
    print (add_three 12) -- 15

Remarques

La curryfication peut se faire à la main ou bien par un programme. Pour les fonctions à deux arguments, voici ces programmes en Haskell :

main = do
    let uncurried = uncurry curried_add
    print (uncurried (3, 5)) -- 8
    
    let curried = curry uncurried_add
    print ((curried 3) 5) -- 8
    print (curried 3 5) -- 8
    let add_three = curried 3
    print (add_three 5) -- 8
    print (add_three 12) -- 15

Même fonction en Python :

def uncurried_add(x, y):
    return x + y
def curried_add(x):
    return lambda y: x + y
print(uncurried_add(3, 5)) # 8
print(curried_add(3)(5)) # 8
add_three = curried_add(3)
print(add_three(5)) # 8
print(add_three(12)) # 15

Même fonction en Caml :

let uncurried_add(x, y) = x + y;; (* Type de la fonction : (entier * entier) -> entier *)
let curried_add x y = x + y;; (* Type de la fonction : entier -> entier -> entier *)
uncurried_add(3,4);; (* Retourne 7. Type de la valeur retournée : entier. *)
curried_add 3;; (* Retourne la fonction qui ajoute 3. Type de la valeur retournée : entier -> entier. *)
(curried_add 3) 4;; (* Crée la fonction qui ajoute 3 et l'applique à l'entier 4. Retourne 7. Type de la valeur retournée : entier. *)
let add_three = curried_add 3;; (* Définit la fonction add_three comme la fonction qui ajoute 3 à son argument. *)
add_three 5;; (* Applique add_three à 5. Retourne 8. *)
add_three 12;; (* Applique add_three à 12. Retourne 15. *)

def uncurried_add(x, y)
    return x + y
end
def curried_add(x)
    return lambda { |y| x + y }
end
puts uncurried_add(3, 5) # 8
puts curried_add(3).call(5) # 8
add_three = curried_add(3)
puts add_three.call(5) # 8
puts add_three.call(12) # 15

Ruby fournit l'expression lambda avec la méthode curry. La méthode prend en argument un argument optionnel : l'arity, qui permet des processus plus fins, qui ne seront pas discutés ici.

uncurried_add = lambda { |x, y| x + y }
puts uncurried_add.call(3, 5) # 8
puts uncurried_add.curry[3][5] # 8
add_three = uncurried_add.curry[3]
puts add_three.call(5) # 8
puts add_three.call(12) # 15

Un JAPH qui est un exemple de curryfication en Perl 6 :

sub japh (Str $lang) { say "just another $lang hacker"; }
my &perl6Japh := &japh.assuming("Perl6");
perl6Japh();

Le C++11 a introduit les lambdas dans le langage, puis le C++14 a introduit la possibilité de définir un type de retour auto pour faciliter l'écriture de certaines fonctions.

Ces deux améliorations permettent d'implémenter la curryfication :

#include <iostream>
int uncurried_add(int x, int y) {
    return x + y;
}
auto curried_add(int x) {
    return [x](int y) {
        return x + y;
    };
}
int main() {
    std::cout << uncurried_add(3, 5) << std::endl; // 8
    std::cout << curried_add(3)(5) << std::endl; // 8
    auto add_three = curried_add(3);
    std::cout << add_three(5) << std::endl; // 8
    std::cout << add_three(12) << std::endl; // 15
}

À noter que depuis le C++17, la mention du type int en argument de l'expression lambda peut également être remplacée par auto, généralisant l'implémentation (au prix de faire de la méthode curried_add un template implicite).

• Haskell Curry
• Moses Schönfinkel