क्या सशर्त बयान के शरीर के अंदर कई बयानों की संभावना है?

Question

मैं मुख्य रूप से एक सी ++ (इस प्रकार एक ओओ/अनिवार्य) प्रोग्रामर हूं और मुझे यह बहुत विचित्र लगता है कि आप एक सशर्त बयान में प्रति मूल्यांकन एक विवरण दे सकते हैं जैसे कि योजना में एक if-statement, एक कार्यात्मक भाषा।

उदाहरण के लिए:

(let ((arg1 0) (arg2 1)) 
    (if (> arg1 arg2) 
     arg1 
     arg2))) 

गलत उदाहरण:

(let ((arg1 0) (arg2 1)) 
    (if (> arg1 arg2) 
     (arg1 (display "cool")) 
     (arg2 (display "not cool")))) 

मुझे एक प्रकार का एक त्रुटि देता है ": उम्मीद प्रक्रिया, यह देखते हुए: प्रक्रिया आवेदन 2; तर्क गया: #void"

जिसे परिभाषित फ़ंक्शन के शरीर के भीतर अलग-अलग बयानों में कहा गया सशर्त बयान देकर हल किया जा सकता है, सशर्त बयान के शरीर को सीपी रखने के साथ arate बयान हर बार इस प्रकार है:

(if (condition) statement1a statement2a) 
(if (condition) statement1b statement2b) 

और इतने पर ...

यह कह रही है कि यह बहुत व्यावहारिक नहीं है बिना चला जाता है। डुप्लीकेट कोड ओवरहेड का जिक्र नहीं है।

क्या मुझे यहां कुछ याद आ रहा है या वास्तव में कोई अन्य तरीका नहीं है?

Answer 1

(let((arg1 0)(arg2 1)) 
    (if (> arg1 arg2) 
     (begin 
     (display arg1) 
     (newline) 
     (display "cool")) 
     (begin 
     (display arg2) 
     (newline) 
     (display "not cool")))) 

जब आप कहते हैं (arg1 (disply "cool")) आप यह कह रहे हैं कि arg1 एक प्रक्षेपण होना चाहिए।

Answer 2

@ राजेशभाट ने एक कथन के साथ शुरू करने का एक अच्छा उदाहरण दिया।

एक और समाधान cond रूप

(let ([arg1 0] [arg2 1]) 
    (cond 
    [(< arg1 0) (display "negative!")] 
    [(> arg1 arg2) (display arg1) (newline) (display "cool")] 
    [else (display arg2) (newline) (display "not cool")])) 

cond रूप में प्रत्येक पंक्ति एक अंतर्निहित begin जो आप वास्तव में अगर आप cond के कार्यान्वयन को देखो देख सकते हैं नहीं है।

(लिंक Chez योजना प्रलेखन के लिए है, (पढ़ सकता है: शायद) नहीं एक ही कार्यान्वयन आप उपयोग कर रहे हैं के रूप में यह स्वामित्व है, हालांकि छोटा Chez (खूबसूरत संस्करण में कोई संकलक) नि: शुल्क है)

http://scheme.com/tspl4/syntax.html#./syntax:s39

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

निम्नलिखित कोड

(+ 2 (begin 3 4 5)) 

7. का मूल्यांकन इसका कारण यह है एक begin फार्म की वापसी मान अपने पिछले अभिव्यक्ति है। प्रारंभ होने पर यह ध्यान में रखना कुछ है। हालांकि, साइड इफेक्ट्स और डिस्प्ले जैसी चीजों का उपयोग करना उन पदों में ठीक काम करेगा जहां 3 और 4 हैं।

Answer 3

