Aplicare parțială

În matematică și informatică , aplicarea parțială a unei funcții este definită ca aplicarea unei funcții la o parte a argumentelor sale.

Strict vorbind, această operațiune ar trebui „interzisă”, deoarece o funcție trebuie aplicată tuturor argumentelor sale care urmează a fi definite. De fapt, există mai multe limbaje de programare care vă permit să faceți acest lucru prin returnarea unui rezultat utilizabil și chiar și în matematică este posibil să înțelegeți o expresie în care o funcție este aplicată unei părți din argumentele sale.

Abordare intuitivă cu exemple

Chiar înainte de a furniza definiția formală, un exemplu simplu poate arăta că sensul care trebuie dat unei aplicații parțiale este destul de intuitiv, dincolo de complicațiile care apar atunci când se dorește formalizarea unei astfel de intuiții.

Să presupunem că avem o multiplica funcție care multiplică două numere întregi , adică, că fiecare pereche de numere întregi face corespund lor produs:

moltiplica:\mathbb {N} \times \mathbb {N} \to \mathbb {N}

{\ displaystyle se înmulțește: \ mathbb {N} \ times \ mathbb {N} \ la \ mathbb {N}}

înmulțiți: \ N \ ori \ N \ la \ N

moltiplica:(m,n)\mapsto moltiplica(m,n)=m\cdot n

{\ displaystyle multiplies: (m, n) \ mapsto multiplies (m, n) = m \ cdot n}

multiply: (m, n) \ mapsto multiply (m, n) = m \ cdot n

Prin definiție, dacă această funcție este aplicată la două numere, returnează un număr. De exemplu $moltiplica(2,3)=6$ ${\ displaystyle multiply (2,3) = 6}$ ${\ displaystyle multiply (2,3) = 6}$ . Dar să presupunem că aveți o expresie ca aceasta: $moltiplica(2,\cdot )$ ${\ displaystyle multiplies (2, \ cdot)}$ ${\ displaystyle multiplies (2, \ cdot)}$ (unde punctul indică absența unui argument), sau o expresie ca aceasta: $moltiplica(2)$ ${\ displaystyle multiplies (2)}$ ${\ displaystyle multiplies (2)}$ , adică o expresie în care este prezent doar unul dintre cele două argumente. Ce sens ar putea fi dat acestei expresii?

Dacă utilizați o astfel de expresie în anumite limbaje de programare care vă permit să faceți acest lucru, programul returnează o funcție. Se înțelege intuitiv că funcția returnată este o funcție care „așteaptă” al doilea argument, pentru a finaliza operația. Astfel funcția care a fost scrisă ca $moltiplica(2,\cdot )$ ${\ displaystyle multiplies (2, \ cdot)}$ ${\ displaystyle multiplies (2, \ cdot)}$ sau cum $moltiplica(2)$ ${\ displaystyle multiplies (2)}$ ${\ displaystyle multiplies (2)}$ ia un argument și returnează produsul acelui argument cu numărul 2:

moltiplica(2):\mathbb {N} \to \mathbb {N}

{\ displaystyle multiplies (2): \ mathbb {N} \ la \ mathbb {N}}

{\ displaystyle multiplies (2): \ mathbb {N} \ la \ mathbb {N}}

moltiplica(2):n\mapsto moltiplica(2)(n)=2\cdot n

{\ displaystyle multiply (2): n \ mapsto multiply (2) (n) = 2 \ cdot n}

{\ displaystyle multiply (2): n \ mapsto multiply (2) (n) = 2 \ cdot n}

Intuitiv, lucrul este atât de banal încât pare aproape o complicație formală inutilă, în sensul că pare să nu existe necesitatea introducerii unor definiții suplimentare pentru a putea întreba:

moltiplica(m,n)=moltiplica(m)(n)

{\ displaystyle multiply (m, n) = multiply (m) (n)}

{\ displaystyle multiply (m, n) = multiply (m) (n)}

