Lambda function for optimization in Lisp

Question

Consider the following function definition in Lisp:

(defun f (l)
    (cond
        ((null l) 0)
        ((> (f (car l)) 2) (+ (car l) (f (cdr l))))
        (T (f (car l)))
    )
)

Give a solution to avoid the double recursive call (f (car l)). You will not use set,setq,setf. Justify the answer.

This is how I proceeded:

(defun f2 (l)
    (cond
        ((null l) 0)
        ((lambda (x) 
           (cond
                ((> x 2) (+ (car l) (f2 (cdr l))))
                (T x)
           )
         ) (f2 (car l)) 
        )
    )
)

I want to hear some opinions. By the way, it's just an exercise. This function is not suposed to do something coherent.

Answer 1

Here I tried to reformat your code in a Lisp way:

(defun f2 (l)
  (cond
    ((null l) 0)
    ((lambda (x)
       (> x 2)
       (+ (car l) (f (cdr l)))
       (T (f (car l))))
     (f (car l)))))

The use of lambda is fine to compute a value once and bind it to a variable, and it in fact you can merge the two last original cases of cond inside the lambda.

But, there are multiple problems which makes the code incorrect.

• recursive calls should call f2, not f
• you can't move the test clauses of the cond inside the lambda, this is not how the Lisp syntax works. You probably only need an if, but if missed a cond inside the lambda for the (> x 2) case.
• inside the lambda, do not call (f2 (car l)) since the whole intent of using an intermediate function is to use the parameter x (this is about the (T (f (car l))) form which looks like a cond clause but is interpreted as a function call)