Quelle est la différence entre le nourrissage et l'application partielle?

Nourrissage est la conversion d'une seule fonction de n arguments en n fonctions à un seul argument de chacun. Compte tenu de la fonction suivante:

function f(x,y,z) { z(x(y));}

Quand au curry, devient:

function f(x) { lambda(y) { lambda(z) { z(x(y)); } } }

Afin d'obtenir l'application intégrale de f(x,y,z), vous devez faire ceci:

f(x)(y)(z);

De nombreux langages fonctionnels vous permettent d'écrire des f x y z. Si vous n'appelez f x y ou f(x)(y) ensuite, vous obtenez un partiellement appliqué en fonction de la valeur de retour est une fermeture de lambda(z){z(x(y))} avec le passé-dans les valeurs de x et de y pour f(x,y).

Un moyen d'utiliser l'application partielle est de définir des fonctions que les applications partielles de des fonctions généralisées, comme fois:

function fold(combineFunction, accumulator, list) {/* ... */}
function sum     = curry(fold)(lambda(accum,e){e+accum}))(0);
function length  = curry(fold)(lambda(accum,_){1+accum})(empty-list);
function reverse = curry(fold)(lambda(accum,e){concat(e,accum)})(empty-list);

/* ... */
@list = [1, 2, 3, 4]
sum(list) //returns 10
@f = fold(lambda(accum,e){e+accum}) //f = lambda(accumulator,list) {/*...*/}
f(0,list) //returns 10
@g = f(0) //same as sum
g(list)  //returns 10

OriginalL'auteur Mark Cidade

Note: ceci a été pris de F# Bases un excellent article d'introduction .NET développeurs d'entrer dans la programmation fonctionnelle.

Nourrissage moyens de briser une fonction avec beaucoup d'arguments dans une série
des fonctions qui prennent chacun un argument et en fin de compte produire de l'
même résultat que la fonction originale. Nourrissage est probablement le plus
difficile sujet pour les développeurs de nouvelles à la programmation fonctionnelle, en particulier parce qu'il
elle est souvent confondue avec l'application partielle. Vous pouvez voir à la fois au travail
dans cet exemple:

let multiply x y = x * y    
let double = multiply 2
let ten = double 5

Vous devriez voir le comportement qui est différent de la plupart des
des langages impératifs. La deuxième instruction crée une nouvelle fonction
appelé double par le passage d'un argument à une fonction qui prend deux.
Le résultat est une fonction qui accepte un argument de type int et les rendements de la
même résultat que si vous aviez fait appel à multiplier avec x égal à 2 et y
égale à celle de l'argument. En termes de comportement, c'est la même chose que ce
code:

let double2 z = multiply 2 z

Souvent, les gens à tort de dire que multiplier est le curry de forme double.
Mais ce n'est qu'un peu vrai. La fonction multiply est préparé, mais
ce qui se passe quand elle est définie, car les fonctions de F# sont au curry par
par défaut. Lorsque la double fonction est créée, il est plus juste de
dire que la fonction multiply est partiellement appliquée.

De la fonction multiply est vraiment une série de deux fonctions. La première
la fonction prend un int en argument et renvoie une autre fonction,
effectivement la liaison de x à une valeur spécifique. Cette fonction accepte aussi
un argument int ce que vous pouvez penser que la valeur de lier à y. Après
l'appel de cette deuxième fonction, x et y sont liés, de sorte que le résultat est
le produit de x et y définies dans le corps de double.

Pour créer le double, la première fonction dans la chaîne de multiplier
fonctions est évalué à appliquer partiellement multiplier. Le résultant
la fonction est donnée le nom de double. Lors d'un double est évalué, il utilise
son argument avec l'application partielle de la valeur afin de créer le
résultat.

OriginalL'auteur dodgy_coder

J'ai répondu à cette question dans un autre thread https://stackoverflow.com/a/12846865/1685865 . En bref, partielles de la fonction de demande est à propos de la fixation des arguments d'une fonction multivariable à céder d'une autre fonction avec moins d'arguments, tandis que le Nourrissage est sur la façon de transformer une fonction de N arguments dans une fonction unaire qui retourne une fonction unaire...[Un exemple de Nourrissage est indiqué à la fin de ce post.]

