स्कीम मैक्रो जो खोजशब्द द्वारा ट्रिगर किया गया है

Question

मान लीजिए कि मैं एस-अभिव्यक्ति में पहले आइटम के अलावा किसी अन्य चीज़ पर स्कीम मैक्रो ट्रिगर करना चाहता हूं। उदाहरण के लिए, कि मैं एक इन्फ़िक्स शैली := साथ define को बदलने के लिए करना चाहता था लगता है, तो यह है कि:

(a := 5) -> (define a 5) 
((square x) := (* x x)) -> (define (square x) (* x x)) 

वास्तविक परिवर्तन काफी सरल हो रहा है। इस चाल को := अभिव्यक्तियों और मैक्रो-विस्तारित करने के लिए योजना मिल जाएगी। मैंने कोड के आसपास के बड़े वर्गों के बारे में सोचा है जो मानक मैक्रो के साथ इंफिक्स सिंटैक्स का उपयोग करते हैं, शायद: (with-infix-define expr1 expr2 ...), और मानक मैक्रो अपने शरीर में अभिव्यक्तियों के माध्यम से चलना और आवश्यक परिवर्तन करना। मुझे पता है कि यदि मैं इस दृष्टिकोण को लेता हूं, तो मुझे उन सूचियों को बदलने से बचने के लिए सावधान रहना होगा जिन्हें वास्तव में डेटा माना जाता है, जैसे उद्धृत सूचियां, और quasiquoted सूचियों के कुछ अनुभाग। मैं क्या कल्पना का एक उदाहरण:

(with-infix-define 
    ((make-adder n) := (lambda (m) (+ n m))) 

    ((foo) := 
     (add-3 := (make-adder 3)) 
     (add-6 := (make-adder 6)) 
     (let ((a 5) (b 6)) 
      (+ (add-3 a) (add-6 b)))) 

    (display (foo)) 
    (display '(This := should not be transformed)) 

तो, मेरे सवाल का दो गुना है:

1. अगर मैं with-infix-define मार्ग अपनाते हैं, मैं किसी भी ठोकर बोली के अलावा अन्य ब्लॉकों के लिए बाहर देखने के लिए करते हैं और quasiquote?
2. मुझे लगता है कि मैं पहिया को फिर से शुरू कर रहा हूं। इस प्रकार का कोड चलना बिल्कुल मानक मैक्रो विस्तार प्रणालियों को करना होगा - केवल अंतर यह है कि किसी भी कोड परिवर्तन को करने या नहीं करने का निर्णय लेने पर वे केवल सूची में पहले आइटम को देखते हैं। क्या कोई तरीका है कि मैं मौजूदा सिस्टम पर बस पिगबैक कर सकता हूं?

Answer 1

1. इससे पहले कि आप इस के साथ जारी है, यह सोचने के लिए अच्छी तरह से खत्म हो गया चीजें सबसे अच्छा है - IME आप अक्सर है कि क्या तुम सच में एक इन्फ़िक्स वाक्य रचना के रूप में := के पाठक स्तरीय हैंडलिंग चाहते हैं चाहते हैं। इसका मतलब यह होगा कि यह उद्धरण आदि में भी इंफिक्स है, इसलिए अब यह बुरा लगेगा, लेकिन फिर, मेरा अनुभव यह है कि आप यह महसूस कर रहे हैं कि चीजों को लगातार करना बेहतर है।

2. पूर्णता के लिए, मैं रैकेट में है कि रीड-वाक्य रचना इन्फ़िक्स की तरह भाव के लिए हैक उल्लेख करेंगे: (x . define . 1)(define x 1) के रूप में पढ़ा है। (और ऊपर के रूप में, यह हर जगह काम करता है।)

3. अन्यथा, एक रैपिंग मैक्रो का आपका विचार केवल एक चीज है जो आप कर सकते हैं। यह पूरी तरह निराशाजनक नहीं है, हालांकि, आपके कार्यान्वयन के विस्तारक में एक हुक हो सकता है जो आपको ऐसी चीजों को करने की अनुमति दे सकता है - उदाहरण के लिए, रैकेट के पास एक विशेष मैक्रो है जिसे #%module-begin कहा जाता है जो एक पूर्ण मॉड्यूल बॉडी और #%top-interaction को लपेटता है जो अपर्याप्त लपेटता है आरईपीएल पर अभिव्यक्तियां (इन दोनों के दो संदर्भों में परोक्ष जुड़ जाते हैं।) यहाँ एक उदाहरण (मैं रैकेट के define-syntax-rule सादगी के लिए उपयोग कर रहा हूँ) है:

   #lang racket/base 
   
   (provide (except-out (all-from-out racket/base) 
           #%module-begin #%top-interaction) 
        (rename-out [my-module-begin #%module-begin] 
           [my-top-interaction #%top-interaction])) 
   
   (define-syntax infix-def 
       (syntax-rules (:= begin) 
       [(_ (begin E ...)) (begin (infix-def E) ...)] 
       [(_ (x := E ...)) (define x (infix-def E) ...)] 
       [(_ E)    E])) 
   
   (define-syntax-rule (my-module-begin E ...) 
       (#%module-begin (infix-def E) ...)) 
   (define-syntax-rule (my-top-interaction . E) 
       (#%top-interaction . (infix-def E))) 
   

   अगर मैं my-lang.rkt नामक एक फ़ाइल में इस डाल, मैं अब यह के रूप में उपयोग कर सकते हैं इस प्रकार है:

   #lang s-exp "my-lang.rkt" 
   (x := 10) 
   ((fib n) := 
   (done? := (<= n 1)) 
   (if done? n (+ (fib (- n 1)) (fib (- n 2))))) 
   (fib x) 
   

4. हाँ, आप चीजों की एक गुच्छा के साथ सौदा करने की जरूरत है। उपर्युक्त में दो उदाहरण begin अभिव्यक्तियों और हैंडलिंग फ़ंक्शन निकायों को संभालने में हैं। यह स्पष्ट रूप से एक बहुत ही आंशिक सूची है - आप lambda, let आदि के निकायों को भी चाहते हैं।लेकिन यह अभी भी कुछ अंधे मालिश से बेहतर है, क्योंकि यह केवल व्यावहारिक नहीं है क्योंकि आप वास्तव में पहले से ही नहीं बता सकते कि कोड का कुछ यादृच्छिक टुकड़ा कैसे समाप्त होगा। एक आसान उदाहरण के रूप में, इस सरल मैक्रो पर विचार करें:

   (define-syntax-rule (track E) 
       (begin (eprintf "Evaluating: ~s\n" 'E) 
        E)) 
   (x := 1) 
   

5. इस का नतीजा यह है कि एक उचित समाधान के लिए, आप किसी तरह की जरूरत कोड पूर्व विस्तार करने के लिए इतना है कि आप तो यह स्कैन और के साथ सौदा कर सकते हैं आपके प्रत्यारोपण में कुछ ज्ञात मूल रूप हैं।

6. हां, यह सब काम कर रहा है जो मैक्रो विस्तारक करता है, लेकिन चूंकि आप विस्तार कर रहे हैं कि विस्तार कैसे काम करता है, इसके आसपास कोई रास्ता नहीं है। (यह देखने के लिए कि यह एक मौलिक परिवर्तन क्यों है, (if := 1) जैसे कुछ पर विचार करें - क्या यह एक सशर्त अभिव्यक्ति या परिभाषा है? आप कैसे निर्णय लेते हैं कि किसके लिए प्राथमिकता है?) इस कारण से, इस तरह के "प्यारा वाक्यविन्यास" वाली भाषाओं के लिए, एक और लोकप्रिय दृष्टिकोण कोड को सादे एस-अभिव्यक्तियों में पढ़ने और पार्स करना है, और फिर वास्तविक भाषा कार्यान्वयन को सादा कार्य और मैक्रोज़ का उपयोग करने दें।

Answer 2

define को फिर से परिभाषित करना थोड़ा जटिल है। @ एली के उत्कृष्ट स्पष्टीकरण देखें।

दूसरी तरफ, := के साथ set! का उपयोग करने के लिए आप कुछ सरल हैं।

#lang racket 

(module assignment racket 
    (provide (rename-out [app #%app])) 

    (define-syntax (app stx) 
    (syntax-case stx (:=) 
     [(_ id := expr) 
     (identifier? #'id) 
     (syntax/loc stx (set! id expr))]  
     [(_ . more) 
     (syntax/loc stx (#%app . more))]))) 

(require 'assignment) 

(define x 41) 
(x := (+ x 1)) 
(displayln x) 

एक एकल फाइल करने के लिए उदाहरण के रखने के लिए, मैं submodules (रैकेट का प्री-रिलीज़ संस्करण में उपलब्ध) का इस्तेमाल किया:

यहाँ एक छोटा सा उदाहरण है।