वाई-संयोजक निश्चित रूप से निश्चित बिंदु की गणना कैसे करता है?

Question

मेरा मानना ​​है कि मैं गणितीय रूप से वाई-संयोजक का विचार समझता हूं: यह किसी दिए गए कार्यात्मक F का निश्चित बिंदु देता है, इस प्रकार f = Y(F) जहां ff == F(f) को संतुष्ट करता है।

लेकिन मुझे समझ में नहीं आता कि यह वास्तविक गणना कार्यक्रम के अनुसार कैसे काम करता है?

के दिए गए here (मैं भी जो पढ़ने में आसान है एक CoffeeScript टिप्पणी में संस्करण, शामिल हैं) जावास्क्रिप्ट उदाहरण लेते हैं:

var Y = function (F) { 
    return (function(x) { 
    return F(function(y) { 
     return x(x)(y); 
    }); 
    })(function(x) { 
    return F(function(y) { 
     return x(x)(y); 
    }); 
    }); 
}; 


var Factorial = function (factorial) { 
    return function (n) { 
    if (n === 0) { 
     return 1; 
    } else { 
     return n * factorial(n - 1); 
    } 
    }  
}; 

/* Equivalent CoffeeScript: 
Y = (F) -> 
    ((x) -> F((y) -> x(x)(y)))((x) -> F((y) -> x(x)(y))) 

Factorial = (factorial) -> 
    if n == 0 then 1 else n * factorial(n-1) 
*/ 

Y(Factorial)(6) == 720 // => true 
computed_factorial = Y(Factorial) 

हिस्सा मुझे समझ नहीं आता कैसे computed_factorial समारोह (नियत बिन्दु है) वास्तव में गणना की जाती है? वाई की परिभाषा का पता लगाने के द्वारा, आप पाएंगे कि यह पर भाग पर अनगिनत रिकर्सन में चलता है, मैं वहां उल्लिखित किसी भी टर्मिनल केस को नहीं देख सकता। हालांकि, यह अजीब तरह से वापस आता है। क्या कोई समझा सकता है?

Answer 1

मैं ES6 तीर फ़ंक्शन सिंटैक्स का उपयोग करने जा रहा हूं। चूंकि आपको कॉफीस्क्रिप्ट पता है, आपको इसे पढ़ने में कोई परेशानी नहीं होनी चाहिए।

यहाँ अपने Y Combinator

var Y = F=> (x=> F (y=> x (x) (y))) (x=> F (y=> x (x) (y))) 

मैं अपने factorial समारोह यद्यपि के एक उन्नत संस्करण का उपयोग करने के लिए जा रहा हूँ है। यह एक संचयक का उपयोग करता है जिसके बजाय मूल्यांकन को एक बड़े पिरामिड में बदलने से रोक दिया जाएगा। इस फ़ंक्शन की प्रक्रिया रैखिक पुनरावृत्त होगी, जबकि आपका रिकर्सिव होगा। जब ईएस 6 अंत में पूंछ कॉल उन्मूलन प्राप्त करता है, तो इससे भी बड़ा अंतर होता है।

वाक्यविन्यास में अंतर नाममात्र है। यह वास्तव में कोई फर्क नहीं पड़ता क्योंकि आप सिर्फ यह देखना चाहते हैं कि Y का मूल्यांकन कैसे किया जाता है।

var factorial = Y (fact=> acc=> n=> 
    n < 2 ? acc : fact (acc*n) (n-1) 
) (1); 

वैसे यह कंप्यूटर को कुछ काम करने शुरू कर देगा। तो इससे पहले कि हम किसी भी आगे जाने के लिए इस का मूल्यांकन करते हैं ...

मुझे आशा है कि आप अपने पाठ संपादक में एक बहुत अच्छी ब्रैकेट हाइलाइटर है ...