Nourrissage est surtout un intérêt théorique: on peut exprimer les calculs en utilisant uniquement des fonctions unaires (c'est à dire chaque fonction unaire). Dans la pratique, et comme sous-produit, c'est une technique qui peut faire beaucoup de pratique (mais pas tous) les applications fonctionnelles trivial, si la langue a des fonctions curryfiées. Encore une fois, il n'est pas le seul moyen de mettre en œuvre les applications partielles. Donc, vous pourriez rencontrer des scénarios où l'application partielle est fait d'une autre manière, mais les gens sont croyant que c'est comme Lancer.

(Exemple de Nourrissage)

Dans la pratique, on ne serait pas juste écrire

lambda x: lambda y: lambda z: x + y + z

ou l'équivalent javascript

function (x) { return function (y){ return function (z){ return x + y + z }}}

au lieu de

lambda x, y, z: x + y + z

pour l'amour de Nourrissage.

OriginalL'auteur Ji Han

La différence entre le curry et l'application partielle peut être mieux illustré par le biais de ce code JavaScript suivant exemple:

function f(x, y, z) {
    return x + y + z;
}

var partial = f.bind(null, 1);

6 === partial(2, 3);

Application partielle des résultats en fonction de la plus petite arité; dans l'exemple ci-dessus, f a une arité de 3 alors que partial seulement a une arité de 2. Plus important encore, une application partielle de la fonction retourner le résultat tout de suite après invoquer, pas une autre fonction en bas de la nourrissage de la chaîne. Donc, si vous voyez quelque chose comme partial(2)(3), ce n'est pas une application partielle dans la réalité.

Pour en savoir plus:

• Programmation fonctionnelle en 5 minutes
• Nourrissage: le Contraste avec Fonction Partielle de l'Application

OriginalL'auteur gsklee

Je pourrais être très mal ici, car je n'ai pas une formation solide en mathématiques théoriques ou de la programmation fonctionnelle, mais à partir de ma brève incursion dans la FP, il semble que nourrissage tend à son tour une fonction à N arguments en N de fonctions à un argument, alors que l'application partielle [en pratique] fonctionne mieux avec les variadic fonctions avec un nombre indéterminé d'arguments. Je sais que certains des exemples donnés dans les réponses précédentes défier cette explication, mais il m'a aidé le plus à séparer les concepts. Considérons l'exemple suivant (écrit en CoffeeScript pour la concision, toutes mes excuses si il confond de plus, mais s'il vous plaît demander pour plus de précisions, si nécessaire):

# partial application
partial_apply = (func) ->
  args = [].slice.call arguments, 1
  -> func.apply null, args.concat [].slice.call arguments

sum_variadic = -> [].reduce.call arguments, (acc, num) -> acc + num

add_to_7_and_5 = partial_apply sum_variadic, 7, 5

add_to_7_and_5 10 # returns 22
add_to_7_and_5 10, 11, 12 # returns 45

# currying
curry = (func) ->
  num_args = func.length
  helper = (prev) ->
    ->
      args = prev.concat [].slice.call arguments
      return if args.length < num_args then helper args else func.apply null, args
  helper []

sum_of_three = (x, y, z) -> x + y + z
curried_sum_of_three = curry sum_of_three
curried_sum_of_three 4 # returns a function expecting more arguments
curried_sum_of_three(4)(5) # still returns a function expecting more arguments
curried_sum_of_three(4)(5)(6) # returns 15
curried_sum_of_three 4, 5, 6 # returns 15

C'est évidemment un exemple artificiel, mais remarquez que partiellement l'application d'une fonction qui accepte un nombre quelconque d'arguments nous permet d'exécuter une fonction, mais avec certaines données préliminaires. Lancer une fonction est similaire, mais nous permet d'exécuter un N-paramètre de la fonction en morceaux jusqu'à ce que, mais seulement jusqu'à ce que, tous les N paramètres sont pris en compte.

