Common Lisp: How to create a concatenation-prefix macro, similar to '? [closed]

Question

It's difficult to tell what is being asked here. This question is ambiguous, vague, incomplete, overly broad, or rhetorical and cannot be reasonably answered in its current form. For help clarifying this question so that it can be reopened, visit the help center.

Closed 8 years ago.

Common Lisp macros typically use included-prefix notation: (operator stuff...)

However, the special quote macro ' uses concatenated-prefix notation: operator stuff , or alternatively operator(stuff).

I would like to create a custom macro in SBCL Common Lisp, let's call it !, that uses concatenation-prefix syntax to operate on a following list (or even atom), in a similar manner to ' . So I could invoke it anywhere, e.g. (setq foo !(bar) ), without it being infixed in parentheses itself.

How can this be done? What would the defmacro syntax look like? Thanks.

Answer 1

I see 2 ways to do it.

The first, simple variant is suitable, if you need it only for a single or very limited number of cases and you're satisfied with using just a single symbol as a prefix (like ! in the example case). You can create a read-macro, more specifically set a macro-character to substitute such operator for, say, addition:

(set-macro-character #\! (lambda (stream char)
                           (declare (ignore char))
                           (cons '+ (let ((next (read stream t nil t)))
                                 (if (consp next) next
                                     (list next)))))
CL-USER> !1
1
CL-USER> !(1 2)
3

The other, more complex and more flexible way is to define a macro, inside which apply a custom transformation, that will turn concatenated-prefix code into included-prefix. This trick uses the fact, that ordinary Lisp reader will read the in the same way both foo(bar) and foo (bar), i.e. it will split them into 2 elements.

The simple version of such macro may look like this:

(defmacro with-prefix-syntax (&body body)
  `(progn ,@(loop :for tail :on body :while body
                  :collect (if (and (not (atom (second tail)))
                                    (fboundp (first tail)))
                               (prog1 (cons (first tail) (second tail)
                                 (setf tail (rest tail)))
                               (first tail)))))

It will transform only top-level forms:

CL-USER> (macroexpand-1 '(with-prefix-syntax
                           print(1)))
(PROGN (PRINT 1))
CL-USER> (macroexpand-1 '(with-prefix-syntax
                           1))
(PROGN 1)
CL-USER> (macroexpand-1 '(with-prefix-syntax
                           print(1)
                           2))
(PROGN (PRINT 1) 2)

But not work in the lower levels:

CL-USER> (macroexpand-1 '(with-prefix-syntax
                           print(1)
                           (+ print(2))))
(PROGN (PRINT 1) (+ PRINT (2)))

Though it's rather easy to make it recursively transform all the layers (which is left as an exercise to the reader :)