रिकर्शन में

रिकर्शन के बारे में

रिकर्सिव फंक्शन ऐसे फंक्शन होते हैं जो खुद को कॉल करते हैं।

एक रिकर्सिव फंक्शन में कम से कम एक बेस केस और कम से कम एक रिकर्सिव केस होना चाहिए।

बेस केस फंक्शन को दोबारा कॉल किए बिना एक वैल्यू लौटाता है। रिकर्सिव केस फंक्शन को दोबारा कॉल करता है और इनपुट को इस तरह बदलता है कि वह किसी बिंदु पर बेस केस से मेल खाने लगे।

बहुत बार हर केस को उसके अपने फंक्शन क्लॉज़ में लिखा जाता है।

# base case
def count([]), do: 0

# recursive case
def count([_head | tail]), do: 1 + count(tail)

एक रिकर्सिव फंक्शन में कई बेस केस और/या कई रिकर्सिव केस हो सकते हैं। उदाहरण के लिए, फिबोनाची अनुक्रम एक रिकर्सिव अनुक्रम है जिसमें दो बेस केस होते हैं:

def fibonacci(0), do: 0
def fibonacci(1), do: 1
def fibonacci(n), do: fibonacci(n - 1) + fibonacci(n - 2)

किसी ऐरे में दी गई वैल्यू x कितनी बार आती है, यह गिनने के दो रिकर्सिव केस होते हैं:

def count_occurrences([], _x), do: 0
def count_occurrences([x | tail], x), do: 1 + count_occurrences(tail, x)
def count_occurrences([_ | tail], x), do: count_occurrences(tail, x)

रिकर्सन के ज़रिए लूप

इम्यूटेबिलिटी की वजह से Elixir में लूप इम्पेरेटिव भाषाओं से अलग तरीके से लिखे जाते हैं। उदाहरण के लिए, लूप आम तौर पर ऐसे दिखते हैं:

for(i = 0; i < array.size; i++) {
  # do something with array[i]
}

फंक्शनल भाषा में i को बदलना (यानी i++ कॉल करना) संभव नहीं होता। इसलिए लूप को रिकर्सन से लागू करना पड़ता है।

Elixir में for लूप के बराबर चीज़ ऐसी दिखेगी:

def loop([]), do: nil

def loop([head | tail]) do
  do_something(head)
  loop(tail)
end

व्यवहार में, ऐरे और दूसरे एन्यूमरेबल डेटा स्ट्रक्चर पर इटरेशन अक्सर Enum मॉड्यूल का उपयोग करके किया जाता है। अंदर से देखें तो Enum मॉड्यूल के फंक्शन रिकर्सन का उपयोग करके लागू किए गए हैं।

अनंत निष्पादन

रिकर्सिव फंक्शन, अगर गलत तरीके से लागू किए जाएँ, तो अपना परिणाम कभी नहीं लौटा सकते। यह समस्या खड़ी कर सकता है, क्योंकि हर बार जब कोई फंक्शन कॉल होता है, तो मेमोरी में एक संदर्भ संग्रहीत हो जाता है, जहाँ VM को परिणाम लौटाना होता है (कॉल स्टैक पर)। अगर कोई रिकर्सिव फंक्शन खुद को अनंत बार कॉल करता रहे, तो मेमोरी खत्म हो सकती है और VM क्रैश हो सकता है (एक स्टैक ओवरफ्लो एरर)। जिस Erlang VM पर Elixir चलता है, वह रिकर्सन और विश्वसनीयता के लिए खास तौर पर ऑप्टिमाइज़ किया गया है, इसलिए अनंत रिकर्सन की गलतियाँ दिखने या क्रैश होने में लंबा समय लग सकता है।

अनंत निष्पादन की यह समस्या इन कारणों से हो सकती है:

• बेस केस लागू करना भूल जाना।
• बेस केस को पहला क्लॉज़ न बनाना।
• रिकर्सिव कॉल करते समय आर्गुमेंट को ठीक से न बदलना, और इस तरह बेस केस तक कभी न पहुँचना।