एक चीज जो आपको याद आ रही है वह यह है कि योजना में "कथन" जैसी कोई चीज़ नहीं है। सबकुछ एक अभिव्यक्ति है और जिन चीजों पर आप विचार कर सकते हैं वे भी एक मूल्य वापस कर सकते हैं। यह if पर लागू होता है, जिसे आम तौर पर एक मान वापस करने के लिए उपयोग किया जाता है (उदा।, (if (tea-drinker?) 'tea 'coffee)।सी ++ के विपरीत, सशर्त के अधिकांश उपयोग एक परिवर्तनीय या प्रिंटिंग मानों को म्यूट करने के लिए नहीं होंगे। इससे if खंड में एकाधिक अभिव्यक्तियों की आवश्यकता कम हो जाती है।

हालांकि, जैसा कि रॉस और राजेश ने इंगित किया है, आप cond (अनुशंसित) का उपयोग कर सकते हैं या अपने if खंडों में begin का उपयोग कर सकते हैं। ध्यान दें कि यदि आपके पास सशर्त में कई साइड इफेक्टिंग कंप्यूटेशंस हैं, तो हो सकता है कि आप योजना का उपयोग मूर्खतापूर्वक नहीं कर रहे हों।

Answer 4

आप पहले से ही "आंतरिक" प्रक्रिया में एक सतत प्रक्रिया का उपयोग कर रहे हैं, यही कारण है कि इस परिभाषा का उपयोग कर नामित उपयोग नहीं

(define (fact n) 
    (let inner ((counter 1) (result 1)) 
    (if (> counter n) 
     result 
     (inner (+ counter 1) (* result counter))))) 

जाने के बाद से इस प्रक्रिया का राज्य सिर्फ 2 चर के साथ निर्धारित किया जा सकता, यह उस स्मृति का उपयोग नहीं करेगा।

उदाहरण के लिए

(वास्तव 6) इस

(inner 1 1) 
(inner 2 1) 
(inner 3 2) 
(inner 4 6) 
(inner 5 24) 
(inner 6 120) 
(inner 7 720) 
720 

की तरह की जाती है यहाँ एक ही प्रक्रिया के letrec संस्करण है:

(define (fact n) 
    (letrec ((inner 
      (lambda (counter result) 
       (if (> counter n) 
        result 
        (inner (+ counter 1) (* result counter)))))) 
    (inner 1 1))) 

Answer 5

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

आप सिंटैक्स का उपयोग करने के लिए आसानी से एक मैक्रो बना सकते हैं जिसका मतलब सामान्यतः प्रक्रिया-अनुप्रयोग, (arg1 "cool") जैसा है, जिसका मतलब है "प्रत्येक आइटम के बाद एक नई लाइन के साथ कोष्ठक के अंदर सबकुछ प्रदर्शित करें"। (इसका मतलब यह होगा कि केवल मैक्रो, निश्चित रूप से अंदर।) इस तरह:

(define-syntax print-if 
    (syntax-rules() 
    [(_ c (true-print ...) (false-print ...)) 
     (if c 
      (display-with-newlines true-print ...) 
      (display-with-newlines false-print ...))])) 

(define-syntax display-with-newlines 
    (syntax-rules() 
    [(_ e) 
     (begin (display e) (newline))] 
    [(_ e0 e* ...) 
     (begin (display-with-newlines e0) (display-with-newlines e* ...)) ])) 

(let ([arg1 0] [arg2 1]) 
    (print-if (> arg1 arg2) 
      (arg1 "cool") 
      (arg2 "not cool"))) 

आउटपुट:

1 
not cool 

चिंता मत करो अगर आप समझ में नहीं आता कि कैसे मैक्रो परिभाषाओं सही काम अभी व। यदि आप सी ++ को महारत हासिल करने के बाद ही योजना की कोशिश कर रहे हैं, तो इसमें कोई संदेह नहीं है कि आप बहुत निराशा का अनुभव कर रहे हैं। वास्तव में आपके पास बिजली और लचीलापन योजना की तरह एक झलक दिखनी चाहिए।

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

और यदि आप चाहें तो किसी को भी दुष्प्रभावों का उपयोग करने से हतोत्साहित न करें। योजना की महिमा यह है कि आप जो भी आप चाहते हैं कर सकते हैं।