वाई-संयोजक?

Question

मैं, (मैं की प्रकार योजना में इसे समझने) और डी 2.0 में इसे लागू वाई Combinator बेहतर जानने की कोशिश कर रहा हूँ और मैं बहुत बुरी तरह नाकाम रहने हूँ:

auto fact = delegate(uint delegate(uint) recurse) 
{ 
    return delegate(uint n) 
    { 
     return n > 1 ? n * recurse(n - 1) : 1; 
    }; 
}; 

fact(fact)(5); 

यह नहीं है काम, स्पष्ट कारण के लिए कि मैं factfact (इसके प्रकार का क्या होगा?) पास नहीं कर सकता है। और इसके अलावा, मुझे अभी भी fact का नाम स्वयं पास करने की आवश्यकता है, इसलिए यह वैसे भी काम नहीं करेगा, है ना?

लेकिन ... मैं डी में वाई-संयोजक को लागू करने के बारे में कैसे जा सकता हूं?

Answer 1

एक व्यापक स्पष्टीकरण here देखें।

Answer 2

मुझे डी नहीं पता है, लेकिन जब आप गैर-रिकर्सन को लागू करने का प्रयास करते हैं तो अधिकांश भाषाओं के साथ आपको समस्याएं मिलेंगी (आपके कोड में अभी तक कोई वाई-कॉम्बिनेटर नहीं है)। आसपास के सामान्य तरीके को विभिन्न हिस्सों में अलग करके और इस प्रकार के प्रकार में रिकर्सन प्राप्त करके हासिल किया जा सकता है।

कुछ उदाहरण अन्य भाषाओं से:

• सी एक में आम तौर पर एक struct कि समारोह सूचक होता है लिखता है। इस संरचना को तब तर्क के रूप में इस्तेमाल किया जा सकता है।

• ओकैमल में एक प्रकार का प्रकार जोड़ देगा जो फ़ंक्शन प्रकार को लपेटता है। फिर से यह प्रकारों को अलग करने की अनुमति देता है, इसलिए रिकर्सन संभव है।

आप अन्य भाषाओं से कुछ उदाहरण चाहते हैं this page पर एक नजर है।

Answer 3

यह डी (और सी/सी ++) की एक जान सीमा है जो कि टाइप किए गए आत्म संदर्भों से निपटने के लिए असंभव है (आखिरी बार मैंने चेक किया) घोषित करने के लिए।

मुझे यह विडंबना मिलती है क्योंकि यह वाक्यविन्यास की सीमा (फ़ंक्शन प्रोटोटाइप की लंबाई अनंत है) या नामकरण सम्मेलन (समान समस्या लेकिन नाम मैंगलिंग के साथ) कुछ अर्थपूर्ण या वास्तुशिल्प की बजाय है।

Answer 4

मेरे डी में सामान्य Y Combinator:

import std.stdio, std.algorithm, std.range; 
auto Y(R,T...)(R delegate(T) delegate (R delegate(T)) f){ 
    struct F{R delegate(F,T) f;}; 
    return (R delegate(T)delegate(F) a){return a(F((F b,T i){return f(a(b))(i);})); 
    }((F b){return (T n){return b.f(b,n);};}); 
} 
void main(){ 
    auto factorial=Y((long delegate(long) self){return (long i){return i?self(i-1)*i:1;};}); 
    auto fibonacci=Y((int delegate(int) self){return (int i){return i<2?i:self(i-1)+self(i-2);};}); 
    auto ackermann=Y((long delegate(long,long) self){return (long n,long m){return n?m?self(n-1,self(n,m-1)):self(n-1,1):m+1;};}); 
    writeln(map!factorial(iota(0,20))); 
    writeln(map!fibonacci(iota(0,20))); 
    writeln(map!((a){return ackermann(a%4,a/4);})(iota(0,20))); 
} 

मैं भाज्य समारोह की एक छोटी सी पुनरावर्ती परिभाषा के साथ शुरू किया और इसे संशोधित जब तक मेरे कोड इस तरह देखा। असीमित प्रकार की समस्या एक प्रकार के आवरण (संरचना एफ) के साथ काम किया जा रहा है।