CL中的辅助嵌套函数

Question

我曾经在Haskell中编写嵌套的辅助函数（btw，偶然使用的外部函数参数和递归函数），如下所示（loop）：

sum a b = let
  loop s i = if i > b then s else loop (s + i) (i + 1)
  in loop 0 a

Common Lisp中最清晰的模拟是什么？

我在这里搜索并发现一些讨论集中在从函数返回函数（以及在尝试调用这样的“返回”函数时可能出现的问题），就我所见，情况并非完全相同。 / p>

Answer 1

Labels用于定义本地函数。

CL-USER> (defun thing (x)
           (labels ((helper (y) (loop for i from x to y collect i)))
             (helper 5)))
THING
CL-USER> (thing 1)
(1 2 3 4 5)

它有点像函数的let *语句，因为您可以定义多个本地函数。 所以这里我们有帮助和双重定义。

(defun thing (x)
   (labels ((helper (y) (loop for i from x to y collect i))
            (double-it (num) (* 2 num)))
     (helper (double-it 10))))

你也可以使用lambdas。在这种情况下，这是相当整洁的，但在这种情况下我仍然更喜欢标签以便于阅读。

CL-USER> (defun another-test (x)
           (funcall #'(lambda (y) (loop for i from x to y collect i)) 10))
ANOTHER-TEST

CL-USER> (another-test 2)
(2 3 4 5 6 7 8 9 10)

标签也可以递归使用：

CL-USER> (defun test-recurse (x)
           (labels ((rec-list (count) 
                      (when (< count x) 
                        (cons count (rec-list (+ 1 count))))))
             (rec-list 0)))
TEST-RECURSE
CL-USER> (TEST-RECURSE 10)
(0 1 2 3 4 5 6 7 8 9)

希望它有所帮助！

Answer 2

如果您的Lisp优化尾调用

，则标记并命名

就像玩“愚蠢的Lisp技巧”一样，我会在Scheme中指出，模拟

sum a b = let
  loop s i = if i > b then sum else loop (s + i) (i + 1)
  in loop 0 a

是letrec或​​名为let：

(define (sum a b)
  (letrec ((loop (lambda (s i)
                   (if (> i b)
                       s
                       (loop (+ s i) (+ i 1))))))
    (loop 0 a)))

(define (sum a b)
  (let loop ((s 0) (i a))
    (if (> i b)
        s
        (loop (+ s i) (+ i 1)))))

Letrec，因为Scheme是一个Lisp-1，它为您提供labels的功能，Baggers described。命名let可以在Common Lisp中使用labels：

周围的宏来完成

(defmacro named-let (name bindings &body body)
  `(labels ((,name ,(mapcar 'first bindings)
              ,@body))
     (,name ,@(mapcar 'second bindings))))

(pprint (macroexpand
 '(named-let loop ((s 0) (i a))
   (if (> i b)
       s
       (loop (+ s i) (+ i 1))))))

;; (LABELS ((LOOP (S I)
;;            (IF (> I B)
;;                S
;;                (LOOP (+ S I)
;;                      (+ I 1)))))
;;   (LOOP 0 A))

Do＆Do *应该在任何地方都有效

但是，尾部调用不一定在Common Lisp中进行优化，因此迭代的这种递归并不常见。迭代模拟是do：

(defun sum (a b)
  (do ((s 0 (+ s i))
       (i a (+ i 1)))
      ((> i b) s)))

循环也是如此

您也可以使用loop，但它更冗长（如果您熟悉do，也可能更具可读性：

(defun sum (a b)
  (loop
     for s = 0 then (+ s i)
     for i = a then (+ i 1)
     when (> i b) return s))