You shouldn't need funcall
in your common lisp code, but the way you defined your function requires it. You have
(let ((c 0))
(defun my-counter! ()
(lambda ()
(setf c (+ 1 c))
c)))
defun
already defines a function; you don't need to also wrap the function body in a lambda
. This definition allows you to avoid the funcall
:
(let ((c 0))
(defun my-counter! ()
(setf c (+ 1 c))
c))
Though it's worth knowing that unlike in scheme, common lisp will return the value after a setf
. There's also a convenience macro called incf
that increments variables so you can write the whole thing like this:
(let ((c 0))
(defun my-counter! ()
(incf c)))
And your other question: Why the different placing of the let?
In common lisp, defun
, defvar
, defparameter
, defmacro
, ... all affect global scope, no matter where they appear. scheme's define
does not affect global scope; its effects are only visible locally. This means that a defun
inside of a let
body still creates a globally accessible function that closes over the variables defined in the let
bindings. Scheme, by contrast, needs to have a define
at global level (or at least outside the let
) but the function body still needs to close over the let
variables.