कार्यात्मक प्रोग्रामिंग में "आंशिक कार्य" से वास्तव में क्या अभिप्राय है?

Question

मेरी समझ के अनुसार, आंशिक कार्य ऐसे कार्य हैं जो हमें अपेक्षा से कम फ़ंक्शन से गुजरते हैं। उदाहरण के लिए, यदि यह सीधे पायथन में मान्य थे:

>>> def add(x,y):
...    return x+y
... 
>>> new_function = add(1)
>>> new_function(2)
3

ऊपर स्निपेट में, new_functionएक आंशिक कार्य है। हालांकि, हास्केल विकी के अनुसार, आंशिक कार्य की परिभाषा है

आंशिक फ़ंक्शन एक फ़ंक्शन है जो निर्दिष्ट प्रकार के सभी संभावित तर्कों के लिए परिभाषित नहीं है।

इसलिए, मेरा सवाल यह है: "आंशिक कार्य" से वास्तव में क्या अभिप्राय है?

Comments

आप एक भ्रमित कर रहे हैं आंशिक रूप से लागू किया एक साथ समारोह आंशिक कार्य करते हैं।

— विलेम वैन ओन्सेम

पायथन आंशिक अनुप्रयोगpartial करता है , जबकि हास्केल स्वचालित रूप से ऐसा करता है। विकी प्रविष्टि आंशिक कार्यों को संदर्भित करती है , जो गणित से एक शब्द है।

— L3viathan

कड़ाई से बोलते हुए, हास्केल आंशिक कार्य अनुप्रयोग नहीं करता है। प्रत्येक फ़ंक्शन एक तर्क लेता है, और फ़ंक्शन एप्लिकेशन किसी एकल तर्क पर फ़ंक्शन लागू करता है। Currying simulates क्या आप पहली जगह में कई तर्क कार्यों का अनुकरण करके किसी अन्य भाषा में आंशिक आवेदन के रूप में के बारे में सोच होगा। ऐसा कुछ add 3 5नहीं है जो एकल फ़ंक्शन अनुप्रयोग है। यह पहली बार addएक नया फंक्शन पाने के लिए 3 पर लागू होता है, जो बाद में 5.

— चेपर

और C # में, एक partialविधि प्रोजेक्ट कोडबेस में कहीं और वैकल्पिक रूप से लागू निजी विधि की एक आगे की घोषणा है ।

— दाई

आपके उदाहरण को वैध बनाया जा सकता है:new_function = functools.partial(add, 1)

— wjandrea

Answer 1

आप यहाँ दो अवधारणाओं को भ्रमित कर रहे हैं। एक आंशिक रूप से लागू फ़ंक्शन [हैस्केल-विकी] एक आंशिक फ़ंक्शन [हैस्केल-विकी] के साथ ।

आंशिक रूप से लागू फ़ंक्शन है:

हास्केल में आंशिक आवेदन में कई तर्कों को लेने वाले फ़ंक्शन के लिए तर्कों की पूरी संख्या से कम पास करना शामिल है।

जबकि एक आंशिक समारोह वास्तव में एक गैर कुल समारोह है:

आंशिक फ़ंक्शन एक फ़ंक्शन है जो निर्दिष्ट प्रकार के सभी संभावित तर्कों के लिए परिभाषित नहीं है।

Comments

यह एक अच्छा उत्तर है, लेकिन उत्तर में आंशिक फ़ंक्शन के उदाहरण को जोड़कर इसे बेहतर बनाया जा सकता है।

— ApproachingDarknessFish

मुझे यकीन नहीं है कि मैं आंशिक रूप से लागू फ़ंक्शन की उस सटीक परिभाषा से सहमत हूं। हास्केल में फ़ंक्शंस हमेशा केवल एक तर्क लेते हैं, "कई तर्क" कभी नहीं। मैं परिभाषा का उपयोग करता हूं "हास्केल में आंशिक आवेदन (आंशिक रूप से आवेदन करने वाले कार्य) में एक मान प्राप्त करने के लिए आवश्यक तर्कों की पूरी संख्या से कम की आपूर्ति शामिल होती है जिसे आगे किसी अन्य तर्क पर लागू नहीं किया जा सकता है।" ( यहां से अनुकूलित किया गया )