var factorial 
= Y (f=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (1)                                        // sub Y 
= (F=> (x=> F (y=> x (x) (y))) (x=> F (y=> x (x) (y)))) (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (1)                           // apply F=> to fact=> 
= (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (1)                // apply x=> to x=> 
= (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (1) // apply fact=> to y=> 
= (acc=> n=> n < 2 ? acc : (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (acc*n) (n-1)) (1)    // apply acc=> to 1 
= n=> n < 2 ? 1 : (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (1*n) (n-1)        // return value 
= [Function] (n=> ...) 

तो तुम यहाँ देख सकते हैं, के बाद हम कहते हैं:

var factorial = Y(fact=> acc=> n=> ...) (1); 
//=> [Function] (n=> ...) 

हम एक समारोह वापस है कि एक एकल इनपुट, n के लिए इंतज़ार कर रहा है मिलता है। चलो अब

इससे पहले कि हम आगे बढ़ना है, तो आप सत्यापित कर सकते हैं एक भाज्य चलाते हैं (और आप चाहिए) कि हर लाइन यहाँ एक जावास्क्रिप्ट repl में नकल/यह चिपकाने से सही है। प्रत्येक पंक्ति 24 लौटाएगी (जो factorial(4) के लिए सही उत्तर है। क्षमा करें अगर मैंने आपके लिए इसे खराब कर दिया है)। ऐसा तब होता है जब आप अंशों को सरल बनाते हैं, बीजगणित समीकरणों को हल करते हैं, या रासायनिक सूत्रों को संतुलित करते हैं; प्रत्येक चरण एक सही जवाब होना चाहिए।

मेरी टिप्पणियों के लिए दाईं ओर स्क्रॉल करना सुनिश्चित करें। मैं आपको बताता हूं कि मैं प्रत्येक लाइन पर कौन सा ऑपरेशन पूरा करता हूं। पूरा ऑपरेशन का परिणाम आगामी लाइन पर है।

और सुनिश्चित करें कि आप उस वर्ग हाइलाइटर फिर से काम किया है ...

factorial (4)                                                      // sub factorial 
= (n=> n < 2 ? 1 : (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (1*n) (n-1)) (4)         // apply n=> to 4 
= 4 < 2 ? 1 : (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (1*4) (4-1)           // 4 < 2 
= false ? 1 : (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (1*4) (4-1)           // ?: 
= (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (1*4) (4-1)              // 1*4 
= (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (4) (4-1)               // 4-1 
= (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (4) (3)               // apply y=> to 4 
= (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (4) (3)                  // apply x=> to x=> 
= (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (4) (3)  // apply fact=> to y=> 
= (acc=> n=> n < 2 ? acc : (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (acc*n) (n-1)) (4) (3)     // apply acc=> to 4 
= (n=> n < 2 ? 4 : (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (4*n) (n-1)) (3)         // apply n=> to 3 
= 3 < 2 ? 4 : (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (4*3) (3-1)           // 3 < 2 
= false ? 4 : (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (4*3) (3-1)           // ?: 
= (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (4*3) (3-1)              // 4*2 
= (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (12) (3-1)              // 3-1 
= (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (12) (2)               // apply y=> to 12 
= (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (12) (2)                 // apply x=> to y=> 
= (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (12) (2)  // apply fact=> to y=> 
= (acc=> n=> n < 2 ? acc : (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (acc*n) (n-1)) (12) (2)     // apply acc=> 12 
= (n=> n < 2 ? 12 : (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (12*n) (n-1)) (2)        // apply n=> 2 
= 2 < 2 ? 12 : (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (12*2) (2-1)           // 2 < 2 
= false ? 12 : (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (12*2) (2-1)           // ?: 
= (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (12*2) (2-1)              // 12*2 
= (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (24) (2-1)              // 2-1 
= (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (24) (1)               // apply y=> to 24 
= (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (24) (1)                 // apply x=> to x=> 
= (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (24) (1)  // apply fact=> to y=> 
= (acc=> n=> n < 2 ? acc : (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (acc*n) (n-1)) (24) (1)     // apply acc=> to 24 
= (n=> n < 2 ? 24 : (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (24*n) (n-1)) (1)        // apply n=> to 1 
= 1 < 2 ? 24 : (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (24*1) (1-1)           // 1 < 2 
= true ? 24 : (y=> (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (x=> (fact=> acc=> n=> n < 2 ? acc : fact (acc*n) (n-1)) (y=> x (x) (y))) (y)) (24*1) (1-1)           // ?: 
= 24 

---

मैं भी Y के अन्य कार्यान्वयन देखा है। खरोंच से एक और (जावास्क्रिप्ट में उपयोग के लिए) बनाने के लिए यहां एक सरल प्रक्रिया है।

// text book 
var Y = f=> f (Y (f)) 

// prevent immediate recursion (javascript is applicative order) 
var Y = f=> f (x=> Y (f) (x)) 

// remove recursion using U combinator 
var Y = U (h=> f=> f (x=> h (h) (f) (x))) 

// given: U = f=> f (f) 
var Y = (h=> f=> f (x=> h (h) (f) (x))) (h=> f=> f (x=> h (h) (f) (x))) 

Answer 2

एक आलसी मूल्यांकन भाषा में, वाई Combinator रूप में परिभाषित किया जा सकता है:

Y = (f => 
    (x => f(x(x))) 
    (x => f(x(x)))) 

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

इस समस्या को हल करने के लिए, x के निष्पादन में देरी के लिए एक अज्ञात "रैपर" फ़ंक्शन पेश किया जा सकता है। यह रैपर फ़ंक्शन x (x) जैसा ही व्यवहार करेगा, लेकिन तुरंत कार्य करेगा क्योंकि यह केवल एक फ़ंक्शन परिभाषा है।

यह जानते हुए कि एक्स (एक्स) उदाहरण के मामले में, पुनरावर्ती क्रिया करने के लिए बाध्य किया जाएगा:

Factorial = f => n => n==0 ? 1 : n*f(n-1) 

हम समय से आगे बता सकता है कि केवल एक ही तर्क यह करने के लिए पारित किया जाना होगा । यह हमें निम्नलिखित पैटर्न का उपयोग करने को उस अज्ञात फ़ंक्शन के रूप में किसी भी समारोह f (x) एक ही व्यवहार करती है उत्पन्न करने के लिए अनुमति देता है:

f => x => f(x) 

जब हम (एक्स) अवधि के लिए एक्स इस पद्धति लागू होते हैं, वाई अब अनिश्चित काल के लिए recurse और हो जाता है जाएगा:

Y = (f => 
    (x => f(y => x(x)(y))) 
    (x => f(y => x(x)(y)))) 

Answer 3

Y Combinator लैम्ब्डा पथरी में सबसे दिलचस्प phenomenons से एक है। मुझे संदेह है कि इसे तुरंत देखकर, कोई भी इसकी कार्यक्षमता की व्याख्या के साथ आ सकता है।

Y = f => (g => g(g))(g => n => f(g(g))(n)); 

चलिए कदम से व्युत्पन्न कदम को समझने की कोशिश करते हैं। मैं तीर कार्यों का उपयोग करूंगा ताकि यदि आप उनसे परिचित नहीं हैं तो कृपया this link का पालन करें। वे बहुत सरल हैं। x => x का अर्थ है function(x){return x;}। जेएस this कीवर्ड के तीर के भीतर एक अलग अर्थ है लेकिन यह इस विषय के अनुसार विषय बंद है।

तो हमेशा के रूप में हम फैक्टोरियल फ़ंक्शन के साथ जाएंगे, लेकिन वाई संयोजक जिसे हम प्राप्त करेंगे, सभी रिकर्सिव कार्यों के लिए मान्य होगा।

एक भाज्य समारोह बस के रूप में

var fa = n => n === 0 ? 1 : n*fa(n-1); 
fact(5) // <- 120 

इस प्रकार व्यक्त किया जा सकता लेकिन कहते हैं कि हमें fa समारोह रिकर्सिवली का उल्लेख नहीं करना चाहती; इसके बजाय हम फैक्टोरियल फ़ंक्शन के एक काल्पनिक संस्करण से एक कार्यशील फैक्टोरियल फ़ंक्शन प्राप्त करना चाहते हैं। एक काल्पनिक फैक्टोरियल समारोह क्या है? Hypothetical फैक्टोरियल समारोह एक उचित फैक्टोरियल समारोह लेता है और हमें एक कामकाजी फैक्टोरियल समारोह देता है। निम्नलिखित

var fh = f => n => n === 0 ? 1 : n*f(n-1); 

की तरह तो अगर मैं fh एक तर्क यह काम करेगा के रूप में fa समारोह गुजरती हैं। पसंद;

fh(fa)(5); // <- 120 

लेकिन हम fa की तरह एक और भाज्य समारोह का उल्लेख करने के बाद से हम पहले से ही नहीं है चाहता हूँ "की तरह" fh समारोह के भीतर भाज्य तर्क को परिभाषित किया। फिर हम सोचते हैं। fh बंद होने में f तर्क रखता है और मुझे एक कामकाजी फैक्टोरियल फ़ंक्शन (n => n === 0 ? 1 : n*f(n-1)) देता है यदि मैं fa जैसे उचित फैक्टोरियल फ़ंक्शन पास करता हूं। तो क्या होगा अगर मैं इसे अपने पास कर दूं; एक त्वरित प्रयास fh(fh)(5) // <- NaN मेह ..!

तो हम आंतरिक कार्य के साथ खेलना शुरू करते हैं। आम तौर पर मैं इस कदम को पारित करता हूं लेकिन परिवर्तनों को देखना उपयोगी हो सकता है ... इसलिए जारी रखें। मैं मेरे एक समारोह जो दो तर्क लेता है, जो अपने आप और भाज्य गिनती वापस जाने के लिए fb समारोह को परिभाषित कर सकते n

fb = (f,n) => n === 0 ? 1 : n* f(f,n-1), // fb(fb,5) <- 120 

अब तक तो अच्छा है लेकिन दो तर्क भाज्य समारोह नहीं है जहां मैं क्या देख रहा हूँ के करीब है। मैं उन्हें एक और कार्यात्मक कदम जोड़कर अलग कर सकता हूं।

fc = f => n => n === 0 ? 1 : n* f(f)(n-1), // fc(fc)(5) <- 120 

अब यह बहुत ही हमारे काल्पनिक समारोह fh के करीब है। लेकिन आंतरिक शो f(f)(n-1) हमें एफ (एन -1) दिखाने के लिए इसे सही करना होगा। अच्छी तरह से हम एक जेएस सौंदर्य IIFE का उपयोग करने में हमारी सहायता के लिए उपयोग कर सकते हैं ...

fd => f => n => ((g,n) => n === 0 ? 1 : n * (g,n-1))(f(f),n) // fd(fd)(5) <- 120 

क्या आप आईआईएफई देख सकते हैं ..? ((g,n) => n === 0 ? 1 : n * g(n-1))(f(f),n) फिर भी, यह ठीक लगता है, वांछित परिणाम प्राप्त करने के लिए मुझे दोहरी तर्क (g,n) IIFE से छुटकारा पाना है। यह कार्यात्मक होने का एक और स्तर ले जाएगा।

fe => f => n => (g => n => n === 0 ? 1 : n * g(n-1))(f(f))(n) // fe(fe)(5) <- 120 

अब हम g => n => n === 0 ? 1 : n * g(n-1) जो हमारे काल्पनिक समारोह fh का मुख्य भाग है अंदर है। जिसका अर्थ है कि मैं विकल्प (मुझे इस भाग से प्यार है .. कैलकुंस प्रतिस्थापन की तरह, वास्तव में यह है ...) fh उपरोक्त फ़ंक्शन में पढ़ने के लिए;

fe => f => n => fh(f(f))(n) // fe(fe)(5) <- 120 

इसे लपेटने के लिए ठीक समय। मैं पहले स्थान पर क्या चाहता था ..? मैं fh को फ़ंक्शन (वाई-संयोजक) में फ़ीड करना चाहता हूं और इसे निश्चित बिंदु प्राप्त करना चाहता हूं। यहां मुझे पता है कि fe(fe)fh का उपयोग करता है और मुझे ठीक से काम कर रहे फैक्टोरियल फ़ंक्शन देता है। तो एक तर्क के रूप में हमारे हाइपोफेटिकल रिकर्सिव फ़ंक्शन को लेने के लिए एक फ़ंक्शन को परिभाषित करने दें और हमें कुछ काम करने (निश्चित) दें। IIFE फिर से मदद करने के लिए।

Y = f => (g => g(g))(g => n => f(g(g))(n)); 

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

var Y = f => (g => g(g))(g => n => f(g(g))(n)), 
 
fibH = f => n => n === 0 ? 0 
 
          : n === 1 ? 1 
 
            : f(n-2) + f(n-1), 
 
fibo = Y(fibH); 
 
console.log(fibo(10));

मुझे आशा है कि यह सब स्पष्ट ...