का उपयोग करना (घोषित (प्रकार ...)) 'सुरक्षित' कार्यों लेकिन अभी भी है

Question

क्या यह संभव है कार्यों में (declare (type ...)) घोषणाओं का उपयोग करने पर भी प्रकार की जाँच समारोह तर्क पर तेजी से निर्माण करने के लिए करते हैं, क्रम में, लेकिन अभी भी सुरक्षित कोड?

उदाहरण के लिए

,

(defun add (x y) 
    (declare (type fixnum x y)) 
    (the fixnum x y)) 

जब (add 1 "a") के रूप में बुलाया अपरिभाषित व्यवहार में परिणाम होगा, तो अधिमानतः मैं

(defun add (x y) 
    (declare (type fixnum x y)) 
    (check-type x fixnum) 
    (check-type y fixnum) 
    (the fixnum x y)) 

के रूप में यह संशोधन करना चाहते हैं लेकिन मुझे चिंता है कि संकलक करने के लिए अनुमति दी है मान लेते हैं कि check-type हमेशा से गुजरता है और इस तरह की जांच को छोड़ देते हैं।

तो मेरा सवाल यह है कि उपरोक्त उदाहरण गलत है जैसा कि मैं उम्मीद करता हूं, और दूसरा, क्या कोई सामान्य मुहावरे * अनुकूलित कोड के साथ टाइप-सुरक्षा प्राप्त करने के लिए उपयोग में है?

*) मैं उदाहरण के लिए कल्पना कर सकते हैं, एक अनुकूलित लैम्ब्डा का उपयोग कर और बुला उस प्रकार-जाँच करने के बाद, लेकिन मुझे आश्चर्य है कि यह है कि अगर सबसे खूबसूरत तरीका है।

Answer 1

तुम हमेशा प्रकार पहले जाँच कर सकते हैं और उसके बाद अनुकूलित कोड दर्ज करें:

(defun foo (x) 
    (check-type x fixnum) 
    (locally 
    (declare (fixnum x) 
      (optimize (safety 0))) 
    x)) 

LOCALLY स्थानीय घोषणाओं के लिए प्रयोग किया जाता है।

Answer 2

आप पूछ रहे हैं के बाद से:

यह कार्यों में (declare (type ...)) घोषणाओं का उपयोग करने पर भी प्रकार की जाँच के क्रम में तेजी से निर्माण करने के लिए, समारोह तर्क पर है लेकिन अभी भी सुरक्षित कोड प्रदर्शन संभव है?

ऐसा लगता है कि आप सामान्य लिस्प के प्रकार प्रणाली के बारे में एक महत्वपूर्ण बिंदु खो रहे हैं, यह है कि भाषा स्थिर रूप से टाइप नहीं की जा सकती है (और नहीं हो सकती है)। के इस पहलू स्पष्ट करते हैं।

प्रोग्रामिंग भाषाओं मोटे तौर पर मोटे तौर पर तीन श्रेणियों में वर्गीकृत किया जा सकता है:

1. के साथ स्थिर प्रकार की जाँच: हर अभिव्यक्ति या बयान के लिए संकलन समय पर टाइप शुद्धता की जाँच की है, इसलिए उस प्रकार त्रुटियों कर सकते हैं कार्यक्रम के विकास के दौरान पता लगाया जा, और कोड अधिक कुशल है प्रकार के लिए कोई चेक रन-टाइम में किया जाना चाहिए के बाद से;
2. गतिशील प्रकार की जांच के साथ: हर ऑपरेशन रन टाइम पर सहीता टाइप करने के लिए चेक किया गया है, ताकि रन-टाइम पर कोई प्रकार-त्रुटि न हो;
3. प्रकार की जाँच बिना: प्रकार- त्रुटियों रन-टाइम पर हो सकता है इतना है कि कार्यक्रम त्रुटि के लिए बंद कर दें या एक अपरिभाषित व्यवहार हो सकता है।

संपादित

पिछले वर्गीकरण के संबंध में, कॉमन लिस्प विनिर्देश कार्यान्वयन के लिए छोड़ दिया निर्णय लेने से अगर वे दूसरे या तीसरे दृष्टिकोण का पालन करना चाहते का बोझ!न केवल, लेकिन optimize घोषणा के माध्यम से विनिर्देशन एक ही कार्यक्रम में कार्यान्वयन को इस द्विपक्षीय रूप से बदलने की अनुमति देता है।

तो, अधिकांश प्रयोगों, प्रारंभिक अनुकूलन और सुरक्षा के स्तर पर, दूसरा दृष्टिकोण, निम्नलिखित दो संभावनाओं के साथ समृद्ध लागू करता है:

1. एक रन समय प्रकार-चेकिंग जब छोड़ संकलक करने के लिए अनुरोध कर सकते हैं दक्षता कारणों के लिए कोड के कुछ टुकड़े संकलन, आम तौर पर, ताकि, कोड के उस विशेष टुकड़ा अंदर, और अनुकूलन और सुरक्षा सेटिंग, भाषा तीसरी श्रेणी की भाषाओं की तरह व्यवहार कर सकते हैं पर निर्भर करता है: यह कर सकता है संकेतों द्वारा समर्थित हो ough टाइप घोषणाएं, जैसे (declare (type fixnum x)) चर के लिए और (the fixnum (f x)) मूल्यों के लिए;

2. एक कोड स्पष्ट प्रकार की जाँच परीक्षण में सम्मिलित कर सकते, check-type के माध्यम से, रन-टाइम में प्रदर्शन किया जा करने के लिए इतना है कि जाँच की मूल्य के प्रकार में एक अंतिम अंतर एक "सुधार-त्रुटि" के कारण होगा।

ध्यान दें, इसके अलावा, कि विभिन्न compilers अलग ढंग से संकलन समय पर प्रकार की जाँच से व्यवहार कर सकते हैं, लेकिन वे कभी नहीं स्थिर प्रकार की जाँच के साथ भाषाओं के लिए compilers के स्तर तक पहुंच सकता है क्योंकि कॉमन लिस्प एक अत्यंत गतिशील भाषा है। उदाहरण इस सरल मामले के लिए पर विचार करें:

(defun plus1(x) (1+ x)) 

(defun read-and-apply-plus1() 
    (plus1 (read))) 

जिसमें कोई स्थिर प्रकार-चेकिंग कॉल (plus1 (read)) के लिए किया जा सकता है, के बाद से (read) के प्रकार के संकलन समय पर ज्ञात नहीं है।