— टेरीआक्ट

Answer 2

एक आंशिक फ़ंक्शन (कार्यात्मक प्रोग्रामिंग और गणित दोनों के संदर्भ में) ठीक वैसा ही है जैसा कि विकी कहता है: एक ऐसा फ़ंक्शन जो इसके सभी तर्कों के लिए परिभाषित नहीं है। प्रोग्रामिंग के संदर्भ में, हम आमतौर पर "परिभाषित नहीं" को कई चीजों में से एक के रूप में व्याख्या करते हैं, जिसमें अपरिभाषित व्यवहार, अपवाद या गैर-समाप्ति शामिल है।

आंशिक फ़ंक्शन का एक उदाहरण पूर्णांक विभाजन होगा, जिसे परिभाषित नहीं किया गया है यदि भाजक 0 है (हास्केल में यह एक त्रुटि फेंक देगा)।

ऊपर स्निपेट में new_function आंशिक फ़ंक्शन है।

यह कोड केवल पाइथन में एक त्रुटि का कारण होगा, लेकिन यदि यह आपके इच्छानुसार काम करता है, तो यह एक कुल (जिसका अर्थ आंशिक नहीं) फ़ंक्शन होगा।

जैसा कि टिप्पणीकारों ने पहले ही बताया है, आप इस तथ्य के बारे में सबसे अधिक संभावना सोच रहे हैं कि यह आंशिक रूप से लागू फ़ंक्शन होगा।

Answer 3

जवाब सभी को समझाते हैं, मैं सिर्फ प्रत्येक भाषा में एक उदाहरण जोड़ूंगा:

def add(x,y):
    return x+y

f = add(1)
print(f(3))

    f = add(1)
TypeError: add() missing 1 required positional argument: 'y'

यह न तो कोई आंशिक कार्य है और न ही कोई फ़ंक्शन है , यह केवल एक फ़ंक्शन है जिसे आपने इसके सभी तर्क नहीं दिए हैं ।

अजगर में एक करी समारोह इस तरह होना चाहिए:

partialAdd= lambda x: lambda y: x + y

plusOne = partialAdd(1)
print(plusOne(3))

4

और हैस्केल में:

plus :: Int -> Int -> Int
plus x y = x + y

plusOne = plus 1

plusOne 4

5

अजगर में एक आंशिक कार्य:

def first(ls):
    return ls[0]

print(first([2,4,5]))
print(first([]))

उत्पादन

2

print(first([]))
  File "main.py", line 2, in first
    return ls[0]
IndexError: list index out of range

और हास्केल में, जैसा कि आपके लिंक ने दिखाया:

head [1,2,3]
3

head []
*** Exception: Prelude.head: empty list

तो कुल कार्य क्या है?

खैर, मूल रूप से विपरीत: यह एक फ़ंक्शन है जो उस प्रकार के किसी भी इनपुट के लिए काम करेगा। यहाँ अजगर में एक उदाहरण है:

def addElem(xs, x):
  xs.append(x)
  return xs

और यह अनंत सूचियों के लिए भी काम करता है, यदि आप थोड़ी सी चाल का उपयोग करते हैं:

def infiniList():
    count = 0
    ls = []
    while True:
        yield ls
        count += 1
        ls.append(count)

ls = infiniList()
for i in range(5):
  rs = next(ls)

print(rs, addElem(rs,6))

[1, 2, 3, 4]
[1, 2, 3, 4, 5] [1, 2, 3, 4, 5]

और हास्केल में बराबर:

addElem :: a -> [a] -> [a]
addElem x xs = x : xs

addElem 3 (take 10 [1..])
=> [3,1,2,3,4,5,6,7,8,9,10]

यहां फ़ंक्शंस हमेशा के लिए हैंग नहीं होते हैं। अवधारणा समान है: प्रत्येक सूची के लिए फ़ंक्शन काम करेगा।

Comments

यह ध्यान देने योग्य है कि पायथन को मानक पुस्तकालय में आंशिक कार्यों के लिए समर्थन है ।

— मोनिका