Ytukyg

I am new to lisp and I had a question about this LISP syntax:

(defparameter *binary-operators*

  '((+ 1 +) (- 1 -) (* 2 *)

    (x 2 *) (/ 2 %) (^ 3 expt)))

From what I understand, defparameter allows the binary operators variable to be reassigned but I am confused as to how the (+ 1 +), (- 1 -) ... are evaluated. I know in LISP that (+ 4 6) would result in (4 + 6) = 10 but the same logic would result in (1 + +) which does not make sense. What does the above syntax represent?

In Common Lisp,

(defparameter name initial-value)

(see the manual) introduces a new special (global) variable name with a new value, given by evaluating initial-value.

So, in the example above, the special variable *binary-operators* is assigned a list of triples, each of them constitued by a symbol, a number, and another symbol. In other words, it assigns some data to a variable, and not, as you were thinking, redefines the syntax of the language.

Guessing from the values present in the list, this seems a variable that is assigned a list of arithmetic operators, each of them with the priority, and with the equivalent Common Lisp operator/function. Maybe this is a line of some program that maps arithmetic expressions in lisp s-expressions, or something like that.

Lisp: lists and symbols are used in data and in code

This is one of the applications where code is data. In Lisp symbols and lists are data. But they are also used to write programs: the symbols then are used for variable names, function names and much more. Lists are used to write expressions in the Lisp language - these are called forms.

In a Lisp program

(+ 1 2)

is a function call of the function named + with two values.

'(+ 1 2)

or

(quote (+ 1 2))

then is data -> the list of the symbol + and the numbers 1 and 2.

Example: infix to prefix conversion

The form you used defines a mapping from a symbol denoting a mathematical function to the weight and the actual Lisp function it represents for the conversion.

See Lispology: Infix to prefix

(defparameter *binary-operators*

  ;  operator  weight  Lisp function

  '((+         1       +)

    (-         1       -)

    (*         2       *)

    (x         2       *)

    (/         2       %)

    (^         3       expt)))

We can use it to convert infix mathematical expressions to prefix Lisp expressions (see the above linked article for the code):

CL-USER 52 > (infix-prefix '(2 * 3 ^ 4))

(* 2 (EXPT 3 4))

When we change that assoc list, then the conversion will be different. Let's change the weight of the ^ operator:

CL-USER 53 > (defparameter *binary-operators*

               '((+ 1 +)

                 (- 1 -)

                 (* 2 *)

                 (x 2 *)

                 (/ 2 %)

                 (^ 1 expt)))     ; weight changed to 1

*BINARY-OPERATORS*

Now we can convert the example from above and we get a different Lisp form:

CL-USER 54 > (infix-prefix '(2 * 3 ^ 4))

(EXPT (* 2 3) 4)

So, *binary-operators* is data, which drives the conversion from infix mathematical expressions to Lisp forms. Instead of hardwiring the rules into the code, here we are using an assoc list to keep the mappings. Thus allows us to add new operators by changing the assoc list, without changing the actual code.