Clojure Какие интересные концепции есть в Лиспе?

defn f (i) (cond (< i 2) 1 (* i (f (- i 1))))
OK
defn g (i a) (cond (< i 2) a (g (- i 1) (* i a)))
OK
tray f 3
  1 <- (f 3)
    2 <- f
    2 -> (lambda (i) (cond (< i 2) 1 (* i (f (- i 1)))))
    2 <- (cond (< i 2) 1 (* i (f (- i 1))))
      3 <- (< i 2)
        4 <- i
        4 -> 3
      3 -> false
      3 <- (* i (f (- i 1)))
        4 <- i
        4 -> 3
        4 <- (f (- i 1))
          5 <- f
          5 -> (lambda (i) (cond (< i 2) 1 (* i (f (- i 1)))))
          5 <- (- i 1)
            6 <- i
            6 -> 3
          5 -> 2
          5 <- (cond (< i 2) 1 (* i (f (- i 1))))
            6 <- (< i 2)
              7 <- i
              7 -> 2
            6 -> false
            6 <- (* i (f (- i 1)))
              7 <- i
              7 -> 2
              7 <- (f (- i 1))
                8 <- f
                8 -> (lambda (i) (cond (< i 2) 1 (* i (f (- i 1)))))
                8 <- (- i 1)
                  9 <- i
                  9 -> 2
                8 -> 1
                8 <- (cond (< i 2) 1 (* i (f (- i 1))))
                  9 <- (< i 2)
                    10 <- i
                    10 -> 1
                  9 -> true
                8 -> 1
              7 -> 1
            6 -> 2
          5 -> 2
        4 -> 2
      3 -> 6
    2 -> 6
  1 -> 6
6
tray g 3 1
  1 <- (g 3 1)
    2 <- g
    2 -> (lambda (i a) (cond (< i 2) a (g (- i 1) (* i a))))
    2 <- (cond (< i 2) a (g (- i 1) (* i a)))
      3 <- (< i 2)
        4 <- i
        4 -> 3
      3 -> false
      3 <- (g (- i 1) (* i a))
        4 <- g
        4 -> (lambda (i a) (cond (< i 2) a (g (- i 1) (* i a))))
        4 <- (- i 1)
          5 <- i
          5 -> 3
        4 -> 2
        4 <- (* i a)
          5 <- i
          5 -> 3
          5 <- a
          5 -> 1
        4 -> 3
      3 -> FUNCALL: {a=3, i=2}
    2 -> FUNCALL: {a=3, i=2}
    2 <- (cond (< i 2) a (g (- i 1) (* i a)))
      3 <- (< i 2)
        4 <- i
        4 -> 2
      3 -> false
      3 <- (g (- i 1) (* i a))
        4 <- g
        4 -> (lambda (i a) (cond (< i 2) a (g (- i 1) (* i a))))
        4 <- (- i 1)
          5 <- i
          5 -> 2
        4 -> 1
        4 <- (* i a)
          5 <- i
          5 -> 2
          5 <- a
          5 -> 3
        4 -> 6
      3 -> FUNCALL: {a=6, i=1}
    2 -> FUNCALL: {a=6, i=1}
    2 <- (cond (< i 2) a (g (- i 1) (* i a)))
      3 <- (< i 2)
        4 <- i
        4 -> 1
      3 -> true
      3 <- a
      3 -> 6
    2 -> 6
  1 -> 6
6

(iter (for i from 1 to 10) (collecting i))
 
==> (1 2 3 4 5 6 7 8 9 10)
 
(iter (for i from 10 to 1 by -1) (collecting i))
 
==> (10 9 8 7 6 5 4 3 2 1)
 
(iter (for i from 10 to 1 by -1) 
      (for j from 1 to 10) (collecting (list i j)))
 
==> ((10 1) (9 2) (8 3) (7 4) (6 5) (5 6) (4 7) (3 8) (2 9) (1 10))
 
(iter (for i from 1 to 20) (summing i))
 
==> 210
 
(iter (for i from 1 to 20) (multiplying i))
 
==> 2432902008176640000
 
(iter (for a in '(1 4 -6 7 8 12 5)) (maximizing a)) 
 
==> 12
 
(iter (for a in '(1 4 -6 7 8 12 5)) (minimizing a)) 
 
==> -6

(iter (for i from 1 to 10) (collecting i at start)) 
 
==> (10 9 8 7 6 5 4 3 2 1)
 
(iter (for i from 1 to 10) (collecting i at end)) 
 
==> (1 2 3 4 5 6 7 8 9 10)

(loop for n downfrom 10 to 0 collect n)

(loop for i upto 10 collecting i)
(loop for i upto 10 collect i)

for (key value) in-hashtable table

;; мутабельность + не нужная особая форма, оставил для баловства
(def i 0) (while (< i 5) (print i " ") (set! i (+ 1 i)))
0 1 2 3 4 OK
;; мутабельность + функция
(def i 0) (defn f1 () (cond (< i 5) ((print i " ") (set! i (+ 1 i)) (f1)))) (f1)
0 1 2 3 4 OK
;; мутабельность + макрос
(def i 0) (defmacro m1 () (cond (< i 5) ((print i " ") (set! i (+ 1 i)) (m1)))) (m1)
0 1 2 3 4 OK
;; иммутабельность + функция
(defn f2 (i) (cond (< i 5) ((print i " ") (f2 (+ 1 i))))) (f2 0)
0 1 2 3 4 OK
;; иммутабельность + макрос
(defmacro m2 (i) (cond (< i 5) ((print i " ") (m2 (+ 1 i))))) (m2 0)
0 1 2 3 4 OK

(defn foldl (f a l)
    (cond (null? l) a
          (foldl f (f (car l) a) (cdr l)) ))
OK
foldl + 0 '(1 2 3 4 5)
15

(def h-m (new "java.util.HashMap"))
OK
(def h-m-put (method h-m "put" "java.lang.Object" "java.lang.Object"))
OK
invoke h-m h-m-put 0 "abc"
OK
invoke h-m h-m-put 1 "def"
OK
h-m
{0=abc, 1=def}
(def h-m-get (method h-m "get" "java.lang.Object"))
OK
invoke h-m h-m-get 1
def

(def exp0  (cons '* (cons 'sin 1.1) (cons 'cos 2.03) nil) )
OK
exp0
(* (sin 1.1) (cos 2.03))
eval exp0
-0.3950137734738094
list-ref 2 exp0
(cos 2.03)
def exp1 (mapa (lambda (x) (cond (eq? x 'cos) 'sin x)) exp0)
OK
exp1
(* (sin 1.1) (sin 2.03))
eval exp1
0.7988833941155963
def exp2 (read)
(* (sin 1.1) (sin 2.03))
OK
exp2
(* (sin 1.1) (sin 2.03))
eval exp2
0.7988833941155963