आरपीथॉन में स्थिर रूप से टाइप किया गया क्या है?

Question

अक्सर यह कहा जाता है कि RPython (पायथन का सबसेट) स्थिर रूप से टाइप किया गया है। (Wikipedia पर 0)

प्रारंभ में, मुझे आश्चर्य हुआ कि वे इसे पायथन में कैसे जोड़ देंगे और सोचा था कि उन्होंने प्रत्येक समारोह की शुरुआत में assert isinstance(arg1, ...) जैसे बयान जोड़ने की आवश्यकता को जोड़ा होगा (लेकिन मैं वास्तव में विश्वास नहीं कर सका उस)।

फिर मैंने कुछ RPython कोड को देखा और यह वास्तव में स्थिर रूप से टाइप नहीं किया गया है। कई मामलों में, यह हो सकता है कि संकलक साबित कर सके कि एक फ़ंक्शन तर्क केवल कुछ प्रकार के हो सकता है लेकिन निश्चित रूप से सभी मामलों में नहीं।

जैसे, इस string.split की RPython दिया गया है:

def split(value, by, maxsplit=-1): 
    bylen = len(by) 
    if bylen == 0: 
     raise ValueError("empty separator") 

    res = [] 
    start = 0 
    while maxsplit != 0: 
     next = value.find(by, start) 
     if next < 0: 
      break 
     res.append(value[start:next]) 
     start = next + bylen 
     maxsplit -= 1 # NB. if it's already < 0, it stays < 0 

    res.append(value[start:len(value)]) 
    return res 

RPython के बारे में PyPy प्रलेखन में यह कहा गया है: "चर ज़्यादा से ज़्यादा एक प्रकार का मान होने चाहिए"।

तो, फ़ंक्शन तर्क भी चर के रूप में गिना जाता है? या किस अर्थ में RPython स्थिर रूप से टाइप किया गया है? या यह वास्तव में गलत है?

Answer 1

तो, फ़ंक्शन तर्क भी चर के रूप में गिना जाता है?

बेशक वे करते हैं। वे हमेशा हर भाषा में बहुत कुछ करते हैं।

या आरपीथन द्वारा किस अर्थ में टाइप किया गया है? या यह वास्तव में गलत है?

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

कई मामलों में, यह हो सकता है कि संकलक साबित कर सके कि फ़ंक्शन तर्क केवल कुछ प्रकारों का हो सकता है लेकिन निश्चित रूप से सभी मामलों में नहीं।

बेशक नहीं। वहां बहुत सारे कोड हैं जो स्थिर रूप से टाइप नहीं किए गए हैं, और कुछ स्थिर रूप से टाइप किए गए कोड वर्तमान एनोटेटर को सांख्यिकीय रूप से टाइप नहीं किया जा सकता है। लेकिन जब इस तरह के कोड को बढ़ाया जाता है, तो यह एक संकलन त्रुटियों, अवधि है।

कुछ बिंदुओं कि महत्वपूर्ण हैं महसूस करने के लिए कर रहे हैं:

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

• यह विश्लेषण पूरे कार्यक्रम के आधार पर होता है! कोई फंक्शन def add(a, b): return a + b (तर्क इंक, फ्लोट्स, स्ट्रिंग्स, सूचियां इत्यादि) के लिए एक (गैर-जेनेरिक) प्रकार का अनुमान नहीं लगा सकता है, लेकिन अगर फ़ंक्शन को पूर्णांक तर्कों के साथ बुलाया जाता है (उदाहरण के लिए पूर्णांक अक्षर या चर जो पहले थे पूर्णांक रखने के लिए अनुमानित), यह निर्धारित किया गया है कि a और b (और, + के प्रकार से, add का परिणाम) पूर्णांक भी हैं।

• पीपीपी रिपोजिटरी में सभी कोड RPython नहीं है। उदाहरण के लिए, कोड जनरेटर (उदा। rlib.parsing में) जो संकलन समय पर चलते हैं और RPython कोड उत्पन्न करते हैं, लेकिन RPython (अक्सर "NOT_RPYTHON" डॉकस्ट्रिंग के साथ) नहीं होते हैं। इसके अलावा, मानक पुस्तकालय के बड़े हिस्से पूर्ण पायथन में लिखे गए हैं (ज्यादातर सीधे सीपीथन से लिया जाता है)।

पूरे अनुवाद और टाइपिंग वास्तव में कैसे काम करता है इस पर बहुत सारी रोचक सामग्री है। उदाहरण के लिए, The RPython Toolchain सामान्य रूप से अनुवाद प्रक्रिया का वर्णन करता है, जिसमें टाइप अनुमान, और The RPython Typer उपयोग की जाने वाली प्रकार प्रणाली का वर्णन करता है।

Answer 2

हां, यह स्थिर रूप से टाइप किया गया है। आपके उदाहरण में कोई भी चर बदलता प्रकार नहीं है, जो उस संबंध में RPython की आवश्यकता को पूरा करता है। RPython is not formally defined, and it's restrictions are constantly evolving, लेकिन प्रलेखन अभी भी शुरू करने के लिए एक अच्छी जगह है। थोड़ा सा पढ़ने के बाद, कुछ कोड करने का प्रयास करना और कुछ कोड का अनुवाद करना है, आप यह पता लगाएंगे कि आप क्या कर सकते हैं और बहुत जल्दी नहीं कर सकते!