हास्केल में 'फिक्स' का यह संस्करण अधिक कुशल क्यों है?

धीमा fix रिकर्सन के प्रत्येक चरण पर f कॉल करता है, जबकि तेज़ वाला f ठीक एक बार कॉल करता है। इसे ट्रेसिंग के साथ देखा जा सकता है:

import Debug.Trace

fix  f = f (fix f)
fix' f = let x = f x in x

facf :: (Int -> Int) -> Int -> Int
facf f 0 = 1
facf f n = n * f (n - 1)

tracedFacf x = trace "called" facf x

fac  = fix tracedFacf
fac' = fix' tracedFacf

अब कुछ दौड़ने का प्रयास करें:

> fac 3
called
called
called
called
6
> fac' 3
called
6

अधिक विवरण में, let x = f x in x के परिणामस्वरूप x के लिए एक आलसी थंक आवंटित किया जाता है, और इस थंक के लिए एक पॉइंटर f को पास कर दिया जाता है। पहले fix' f का मूल्यांकन करने पर, थंक का मूल्यांकन किया जाता है और इसके सभी संदर्भ (यहां विशेष रूप से: जिसे हम f में पास करते हैं) परिणामी मूल्य पर पुनर्निर्देशित किए जाते हैं। ऐसा होता है कि x को एक मान दिया जाता है जिसमें x का संदर्भ भी होता है।

मैं मानता हूं कि यह दिमाग को झुकाने वाला हो सकता है। यह कुछ ऐसा है जिसे आलस्य के साथ काम करते समय आदत डालनी चाहिए।