En informatique, plus précisément en programmation fonctionnelle, la curryfication est la transformation d'une fonction à plusieurs arguments en une fonction à un argument qui retourne une fonction sur le reste des arguments. L'opération inverse est possible et s'appelle la décurryfication.
Le terme vient du nom du mathématicien américain Haskell Curry, bien que cette opération ait été introduite pour la première fois par Moses Schönfinkel.
Considérons une fonction add qui prend deux arguments (x et y) et en renvoie la somme. En la curryfiant, on obtient une fonction addcur qui prend un argument et renvoie une fonction qui prend le deuxième argument. En pseudo-langage :
curry (add (x,y)) → addcur x → lambda (y → x + y)
La curryfication permet l'application partielle : si on appelle la fonction curryfiée avec l'argument 3, on récupère une fonction qui ajoute 3 à son argument.
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.
Cette page est générée automatiquement et peut contenir des informations qui ne sont pas correctes, complètes, à jour ou pertinentes par rapport à votre recherche. Il en va de même pour toutes les autres pages de ce site. Veillez à vérifier les informations auprès des sources officielles de l'EPFL.
La programmation fonctionnelle est un paradigme de programmation de type déclaratif qui considère le calcul en tant qu'évaluation de fonctions mathématiques. Comme le changement d'état et la mutation des données ne peuvent pas être représentés par des évaluations de fonctions la programmation fonctionnelle ne les admet pas, au contraire elle met en avant l'application des fonctions, contrairement au modèle de programmation impérative qui met en avant les changements d'état.
En informatique, plus précisément en programmation fonctionnelle, la curryfication est la transformation d'une fonction à plusieurs arguments en une fonction à un argument qui retourne une fonction sur le reste des arguments. L'opération inverse est possible et s'appelle la décurryfication. Le terme vient du nom du mathématicien américain Haskell Curry, bien que cette opération ait été introduite pour la première fois par Moses Schönfinkel. Considérons une fonction add qui prend deux arguments (x et y) et en renvoie la somme.
Le lambda-calcul (ou λ-calcul) est un système formel inventé par Alonzo Church dans les années 1930, qui fonde les concepts de fonction et d'application. On y manipule des expressions appelées λ-expressions, où la lettre grecque λ est utilisée pour lier une variable. Par exemple, si M est une λ-expression, λx.M est aussi une λ-expression et représente la fonction qui à x associe M. Le λ-calcul a été le premier formalisme pour définir et caractériser les fonctions récursives : il a donc une grande importance dans la théorie de la calculabilité, à l'égal des machines de Turing et du modèle de Herbrand-Gödel.
Couvre les concepts et la mise en œuvre de la programmation fonctionnelle dans Scala, mettant l'accent sur les fonctions, les données immuables et l'abstraction des données.