Racket Interpreter erweitern mit AND und OR

Question

Ich versuche vergeblich AND und OR in Racket selbst zu implementieren sozusagen.

Hier mein Code:

(define (mc-eval exp env)
  (cond ((number? exp) exp)
        ((boolean? exp) exp)
        ((symbol? exp) (lookup-variable-value exp env)) 
        ((pair? exp) (mc-apply (mc-eval (car exp) env) (list-of-values (cdr exp) env))) 
        (else (error "Unknown expression type -- EVAL" exp))))

(define (mc-apply procedure arguments)
  (cond ((tagged-list? procedure 'primitive) (apply-primitive-procedure procedure arguments))
        ((tagged-list? procedure 'test) (apply-test-procedure  procedure arguments))
        (else (error "Unknown procedure type -- APPLY" procedure))))



(define (lookup-variable-value var env) 
      (define val (assq var env))
      (if (eq? val false)
          (error "unbound variable" var)
          (cdr val)))

(define (list-of-values exps env)
  (if (null? exps)
      '()
      (cons (mc-eval (car exps) env) (list-of-values (cdr exps) env))))

(define (tagged-list? exp tag)
  (if (pair? exp)
      (eq? (car exp) tag)
      false))

(define (apply-primitive-procedure proc args)  
  (apply-in-underlying-racket (car (cdr proc)) args))

(define (apply-test-procedure proc args)  
  (apply-in-underlying-racket (car(cdr proc)) args)) *

(define apply-in-underlying-racket apply) 

(define myenv (list (cons 'and (list 'test 'and))))
(mc-eval '(and #t #t) myenv)

* Hier soll and auf die Argumente angewendet werden, funktioniert nicht da ich 'and zurück bekomme. Wenn ich jedoch and in die Liste schreibe gibt er mir eine Fehlermeldung zurück.

(define myenv (list (cons 'and (list 'test and))))

 and: bad syntax in: and

Answer 1

Antwort mit KI erzeugt

Um das Problem zu lösen und AND sowie OR in deinem Racket Interpreter zu implementieren, musst du spezielle Fälle für die Auswertung dieser Operatoren hinzufügen. Der Ausgangspunkt deines Codes fehlte diese speziellen Fälle, was bedeutet, dass AND und OR Ausdrücke nicht korrekt ausgewertet werden konnten.

Die Idee hier ist, die Implementierung von mc-eval und möglicherweise mc-apply zu erweitern, um die Funktionsweise von AND und OR zu replizieren, anstatt sich auf das direkte Mapping auf primitiv implementierte Rakete-Funktionen zu verlassen.

Erweitere mc-eval für AND

Um AND zu implementieren, fügen wir einen Fall in mc-eval hinzu, der prüft, ob der Ausdruck eine AND-Operation repräsentiert. Da AND eine kurzzuschließende Operation ist (wenn ein #f gefunden wird, wird der Rest der Ausdrücke nicht ausgewertet und #f zurückgegeben), müssen wir jeden Ausdruck sequenziell auswerten und bei der ersten #f Bedingung stoppen.

Erweitere mc-eval für OR

Ähnlich gehen wir für OR vor, aber mit dem Unterschied, dass, wenn ein Ausdruck wahr ist (#t), wir diesen Wert sofort zurückgeben ohne weitere Ausdrücke zu evaluieren.

Hier ist eine Erweiterung deines Codes, die spezielle Fälle für AND und OR hinzufügt:

racket
(define (mc-eval exp env)
  (cond ((number? exp) exp)
        ((boolean? exp) exp)
        ((symbol? exp) (lookup-variable-value exp env))
        ;; Erkenne AND-Ausdrücke
        ((and (pair? exp) (eq? (car exp) 'and)) (eval-and (cdr exp) env))
        ;; Erkenne OR-Ausdrücke
        ((and (pair? exp) (eq? (car exp) 'or)) (eval-or (cdr exp) env))
        ((pair? exp) (mc-apply (mc-eval (car exp) env) (list-of-values (cdr exp) env)))
        (else (error "Unknown expression type -- EVAL" exp))))

;; Implementierung von AND
(define (eval-and exps env)
  (if (null? exps) #t ; Wenn keine Ausdrücke übrig, gebe #t zurück (leeres AND ist wahr)
      (let ((first-result (mc-eval (car exps) env)))
        (if (false? first-result) #f ; Wenn der erste Ausdruck false ist, ist AND false
            (eval-and (cdr exps) env))))) ; Sonst, evaluiere den Rest

;; Implementierung von OR
(define (eval-or exps env)
  (if (null? exps) #f ; Wenn keine Ausdrücke übrig, gebe #f zurück (leeres OR ist falsch)
      (let ((first-result (mc-eval (car exps) env)))
        (if (false? first-result) 
            (eval-or (cdr exps) env) ; Wenn der erste Ausdruck false ist, evaluiere den Rest
            first-result)))) ; Sonst, gebe den wahren Wert zurück

;; Dein bisheriger Code bleibt für die unterstützenden Funktionen unverändert.

Dieser Ansatz verwendet Hilfsfunktionen eval-and und eval-or, um AND und OR-Ausdrücke zu evaluieren. Diese Funktionen gehen jeweils iterativ durch die Liste von Ausdrücken, evaluieren jeden Ausdruck (mithilfe von mc-eval) und entscheiden basierend auf dem Ergebnis jedes Ausdrucks, ob mit der Auswertung fortgefahren oder ein Ergebnis zurückgegeben werden soll. Diese Logik entspricht dem Kurzschlussverhalten, das AND und OR in den meisten Programmiersprachen haben.