Encore une fois, c'est ma façon de voir les choses que j'ai lu. Si quelqu'un n'est pas d'accord, j'apprécierais un commentaire pour expliquer pourquoi, plutôt que d'un immédiat downvote. Aussi, si la CoffeeScript est difficile à lire, veuillez visiter coffeescript.org, cliquez sur "essayez coffeescript" coller " dans mon code pour voir la version compilée, qui peut (heureusement) faire plus de sens. Merci!

OriginalL'auteur sunny-mittal

Réponse Simple

Curry: vous permet d'appeler une fonction, de le fractionner en de multiples appels, fournir un argument par appel.

Partielle: vous permet d'appeler une fonction, de le fractionner en de multiples appels, offrant de multiples arguments par appel.

---

Conseils tout simples

Les deux vous permettent d'appeler une fonction en fournissant moins d'arguments (ou, mieux, de leur fournir de façon cumulative). En fait, les deux d'entre eux se lier à chaque appel) une valeur spécifique à certains arguments de la fonction.

La vraie différence peut être vu lorsque la fonction dispose de plus de 2 arguments.

---

Simple e(c)(échantillon)

(en Javascript)

function process(context, success_callback, error_callback, subject) {...}

pourquoi toujours passer les arguments, comme le contexte et les rappels, si ils seront toujours la même? Juste lier certaines valeurs pour la fonction

processSubject = _.partial(process, my_context, my_success, my_error)

et de l'appeler sur sujet1 et foobar avec

processSubject('subject1');
processSubject('foobar');

Confortable, n'est-ce pas?

Avec nourrissage vous auriez besoin pour passer un argument à la fois

curriedProcess = _.curry(process);
processWithBoundedContext = curriedProcess(my_context);
processWithCallbacks = processWithBoundedContext(my_success)(my_error); //note: these are two sequential calls

result1 = processWithCallbacks('subject1');
//same as: process(my_context, my_success, my_error, 'subject1');
result2 = processWithCallbacks('foobar'); 
//same as: process(my_context, my_success, my_error, 'foobar');

Avertissement

J'ai sauté tous les universitaires/explication mathématique. Car je ne sais pas. Peut-être qu'il a aidé à

OriginalL'auteur Kamafeather

En écrivant cela, j'ai confondu nourrissage et uncurrying. Ils sont les transformations inverses sur les fonctions. Il n'a vraiment pas d'importance ce que vous appelez qui, aussi longtemps que vous obtenez ce que la transformation et de son inverse représentent.

Uncurrying n'est pas défini très clairement (ou plutôt, il y a "conflit" les définitions de tous les capturer l'esprit de l'idée). En gros, cela signifie transformer une fonction qui prend plusieurs arguments dans une fonction qui prend un seul argument. Par exemple,

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

Maintenant, comment voulez vous transformer en une fonction qui prend un seul argument? Vous tentez de tricher, bien sûr!

plus :: (Int, Int) -> Int

Avis que plus maintenant prend un seul argument (qui est composé de deux choses). Super!

Quel est le point de tout cela? Eh bien, si vous avez une fonction qui prend deux arguments, et vous avez une paire d'arguments, il est bon de savoir que vous pouvez appliquer la fonction aux arguments, et toujours obtenir ce que vous attendez. Et, en fait, de la plomberie pour faire ce qu'il existe déjà, de sorte que vous n'avez pas à faire des choses comme l'explicite le pattern matching. Tout ce que vous avez à faire est de:

(uncurry (+)) (1,2)

Donc, qu'est-ce que partielle de la fonction de demande? C'est une façon différente à son tour une fonction à deux arguments dans une fonction avec un argument. Il fonctionne différemment. Encore une fois, prenons (+) comme un exemple. Comment pourrions-nous nous transformer en une fonction qui prend un Int en argument? On triche!

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

C'est la fonction qui ajoute un zéro à n'importe quel Int.

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

ajoute 1 à un Int. Etc. Dans chacun de ces cas, (+) est "partiellement".

OriginalL'auteur nomen