CODEWITHSUNDEEP
macroscommon-lispsymbols
MartinHaTh
MartinHaTh

Reputation: 1447

Symbol manipulation in lisp macro

I'm writing a toy interpreter for a Lisp language, in which I have the following CL code:

(defun mal-list (&rest args)
  (make-mal :type 'list
            :value args))
(register-fun '|list| #'mal-list)

(defun mal-list? (arg)
  (eq (mal-type arg) 'list))
(register-fun '|list?| #'mal-list?)

However, I'd rather simply write something like this:

(defmal list (&rest args)
   (make-mal :type 'list
             :value args))

(defmal list? (arg)
   (eq (mal-type arg) 'list))

I tried to write a macro to do this, but I had problems with the symbols with the bars (I'm pretty confused as to what this is!). This is what I tried:

(defmacro defmal (name args &body body )
  (let ((funsym (intern (format nil "~{~a~}" `(mal- ,name)))))
    `(register-fun `|,name| (defun ,funsym ,args ,@body))))

which didn't work out, because `|,name| literaly meant |,name|, and not |list|

I'm guessing this is an XY problem, but I'm not sure how to approach this otherwise.

Upvotes: 1

Views: 562

Answers (2)

coredump
coredump

Reputation: 38789

In addition to Joshua's detailed answer, consider using a function from the Alexandria library:

  • format-symbol is like format, but inside with-standard-io-syntax. Here, t stands for the current package and name is downcased:

    (format-symbol t "mal-~(~A~)" name)
=> |mal-list|

  • symbolicate concatenates and interns in current package:

    (symbolicate '#:mal- name)

    You can end-up with either |MAL-LIST| or |mal-list| if your current readtable preserves case or not. For completeness, note that readtable-case can be set to the following values: :upcase, :downcase, :preserve or :invert (this one I find quite interesting).

Upvotes: 3

Joshua Taylor
Joshua Taylor

Reputation: 85813

The |...| syntax is just one of the ways that the Lisp printer can print symbols that have characters in their name that need to be escaped (and that the reader can read symbols with those kinds of characters in their names):

(print (intern "foo"))
;=> |foo|

There are other ways, too, including escaping individual characters:

(print '|FOO|)
;=> FOO

(print '\f\o\o)
;=> |foo|

What you're trying to do is simply create a symbol whose name includes lower case letters. That's easy enough, as shown above. Part of your issue, though, is that you're getting as input a symbol whose name is full of capital letters, so you'll need to downcase first:

CL-USER> (symbol-name 'FOO)
;=> "FOO"

CL-USER> (intern (symbol-name 'FOO))
;=> FOO

CL-USER> (string-downcase (symbol-name 'FOO))
;=> "foo"

CL-USER> (intern (string-downcase (symbol-name 'FOO)))
;=> |foo|

In fact, because string-downcase takes string designators, not just strings, you can pass the symbol in directly:

CL-USER> (intern (string-downcase 'BaR))
;=> |bar|

So, after all that string processing, we can move to the macro.

It sounds like you're looking for something like this:

(defmacro defmal (name lambda-list &body body)
  (let ((mal-name (intern (concatenate 'string "MAL-" (symbol-name name))))
        (mal-norm (intern (string-downcase name))))
    `(progn
       (defun ,mal-name ,lambda-list
          ,@body)
       (register-function ',mal-norm #',mal-name))))


CL-USER> (pprint (macroexpand-1 '(defmal list? (arg)
                                  (eq (mal-type arg) 'list))))

(PROGN
 (DEFUN MAL-LIST? (ARG) (EQ (MAL-TYPE ARG) 'LIST))
 (REGISTER-FUNCTION '|list?| #'MAL-LIST?))

It's generally a good idea to avoid using format in generating symbol names, because the specific output can change, depending on other variables. E.g.:

(loop for case in '(:upcase :downcase :capitalize)
   collect (let ((*print-case* case))
             (format nil "~a" 'foo)))
;=> ("FOO" "foo" "Foo")

Instead, you can use concatenate with a string (or the symbol name of a symbol). Because the reader can also have different settings for case sensitivity, sometimes I'll even do (but not everyone likes this):

(concatenate 'string (symbol-name '#:mal-) (symbol-name name))

This way, if the reader does anything unusual (e.g., preserves case, so that the symbol name of mal- is "mal-), you can preserve it in your own generated symbol, too.

Upvotes: 4

Related Questions