इस प्रकार का आपसी "रिकर्सन" कहलाता है?

Question

मेरा मुद्दा कोड की एक निश्चित शैली के साथ है जो बहुत अधिक रिकर्सन जैसा दिखता है, लेकिन काफी नहीं है। रिकर्सन Wikipedia उद्धृत करने के लिए है, "फ़ंक्शन परिभाषित करने की एक विधि जिसमें फ़ंक्शन परिभाषित किया गया है उसकी परिभाषा के भीतर लागू किया गया है"। इसी तरह पारस्परिक पुनरावृत्ति एक और कार्य लागू करता है जो प्रत्यक्ष या परोक्ष रूप से, उस कार्य को लागू करता है जिसे हम परिभाषित कर रहे हैं।

समस्या यह है कि जिस कोड के बारे में मैं सोच रहा हूं और उससे निपट रहा हूं, वही कार्य नहीं करता है! यह एक ही कार्य (एक विधि या बंद करने के रूप में) कोड का उपयोग करता है।

समस्या यह है कि मेरा कोड वही है, फ़ंक्शन नहीं हैं। निम्न बुनियादी आपसी प्रत्यावर्तन उदाहरण एक एक नज़र डालें:

def is_even(x): 
    if x == 0: 
     return True 
    else: 
     return is_odd(x - 1) 

def is_odd(x): 
    if x == 0: 
     return False 
    else: 
     return is_even(x - 1) 

यह पारस्परिक रूप से पुनरावर्ती कुछ हद तक सहज है, और बहुत स्पष्ट रूप से। हालांकि, अगर मैं एक आंतरिक समारोह है कि एक बार हर कॉल बनाई गई है के रूप में प्रत्येक समारोह लपेट, यह कम स्पष्ट हो जाता है:

अंतर्निहित Memoization आदि जैसे

def make_is_even(): 
    def is_even(x): 
     if x == 0: 
      return True 
     else: 
      return make_is_odd()(x - 1) 
    return is_even 

def make_is_odd(): 
    def is_odd(x): 
     if x == 0: 
      return False 
     else: 
      return make_is_even()(x - 1) 
    return is_odd 

def is_even2(x): 
    return make_is_even()(x) 

def is_odd2(x): 
    return make_is_odd()(x) 

की अनदेखी अनुकूलन, इस समारोह कॉल की एक श्रृंखला है कि नहीं है का उत्पादन कड़ाई से रिकर्सिव, विभिन्न नए कार्यों को बनाने और कॉल करने के बिना कभी भी दो बार कॉल किए बिना। फिर भी ये सभी फ़ंक्शंस एक सामान्य टेम्पलेट का पालन करते हैं, और संभवतः एक ही फ़ंक्शन को बार-बार बनाया जाता है (संभवतः विभिन्न मुक्त चर के साथ।

और फिर, हम सीधे समकक्ष के साथ आ सकते हैं (आखिरकार, कक्षाएं वास्तव में हैं बंद, सही;) वर्गों का उपयोग करके कार्यान्वयन। यह विशेष रूप से महत्वपूर्ण है, क्योंकि की इस शैली [0 नाम] का उपयोग किया जाता है, उदाहरण के लिए, Composite Pattern। अंतर यह है कि समग्र डिजाइन पैटर्न के साथ, और अधिकतर उपयोग (यहां तक ​​कि बंद), उदाहरण आमतौर पर फ्लाई पर नहीं बनाए जाते हैं। यह अभी भी वही है।

class EvenChecker(object): 
    def check(self, x): 
     if x == 0: 
      return True 
     else: 
      return OddChecker().check(x - 1) 

class OddChecker(object): 
    def check(self, x): 
     if x == 0: 
      return False 
     else: 
      return EvenChecker().check(x - 1) 

def is_even3(x): 
    return EvenChecker().check(x) 

def is_odd3(x): 
    return OddChecker().check(x) 

समय श्रृंखला वस्तु निर्माण और विधि कॉल का है, लेकिन सिद्धांत एक ही है। (मैं वास्तव में ध्यान देता हूं कि यह थोड़ा अलग है, उस पायथन में एक प्रति-ऑब्जेक्ट आधार पर एक साधारण रैपर को परिभाषित करता है जो हर बार एक ही कार्य को स्वयं ही कॉल करता है - लेकिन यह जरूरी नहीं है कि हमें कुछ पता होना चाहिए, और यह ' टी वर्गों और वस्तुओं के अन्य कार्यान्वयन के लिए सही हो की जरूरत है। लेकिन हाँ, कडाई के साथ यह परस्पर पुनरावर्ती है, साथ ही ... कुछ अधिक है, और यह है कि दूसरी बात यह है कि मैं चाहता हूँ पता करने के लिए है।)

Answer 1

जैसा कि आप इंगित करते हैं, यह अभी भी पारस्परिक रिकर्सन है। मुझे नहीं लगता कि "कुछ और" जो आप पूछ रहे हैं उसका नाम है; अगर ऐसा होता है तो मैंने इसे कभी नहीं सुना है।

Answer 2

जाहिर है, यह Mutual Recursion कहा जाता है :)

लेख भी एक ही उदाहरण आप के रूप में, odd? और even? कार्यों के साथ देता है।

Answer 3

म्यूचुअल रिकर्सन indirect recursion का एक विशेष मामला है।