CODEWITHSUNDEEP
common-lisp
Terry
Terry

Reputation: 1232

Why does the Common Lisp's apply function give a different result?

When I try this code on Emacs SLIME, the apply function gives a different result. Isn't it supposed to give the same result? Why does it give a different result? Thanks.

CL-USER> (apply #'(lambda (n)
             (cons n '(b a))) '(c)) 

(C B A)

CL-USER> (cons '(c) '(b a)) 

((C) B A)

Upvotes: 1

Views: 450

Answers (3)

Sylwester
Sylwester

Reputation: 48745

There is a symmetry between &rest arguments in functions and apply.

(defun function-with-rest (arg1 &rest argn)
  (list arg1 argn))

(function-with-rest 1)         ; ==> (1 ())
(function-with-rest 1 2)       ; ==> (1 (2))
(function-with-rest 1 2 3 4 5) ; ==> (1 (2 3 4 5))

Imagine we want to take arg1 and argn and use it the same way with a function of our choice in the same manner as function-with-rest. We double the first argument and sum the rest.

(defun double-first-and-sum (arg1 &rest argn)
  (apply #'+ (* arg1 2) argn)) 

(double-first-and-sum 1 1)     ; ==> 3
(double-first-and-sum 4 5 6 7) ; ==> 26

The arguments between the function and the list of "rest" arguments are additional arguments that are always first:

(apply #'+ 1 '(2 3 4)) ; ==> (+ 1 2 3 4)
(apply #'+ 1 2 3 '(4)) ; ==> (+ 1 2 3 4)

This is very handy since often we want to add more arguments than we are passed (or else we could just have used the function apply is using in the first place. Here is something called zip:

(defun zip (&rest args)
  (apply #'mapcar #'list args))

So what happens when you call it like this: (zip '(a b c) '(1 2 3))? Well args will be ((a b c) (1 2 3)) and the apply will make it become (mapcar #'list '(a b c) '(1 2 3)) which will result in ((a 1) (b 2) (c 3)). Do you see the symmetry?

Thus you could in your example you could have done this:

(apply #'(lambda (&rest n)
            (cons n '(b a))) '(c)) 
;==> ((c) b a)

(apply #'(lambda (&rest n)
            (cons n '(b a))) '(c d e)) 
;==> ((c d e) b a)

Upvotes: 2

Rainer Joswig
Rainer Joswig

Reputation: 139261

CL-USER 51 > (cons '(c) '(b a))
((C) B A)

CL-USER 52 > (apply #'(lambda (n)
                        (cons n '(b a)))
                    '(c))
(C B A)

Let's use FUNCALL:

CL-USER 53 > (funcall #'(lambda (n)
                          (cons n '(b a)))
                      '(c))
((C) B A)

See also what happens when we apply a two element list:

CL-USER 54 > (apply #'(lambda (n)
                        (cons n '(b a)))
                    '(c d))

Error: #<anonymous interpreted function 40600008E4> got 2 args, wanted 1.

Upvotes: 2

Jay
Jay

Reputation: 9656

cons takes an element and a list as arguments. So (cons 'x '(a b c d)) will return (x a b c d).

apply takes a function and a list of arguments -- but the arguments will not be passed to the function as a list! They will be split and passed individually:

(apply #'+ '(1 2 3))

6

(actually, it takes one function, several arguments, of which the last must be a list -- this list will be split and treated as "the rest of the arguments to the function". try, for example, (apply #'+ 5 1 '(1 2 3)), which will return 12)

Now to your code:

The last argument you passed to the apply function is '(c), a list with one element, c. Apply will treat it as a list of arguments, so the first argument you passed to your lambda-form is c.

In the second call, you passed '(c) as first argument to cons. This is a list, which was correctly included in the first place of the resulting list: ( (c) b a).

The second call would be equivalent to the first if you did

(cons 'c '(b a))

(c b a)

And the first call would be equivalent to the second if you did

(apply #'(lambda (n) (cons n '(b a))) '((c)))

((c) b a)

Upvotes: 6

Related Questions