बदलते ऑपरेटर डिफ़ॉल्ट व्यवहार

Question

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

(रीसाइक्लिंग) गैर अनुकूल वैक्टर arythmetic आपरेशनों में पुनर्नवीनीकरण:

> x=1:10 
> y=1:20 
> y=rep(1,20) 
> x+y 
[1] 2 3 4 5 6 7 8 9 10 11 2 3 4 5 6 7 8 9 10 11 

उसमें कोई त्रुटि में इस आपरेशन परिणाम बनाने के लिए एक तरीका है?

(रूपांतरण) रूपांतरण होते हैं, जब वैक्टर को अद्यतन करने के लिए, कभी कभी, कभी कभी वेक्टर के प्रकार अपडेट किया जा रहा तत्व के प्रकार को बदलने:

> x[1] <- 'a' 
> x 
[1] "a" "2" "3" "4" "5" "6" "7" "8" "9" "10" 
> x[1] <- 1 
> x 
[1] "1" "2" "3" "4" "5" "6" "7" "8" "9" "10" 

वहाँ एक में इस आपरेशन परिणाम बनाने के लिए एक रास्ता है त्रुटि?

मुझे विश्वास है कि नए और मध्यवर्ती उपयोगकर्ताओं की निराशा की वजह से इस तरह के व्यवहार से उत्पन्न होता है (जिसके परिणामस्वरूप भाषा पर सारांश निर्णय होता है!)। रीसाइक्लिंग और रूपांतरण को संबोधित करने के लिए सामान्य दृष्टिकोण के लिए कोई सूचक बहुत स्वागत है।

Answer 1

इसके अतिरिक्त। डेविड सही बिंदु पर है। समझदार कोड को मैं कम से कम एक समारोह के प्रवेश पर बातें इस तरह की जाँच करें या अंत में:

require(testthat) 
    expect_equal(length(out), length (mainEntry)) 

रूपांतरण भी एक बहुत संवेदनशील मुद्दा है। महत्वपूर्ण कोड में मैं असाइनमेंट में टाइप निर्दिष्ट करता हूं:

X[1] <- as.numeric("a") 

चेतावनी उठाएगा। आप S4 classes का उपयोग करके रूपांतरणों को रोकने वाले वर्गों को भी परिभाषित कर सकते हैं।

दुर्भाग्यवश शुरुआती लोगों के लिए यह पालन करना आसान नहीं हो सकता है लेकिन शुरुआती लोगों को गंभीर कोड को संभालना चाहिए?