Cu toate acestea, în realitate, există o diferență conceptuală notabilă, deoarece o funcție a două argumente apare pe primul membru al ecuației, adică se înmulțește , aplicată la două argumente, în timp ce o funcție a unui argument apare pe al doilea membru al ecuației, acesta este $moltiplica(m)$ ${\ displaystyle multiplies (m)}$ ${\ displaystyle multiplies (m)}$ , aplicat la un argument. Revenind la exemplul de mai sus, $moltiplica(2)$ ${\ displaystyle multiplies (2)}$ ${\ displaystyle multiplies (2)}$ este o funcție, pe care am putea să o definim ca dublă :

doppio=moltiplica(2)

{\ displaystyle double = multiply (2)}

{\ displaystyle double = multiply (2)}

care ia un număr ca argument și returnează dublul acestui număr.

Mai mult, întrucât pentru m fixat multiplicați ( m ) este o funcție, atunci în al doilea membru al ecuației multiplicarea trebuie considerată o funcție a unui argument, care pentru fiecare număr întreg m returnează o funcție din $\mathbb {N}$ ${\ displaystyle \ mathbb {N}}$ $\ N$ la $\mathbb {N}$ ${\ displaystyle \ mathbb {N}}$ $\ N$ . O astfel de funcție, care ia un „număr” (în sens generic) și returnează o funcție, se numește și funcțională . Prin urmare, atunci când o funcție este aplicată doar unei părți din argumentele sale, această funcție este implicit redefinită ca funcțională "asociată în mod natural" cu funcția în sine. Într-adevăr, mai exact ca una dintre funcționalitățile asociabile, deoarece pentru fiecare alegere de argumente pe care să se aplice parțial funcția există o funcționalitate asociată diferită.

Fără a împovăra notația prin definirea unei funcționale diferite pentru fiecare posibilă combinație parțială de argumente, putem lăsa contextul să o determine, folosind suficientă notație pentru a o clarifica. Deci, dacă scrieți multiplicare (2), este clar din context că utilizați multiplicare ca funcționalitate care asociază o funcție fiecărui număr, atunci multiplicare (2) este în special funcția dublă , în timp ce multiplicări (3) ar fi funcție triplă etc.

După cum s-a menționat mai sus, unele limbaje de programare implementează această „sensibilitate la context”, așa că atunci când o funcție este aplicată doar unei părți din argumentele sale, limbajul tratează funcția ca funcțională și returnează o funcție, care poate fi apoi aplicată celorlalte. argumente, care la rândul lor pot fi luate toate împreună sau parțial. În schimb, alte limbi necesită ca funcția să fie transformată mai întâi într-o funcțională, iar apoi această funcționalitate să fie aplicată unei părți a argumentelor. Și întrucât, în principiu, există atât de multe funcționale, câte combinații posibile de argumente, pentru a nu încărca notația, se face de obicei o alegere „radicală”, prin definirea unui operator care transformă o funcție într-o funcționalitate care ia argumentele „ pe rând. timp "începând cu primul.

Acest operator se numește curry , iar operațiunea corespunzătoare se numește currying , în onoarea lui Haskell Curry , care a studiat implementarea acestuia pentru o lungă perioadă de timp. În aceste limbaje de programare, aplicarea parțială a unei funcții la argumentele sale devine din nou „interzisă”; de exemplu, dacă aveți o funcție f cu trei argumente, atunci când nu doriți să o aplicați imediat tuturor celor trei argumente, scriind f ( x , y , z ), trebuie mai întâi să reduceți funcția f la curry funcțional ( f ), apoi aplicați această funcționalitate primului argument, obținând curry funcțional ( f ) ( x ), care aplicat celui de-al doilea argument dă funcția curry ( f ) ( x ) ( y ), care se aplică celui de-al treilea argument returnează numărul curry ( f ) ( x ) ( y ) ( z ). Acest operator este întotdeauna implicit în calculul lambda , unde fiecare funcție a mai multor argumente este considerată funcțională și argumentele sunt luate „unul câte unul”, începând de la primul, dând ca rezultat alte funcționale sau (ajuns la penultimul argument) o funcție .

Definiție formală

Date trei seturi A , B și C (posibil coincidente) și o funcție

f:A\times B\to C

{\ displaystyle f: A \ times B \ to C}

f: A \ ori B \ to C

