Recurring with anonymous functions Common Lisp vs. Scheme

1
votes

I'm working through the Little Schemer and I'm trying to convert all of the answers into Common Lisp. In chapter 8, anonymous functions are discussed, as well as returning anonymous functions. For example:

(define insertL-f
    (lambda (test?)
        (lambda (new old l)
            (cond
                ((null? l) (quote ()))
                ((test? (car l) old) (cons new l)))
                (else (cons (car l) ((insertL-f test?) new old (cdr l))))))))

My code:

(defun insertL-f (test)
    (lambda (new old l)
        (cond
            ((null l) '())
            ((funcall test (car l) old) (cons new l))
            (t (cons (car l) (insertL-f test) new old (cdr l))))))

The problem is the last line of the second block of code. I get the error "too many arguments for cons" but I can't add an extra pair of parentheses like the Scheme code does. Is this style of recursion just not possible in Common Lisp?

2
schemecommon-lisp

2 Answers

2
votes
(defun insertL-f (test)
  (lambda (new old l)
    (cond
     ((null l) '())
     ((funcall test (car l) old) (cons new l))
     (t (cons (car l)
              (funcall (insertL-f test)
                       new
                       old
                       (cdr l)))))))
2
votes

insertL-f returns a function and in your Scheme version you apply it while in CL have flattened the list instead if applying it with funcall However it seems like the function that is to be returned is equal to the one it fetches so you can cache it by defining it locally with labels:

(defun insert-l-f (test)
  (labels ((func (new old l)
             (cond
               ((null l) '())
               ((funcall test (car l) old) (cons new l))
               (t (cons (car l) (func new old (cdr l)))))))
    #'func))

The same in Scheme using local define (which really is aletrec with flatter syntax):

(define (insert-l-f test?)
  (define (func new old l)
    (cond
      ((null? l) (quote ()))
      ((test? (car l) old) (cons new l)))
      (else (cons (car l) (func new old (cdr l)))))
  func)