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

Формулировка задачи:

В смысле, что бы еще попробовать реализовать. На Call-CC все засматриваюсь, но для начала надо понять что это вообще такое. F-expr (функции с ленивыми аргументами) - а нужны ли они? Если значения входящих аргументов можно заквотировать. Окружение, как объект первого класса? Но ведь можно его захватить замыканием и использовать когда надо.

Пока балуюсь подобными вещами, но это несложно:

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

Решение задачи: «Какие интересные концепции есть в Лиспе?»

Листинг программы

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

Объяснение кода листинга программы

В данном коде используется цикл loop, который выполняет блок кода для каждого значения переменной i от 0 до 10.
В первом примере цикла loop, переменная i будет собираться (collected) в результате выполнения цикла.
Во втором примере цикла loop, переменная i также будет собираться в результате выполнения цикла, но на этот раз без присвоения значения.
В обоих примерах цикл loop выполняется 10 раз, перебирая значения i от 0 до 9.
В обоих примерах переменная i является неявной (implicit) переменной, которая автоматически создается и используется в цикле loop.
В обоих примерах переменная i не является аккумулятором (accumulator), поскольку ее значение не сохраняется между итерациями цикла.
В обоих примерах переменная i не является счетчиком (counter), поскольку она не инкрементируется или декрементируется внутри цикла.
В обоих примерах переменная i не является индексом (index), поскольку она не используется для доступа к элементам массива или коллекции.
В обоих примерах переменная i не является условием (condition), поскольку она не используется для проверки условия в цикле.
В обоих примерах переменная i не является результатом (result), поскольку она не используется для возврата значения из цикла.
В обоих примерах переменная i не является параметром (parameter), поскольку она не передается в функцию или метод.
В обоих примерах переменная i не является локальной (local) переменной, поскольку она не объявлена внутри функции или метода.
В обоих примерах переменная i не является глобальной (global) переменной, поскольку она не объявлена вне любой функции или метода.
В обоих примерах переменная i не является переменной окружения (environment variable), поскольку она не используется для доступа к переменным операционной системы.
В обоих примерах переменная i не является переменной контекста (context variable), поскольку она не используется для доступа к переменным, специфичным для определенного контекста.
В обоих примерах переменная i не является переменной управления (control variable), поскольку она не используется для управления потоком выполнения программы.
В обоих примерах переменная i не является переменной-счетчиком (counter variable), поскольку она не используется для подсчета или инкрементации.
В обоих примерах переменная i не является переменной-массивом (array variable), поскольку она не используется для хранения или доступа к элементам массива.
В обоих примерах переменная i не является переменной-список (list variable), поскольку она не используется для хранения или доступа к элементам списка.
В обоих примерах переменная i не является переменной-строкой (string variable), поскольку она не используется для хранения или доступа к элементам строки.