संपादित करें: ऊपर एक टिप्पणी ने लापता टुकड़ा प्रदान किया है। कुछ लोग जानबूझकर कम-से-ट्यूरिंग-पूर्ण भाषाओं के साथ खेल रहे हैं। मैं स्पष्ट रूप से ऐसी भाषाओं की परवाह नहीं करता। वास्तव में प्रयोग करने योग्य-ट्यूरिंग-पूर्ण भाषा डिजाइन करने के लिए एक पागल कठिन चीज है। इसका पूरा विस्तार इन सिद्धांतों को पूर्ण भाषा में लागू करने की कोशिश करने पर होता है।
असत्य!
function f(a): forall t: Type, t->t
function g(a): forall t: Type, t->t
return (a is g) ? f : a
return a is f ? g : a
जहां isऑपरेटर संदर्भ पहचान के लिए दो चर की तुलना करता है। यही है, वे एक ही मूल्य होते हैं। समान मूल्य नहीं, समान मूल्य। कार्य fऔर gकुछ परिभाषा के बराबर हैं, लेकिन वे समान नहीं हैं।
यदि यह फ़ंक्शन स्वयं पास हो जाता है तो यह कुछ और लौटाता है; अन्यथा यह अपना इनपुट लौटाता है। किसी और चीज़ के समान ही है इसलिए इसे प्रतिस्थापित किया जा सकता है। दूसरे शब्दों में, fपहचान नहीं है, क्योंकि f(f)रिटर्न g, जबकि पहचान वापस आ जाएगीf ।
प्रमेय के लिए इसे धारण करने की हास्यास्पद क्षमता को कम करना होगा
function cantor(n, <z, a>) : forall t: t: Type int, <int, t> -> <int, t>
return n > 1 ? cantor((n % 2 > 0) ? (n + 1) : n / 2, <z + 1, a>) : <z, a>
return cantor(1000, <0, a>)[1]¹
यदि आप यह मानने को तैयार हैं कि आप बहुत आसान प्रकार का अनुमान लगा सकते हैं।
यदि हम डोमेन को प्रतिबंधित करने का प्रयास करते हैं, जब तक कि प्रमेय हमारे पास नहीं है तब तक हम इसे दूर तक सीमित रखने के लिए प्रयास करते हैं।
- शुद्ध कार्यात्मक (कोई उत्परिवर्ती राज्य, कोई आईओ नहीं)। ठीक है मैं उसके साथ रह सकता हूं। कई बार हम फंक्शन्स पर सबूत चलाना चाहते हैं।
- खाली मानक पुस्तकालय। हुंह।
- नहीं
raiseऔर नहीं exit। अब हम विवश होने लगे हैं।
- कोई निचला प्रकार नहीं है।
- भाषा में एक नियम होता है जो संकलक को यह सुनिश्चित करने की अनुमति देता है कि इसे समाप्त करके अनंत पुनरावृत्ति को समाप्त किया जाए। संकलक को तुच्छ अनंत पुनरावर्तन को अस्वीकार करने की अनुमति है।
- संकलक को विफल होने की अनुमति दी जाती है यदि उसे किसी ऐसी चीज के साथ प्रस्तुत किया जाता है जिसे या तो साबित नहीं किया जा सकता है। अब मानक पुस्तकालय तर्कों के रूप में कार्य नहीं कर सकता है। बू।
- नहीं है
nil। इससे समस्या होने लगी है। हमने 1 / 0. out से निपटने के तरीकों से बाहर भाग लिया है
- भाषा शाखा प्रकार के इंफ़ेक्शन नहीं कर सकती है और जब प्रोग्रामर एक प्रकार की भाषा कैंटीन साबित कर सकता है तो इसके लिए कोई ओवरराइड नहीं होता है। यह बहुत बुरा है।
पिछले दो अवरोधों के अस्तित्व ने भाषा को अपंग बना दिया है। हालांकि यह अभी भी ट्यूरिंग को पूरा करने का एकमात्र तरीका है सामान्य उद्देश्य काम पाने के लिए एक आंतरिक मंच का अनुकरण करना है जो एक भाषा को शिथिल आवश्यकताओं के साथ व्याख्या करता है।
The यदि आपको लगता है कि कंपाइलर उस एक को कम कर सकता है, तो इसे आज़माएं
function fermat(z) : int -> int
function pow(x, p)
return p = 0 ? 1 : x * pow(x, p - 1)
function f2(x, y, z) : int, int, int -> <int, int>
left = pow(x, 5) + pow(y, 5)
right = pow(z, 5)
return left = right
? <x, y>
: pow(x, 5) < right
? f2(x + 1, y, z)
: pow(y, 5) < right
? f2(2, y + 1, z)
: f2(2, 2, z + 1)
return f2(2, 2, z)
function cantor(n, <z, a>) : forall t: t: Type int, <int, t> -> <int, t>
return n > 1 ? cantor((n % 2 > 0) ? (n + 1) : n / 2, <z + 1, a>) : <z, a>
return cantor(fermat(3)[0], <0, a>)[1]
On इस बात का प्रमाण कि कंपाइलर ऐसा नहीं कर सकता है, अंधा करने पर निर्भर करता है। कंपाइलर लूप को एक बार में नहीं देख सकता है, यह सुनिश्चित करने के लिए हम कई पुस्तकालयों का उपयोग कर सकते हैं। इसके अलावा, हम हमेशा कुछ ऐसा बना सकते हैं जहाँ प्रोग्राम काम करेगा लेकिन संकलित नहीं किया जा सकता क्योंकि संकलक उपलब्ध मेमोरी में इंडक्शन नहीं कर सकता है।
³ किसी को लगता है कि आप बिना किसी सामान्य जेनेरिक प्रकार के रिटर्न देने वाले इस रिटर्न को शून्य कर सकते हैं। यह एक बुरा दंड देता है जिसके लिए मैंने कोई प्रभावी भाषा नहीं देखी है जो इसे भुगतान कर सकती है।
function f(a, b, c): t: Type: t[],int,int->t
return a[b/c]
संकलन नहीं करना चाहिए। मूलभूत समस्या रनटाइम एरे इंडेक्सिंग नहीं है।