clojure interpeter中循环的Java风格？

我在clojure有一个基本的口译员。现在我需要实施

for (initialisation; finish-test; loop-update) {
statements
}  

在我的翻译里面。我将附上我目前获得的翻译代码。感谢您的帮助

翻译

(declare interpret make-env) ;; 

(def do-trace false) ;; 

;; simple utilities

(def third ; return third item in a list
 (fn [a-list]
  (second (rest a-list))))

(def fourth ; return fourth item in a list
 (fn [a-list]
  (third (rest a-list))))

(def run ; make it easy to test the interpreter
 (fn [e]
  (println "Processing: " e)
  (println "=> " (interpret e (make-env)))))

;; for the environment

(def make-env
  (fn []
    '()))

(def add-var
  (fn [env var val]
    (cons (list var val) env)))

(def lookup-var
  (fn [env var]
    (cond (empty? env) 'error
          (= (first (first env)) var) (second (first env))
          :else (lookup-var (rest env) var))))

;; -- define numbers

(def is-number?
 (fn [expn]
  (number? expn)))

(def interpret-number
 (fn [expn env]
  expn))

;; -- define symbols

(def is-symbol?
  (fn [expn]
    (symbol? expn)))

(def interpret-symbol
  (fn [expn env]
    (lookup-var env expn)))

;; -- define boolean

(def is-boolean?
  (fn [expn]
    (or
      (= expn 'true)
      (= expn 'false))))

(def interpret-boolean
  (fn [expn env]
    expn))

;; -- define functions

(def is-function?
  (fn [expn]
    (and 
      (list? expn)
      (= 3 (count expn))
      (= 'lambda (first expn)))))

(def interpret-function 
  (fn [expn env]
    expn))

;; -- define addition

(def is-plus?
 (fn [expn]
  (and 
   (list? expn)
   (= 3 (count expn))
   (= '+ (first expn)))))

(def interpret-plus
 (fn [expn env]
  (+ 
   (interpret (second expn) env)
   (interpret (third expn) env))))

;; -- define subtraction

(def is-minus?
 (fn [expn]
  (and 
   (list? expn)
   (= 3 (count expn))
   (= '- (first expn)))))

(def interpret-minus
 (fn [expn env]
  (- 
   (interpret (second expn) env)
   (interpret (third expn) env))))

;; -- define multiplication

(def is-times?
 (fn [expn]
  (and 
   (list? expn)
   (= 3 (count expn))
   (= '* (first expn)))))

(def interpret-times
 (fn [expn env]
  (* 
   (interpret (second expn) env)
   (interpret (third expn) env))))

;; -- define division

(def is-divides?
 (fn [expn]
  (and 
   (list? expn)
   (= 3 (count expn))
   (= '/ (first expn)))))

(def interpret-divides
 (fn [expn env]
  (/ 
   (interpret (second expn) env)
   (interpret (third expn) env))))

;; -- define equals test

(def is-equals?
  (fn [expn]
    (and
      (list? expn)
      (= 3 (count expn))
      (= '= (first expn)))))

(def interpret-equals
  (fn [expn env]
    (=
      (interpret (second expn) env)
      (interpret (third expn) env))))

;; -- define greater-than test

(def is-greater-than?
  (fn [expn]
    (and
      (list? expn)
      (= 3 (count expn))
      (= '> (first expn)))))

(def interpret-greater-than
  (fn [expn env]
    (>
      (interpret (second expn) env)
      (interpret (third expn) env))))

;; -- define not

(def is-not?
  (fn [expn]
    (and 
      (list? expn)
      (= 2 (count expn))
      (= 'not (first expn)))))

(def interpret-not
  (fn [expn env]
    (not
      (interpret (second expn) env))))

;; -- define or

(def is-or?
  (fn [expn]
    (and
      (list? expn)
      (= 3 (count expn))
      (= 'or (first expn)))))

(def interpret-or
  (fn [expn env]
    (or
      (interpret (second expn) env)
      (interpret (third expn) env))))

;; -- define and

(def is-and?
  (fn [expn]
    (and
      (list? expn)
      (= 3 (count expn))
      (= 'and (first expn)))))

(def interpret-and
  (fn [expn env]
    (and
      (interpret (second expn) env)
      (interpret (third expn) env))))

;; -- define with

(def is-with?
  (fn [expn]
    (and
      (list? expn)
      (= 3 (count expn))
      (= 'with (first expn)))))

(def interpret-with
  (fn [expn env]
    (interpret (third expn)
               (add-var env 
                        (first (second expn))
                        (interpret (second (second expn)) env)))))

;; -- define if

(def is-if?
  (fn [expn]
    (and
      (list? expn)
      (= 4 (count expn))
      (= 'if (first expn)))))

(def interpret-if
  (fn [expn env]
    (cond (interpret (second expn) env) (interpret (third expn) env)
          :else                         (interpret (fourth expn) env))))

;; -- define function-application

(def is-function-application?
  (fn [expn env]
    (and
      (list? expn)
      (= 2 (count expn))
      (is-function? (interpret (first expn) env)))))

(def interpret-function-application
  (fn [expn env]
    (let [function (interpret (first expn) env)]
      (interpret (third function)
                 (add-var env
                          (first (second function))
                          (interpret (second expn) env))))))

；；口译员自己

---

正如您可能已经发现的，clojure没有for，尽管您可以实现一个循环。您只需使用如下简单的递归调用：

(loop [var inital-value]
  ;; statements (regarding "var")
  (when-not finish-test
    (recur update-var)))

   (with (loop (lambda (i n)
                 (if (or (< i n) (= i n))
                     (begin (print i) (loop (+ 1 i) n))))
         (loop 1 10))

---

只要finish测试的计算结果为false，recur将使用update var的值作为新变量返回到循环开始处的执行。正如您可能已经发现的，clojure没有for，尽管您可以实现一个循环。您只需使用如下简单的递归调用：

(loop [var inital-value]
  ;; statements (regarding "var")
  (when-not finish-test
    (recur update-var)))

   (with (loop (lambda (i n)
                 (if (or (< i n) (= i n))
                     (begin (print i) (loop (+ 1 i) n))))
         (loop 1 10))

---

只要finish测试的结果为false，recur就会使用update var的值作为新的变量将执行返回到循环的开始处。请参见

我不完全确定解释语言的语法是什么，但看起来您已经实现了lambda，这是您真正需要的语法糖。可以使用lambda实现for循环之类的功能

您真正需要做的就是添加一个for handler函数，该函数解析如下表达式：

(for (i 0 (< 1 10))
  (print i))

本质上，您需要在递归函数的应用程序中扩展for表达式。上面的代码定义了一个名为loop的函数，并立即调用它。外部lambda强制整个表达式立即运行

如果你想了解更多关于这方面的细节，在《构建元循环解释器的优秀教程》中有一章，有关于实现内部定义的讨论，也有关于他们所谓的派生表达式的讨论，基本上类似于糖

---

祝你好运

我不完全确定解释语言的语法是什么，但看起来您已经实现了lambda，这是获得大量语法支持所需要的。可以使用lambda实现for循环之类的功能

您真正需要做的就是添加一个for handler函数，该函数解析如下表达式：

(for (i 0 (< 1 10))
  (print i))

本质上，您需要在递归函数的应用程序中扩展for表达式。上面的代码定义了一个名为loop的函数，并立即调用它。外部lambda强制整个表达式立即运行

如果你想了解更多关于这方面的细节，在《构建元循环解释器的优秀教程》中有一章，有关于实现内部定义的讨论，也有关于他们所谓的派生表达式的讨论，基本上类似于糖

---

祝你好运

你想干什么？要在clojure中创建for循环，还是要在clojure中为您自己的自定义语言创建解释器？这不是对您的特定问题的回答，不确定它是什么，但请查看multimethods。他们应该很好地摆脱你那里的那种单一的康德。你想做什么？要在clojure中创建for循环，还是要在clojure中为您自己的自定义语言创建解释器？这不是对您的特定问题的回答，不确定它是什么，但请查看multimethods。Clojure有一个for宏，它有一个for宏作为列表理解。我没有提到它，因为它与asker请求的Java风格的FOR循环完全不同，我不想混淆这个问题。我说的是clojure没有for循环，clojure有一个for宏，它有一个for宏，用作列表理解。我没有提到它，因为它与asker请求的Java风格的FOR循环完全不同，我不想混淆这个问题。我说的是clojure没有for循环。在clojure中，lambda是fn。我知道，但在OP的解释语言中，关键字是lambda。上面所有的扩展代码都会被解释，没有一个是Clojure。在Clojure中，lambda是fn。我知道，但在OP的解释语言中，关键字是lambda。上面所有扩展的代码都将被解释，没有一个是Clojure。