f:(a,b)\mapsto c=f(a,b)

{\ displaystyle f: (a, b) \ mapsto c = f (a, b)}

f: (a, b) \ mapsto c = f (a, b)

două funcționale pot fi asociate cu acesta într-un mod „natural” $F_{1}$ ${\ displaystyle F_ {1}}$ $F_ {1}$ Și $F_{2}$ ${\ displaystyle F_ {2}}$ $F_ {2}$ definit astfel:

$F_{1}$ ${\ displaystyle F_ {1}}$ $F_ {1}$: $F_{1}:A\to \{\phi |\phi :B\to C\}$ ${\ displaystyle F_ {1}: A \ to \ {\ phi | \ phi: B \ to C \}}$ $F_1: A \ to \ {\ phi | \ phi: B \ to C \}$; $F_{1}:a\mapsto F_{1}(a):=f(a,\cdot )$ ${\ displaystyle F_ {1}: a \ mapsto F_ {1} (a): = f (a, \ cdot)}$ $F_1: a \ mapsto F_1 (a): = f (a, \ cdot)$; $F_{1}(a):b\mapsto (F_{1}(a))(b)=f(a,b)$ ${\ displaystyle F_ {1} (a): b \ mapsto (F_ {1} (a)) (b) = f (a, b)}$ $F_1 (a): b \ mapsto (F_1 (a)) (b) = f (a, b)$
$F_{2}$ ${\ displaystyle F_ {2}}$ $F_ {2}$: $F_{2}:B\to \{\phi |\phi :A\to C\}$ ${\ displaystyle F_ {2}: B \ to \ {\ phi | \ phi: A \ to C \}}$ $F_2: B \ to \ {\ phi | \ phi: A \ to C \}$; $F_{2}:b\mapsto F_{2}(b):=f(\cdot ,b)$ ${\ displaystyle F_ {2}: b \ mapsto F_ {2} (b): = f (\ cdot, b)}$ $F_2: b \ mapsto F_2 (b): = f (\ cdot, b)$; $F_{2}(b):a\mapsto (F_{2}(b))(a)=f(a,b)$ ${\ displaystyle F_ {2} (b): a \ mapsto (F_ {2} (b)) (a) = f (a, b)}$ $F_2 (b): a \ mapsto (F_2 (b)) (a) = f (a, b)$

Dacă numărul variabilelor crește, notația devine și mai grea și este necesar să se ia în considerare „funcționale cu valori funcționale”, adică funcționale care, atunci când sunt aplicate argumentului lor, la rândul lor returnează o funcționalitate.

Elemente conexe

Calcul Lambda

Implementări specifice pentru fiecare limbă

ALGOL 68G
Currying in C ( PDF ), pe asg.unige.ch . Adus la 7 decembrie 2010 (arhivat din original la 25 decembrie 2010) .
Currying în CSharp , metodă alternativă (mai rapidă)
Currying in Delphi 2009 , la blogs.teamb.com . Adus la 7 decembrie 2010 (arhivat din original la 27 noiembrie 2010) .
Currying în Java ^{[ link rupt ]} , pe dis.4chan.org .
Currying în JavaScript , la flesler.blogspot.com .
Currying în Lua , la tinylittlelife.org . Adus la 7 decembrie 2010 (arhivat din original la 5 noiembrie 2010) .
Currying în Perl , la perldesignpatterns.com . Adus la 7 decembrie 2010 (arhivat din original la 28 februarie 2011) .
Currying în PHP , la zaemis.blogspot.com .
Aplicație parțială în PowerShell , pe nivot.org . Adus la 7 decembrie 2010 (arhivat din original la 14 ianuarie 2011) .
Currying în Ruby , la moonbase.rydia.net . Adus la 7 decembrie 2010 (arhivat din original la 12 iulie 2010) .
Currying în Scala , pe scala-lang.org .
Curry implicit în Scheme , pe engr.uconn.edu . Adus la 19 iulie 2008 (arhivat din original la 19 iulie 2008) .
Currying în Smalltalk , la blog.3plus4.org .

Portalul de matematică : accesați intrările Wikipedia care se ocupă de matematică