Clojure for

 

• for

(for seq-exprs body-expr)

 

列表内涵逻辑，接收一组 ( 一个或多个 ) 绑定 form( binding-form )/ 集合表达式（ collection-expr ）对，每个绑定 form( binding- form )/ 集合表达式（ collection-expr ）对后面跟着 0 个或多个 modifier ，最后获得一个求值表达式表示的惰性序列。

 

这里的 seq-exprs 形式为：

[ binding-form collection-expr

  modifier modifier modifier … ]

 

<!--[if ppt]--> •<!--[endif]--> 或者多个的表现形式为： 

[ binding-form collection-expr

  modifier modifier modifier …

  binding-form collection-expr

  modifier modifier modifier …

  …

  binding-form collection-expr

  modifier modifier modifier … ]

 

<!--[if ppt]--> •<!--[endif]--> 例子： 

user=> (for [x [0 1 2 3 4 5]

  #_=>       :let [y (* x 3)]

  #_=>       :when (even? y)]

  #_=>   y)

(0 6 12)

 

user=> (for [x '(0 1 2 3 4 5)

  #_=>     :let [y (* x 3)]

  #_=>     :when (even? y)]

  #_=>  y)

(0 6 12)

<!--[if ppt]--> •<!--[endif]-->

 

再来个例子：

user=> (for [x [0 1 2 3 4 5]

  #_=>       y [0 1 2 3]

  #_=>       :let [z (* x y)]]

  #_=>   z)

(0 0 0 0 0 1 2 3 0 2 4 6 0 3 6 9 0 4 8 12 0 5 10 15)

 

 

再来个例子：

user=> (for [x [0 1 2 3 4 5]

  #_=>       :let [x (* x 2)]

  #_=>       y [0 1 2 3]

  #_=>       :let [z (* x y)]]

  #_=>   z)

(0 0 0 0 0 2 4 6 0 4 8 12 0 6 12 18 0 8 16 24 0 10 20 30)

 

 

 

 类似的还有loop-when-recur:

(loop [bindings*] exprs*)

 

(when test & body)

 

(recur exprs*)

 

遍历0-20数字：[0,20)

=> (loop [i 0]
#_=>  (when (< i 20)
#_=>   (println i)
#_=>   (recur (inc i))))

 

 

=> (loop [i 0]
#_=>  (when (< i 20)
#_=>   (loop [j 0]
#_=>    (when (< j 20)
#_=>     (println "(", i, j, ")")
#_=>     (recur (inc j))))
#_=>   (recur (inc i))))

 

 

 

(define tree (list 0 
               (list (list #'a' -1) 
                 (list #'z' 0) 
                 (list #'c' 0) 
                 (list #'x' 0) 
                 (list #'e' 0) 
                 (list #'f' 0) 
                 (list #'g' 0) 
                 (list #'h' 1) 
                 (list #'i' 1) 
                 (list #'j' 1) 
                 (list #'k' 1) 
                 (list #'l' 2) 
                 (list #'m' 2) 
                 (list #'n' 3) 
                 (list #'o' 3) 
                 (list #'p' 3) 
                 (list #'q' 5) 
                 (list #'r' 6) 
                 (list #'s' 6) 
                 (list #'t' 6) 
                 (list #'u' 6) 
                 (list #'v' 6) 
                 (list #'w' 6) 
                 (list #'d' 6) 
                 (list #'y' 6) 
                 (list #'b' 6))))
                 
(define iterate 
  (lambda 
    (t)
    (let* ((t0 (car (cdr t))) 
           (i (car t)) 
           (node (list-ref t0 i))) 
      
      
      ;(display (car node))
      ;; search the children of node, which the parent is node, with parent index is i
      (let ((vn (list (list node i))) 
            (ii 0)
            (nvn (list))) 
        
        (do () 
          ((<= (length vn) 0))
          (map (lambda (x) 
                 ;(display "searched node:")
                 ;(newline)
                 (display (list-ref x 0)) 
                 (newline)
                 (map (lambda (z) 
                        (if (= (list-ref z 1) (list-ref x 1))
                          (set! nvn (cons (list z ii) nvn)))
                        (set! ii (+ ii 1))) 
                      t0)
                 (set! ii 0)
               ) vn)
          (set! vn (reverse nvn))
          (set! nvn (list))
          ;(display vn) (newline)
          ))
      )))

 

> (iterate tree)
(a -1)
(z 0)
(c 0)
(x 0)
(e 0)
(f 0)
(g 0)
(h 1)
(i 1)
(j 1)
(k 1)
(l 2)
(m 2)
(n 3)
(o 3)
(p 3)
(q 5)
(r 6)
(s 6)
(t 6)
(u 6)
(v 6)
(w 6)
(d 6)
(y 6)
(b 6)
$3 = unspecified