How is “+” Implemented in Common Lisp Using Special Operators/Forms

  • A+

In On Lisp (page 9), one can find the following claim:

Functions are the building-blocks of Lisp programs. They are also the building-blocks of Lisp. In most languages the + operator is something quite different from user-defined functions. But Lisp has a single model, function application, to describe all the computation done by a program. The Lisp + operator is a function, just like the ones you can define yourself. In fact, except for a small number of operators called special forms, the core of Lisp is a collection of Lisp functions. What’s to stop you from adding to this collection? Nothing at all: if you think of something you wish Lisp could do, you can write it yourself, and your new function will be treated just like the built-in ones.

My question is how exactly would something like a + operator be implemented using the following special operators? Or are there actually more operators being used and Graham is just being imprecise and dramatic?

block      let*                  return-from       catch      load-time-value       setq              eval-when  locally               symbol-macrolet   flet       macrolet              tagbody           function   multiple-value-call   the               go         multiple-value-prog1  throw             if         progn                 unwind-protect    labels     progv                                   let        quote     

Is there a way to see source code for these functions?

He's not saying every function is implemented in terms of these special forms.

He's saying + (like every other function) is a function:

  • It can be called using the normal syntax (+ x y z) (where + is the function and x, y, z the arguments).
  • The arguments will be evaluated first: (f (g) (h)) will call both g and h before calling f, even if f happens to be +.
  • You can pass it around like any other function and call it through funcall and apply: (let ((x #'+)) (funcall x 1 2 3)) is 6.

The point is that these properties do not necessarily hold for special forms. if does not evaluate all of its arguments first; you can't take a reference to let and call it indirectly; etc.

Of course that still leaves the door open for "compiler magic". At some point + has to perform low-level operations that depend e.g. on how numbers are implemented. The details will look different depending on your Lisp compiler.


:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: