关于backquote、unquote等在普通函数中使用的技术疑问

Awesome question—this is a really common point of confusion when diving into Lisp's metaprogramming features, so let's unpack it step by step.

First off, the big realization: these operators (backquote, unquote, unquote-splicing) are not exclusive to macros. They're built-in syntax constructs in Common Lisp and Racket that exist to let you create structured data (like lists, vectors, or even nested structures) using a "template" style.

Think of backquote as a way to say "here's a blueprint for a structure, but I want to fill in some dynamic parts". unquote (,) lets you insert a single value into that blueprint, and unquote-splicing (,@) lets you insert all elements of a collection into the blueprint. This works anywhere you can write a Lisp expression—including inside regular functions—because it's just a normal evaluation step, not something tied to macro expansion.

For a quick Common Lisp example:

(defun build-weekdays ()
  (let ((midweek '("Wed" "Thu")))
    `("Mon" "Tue" ,@midweek "Fri")))

Calling (build-weekdays) will return the list ("Mon" "Tue" "Wed" "Thu" "Fri")—no macros involved, just the function evaluating the backquoted expression to construct a list.

The core difference boils down to what you're constructing: data (in functions) vs. code (in macros), and when evaluation happens.

In Macros: Code Generation & Delayed Evaluation #

Macros exist to generate code that gets compiled/executed later. When you use backquote in a macro, you're creating a template for code that will be inserted into the program before runtime.

• unquote here inserts a piece of code (not its value) into the template.
• unquote-splicing inserts multiple pieces of code into the template.

For example:

(defmacro run-twice (expr)
  `(progn ,expr ,expr))

When you call (run-twice (print "Hello")), the macro expands to (progn (print "Hello") (print "Hello")) before the code runs. The ,expr inserts the actual expression (print "Hello"), not the result of running it—that evaluation happens later, when the expanded code executes.

In Regular Functions: Convenient Data Structure Construction #

In functions, backquote is just a shortcut for building complex data structures without manually chaining list, append, or concatenate. Everything here evaluates immediately at runtime:

• unquote inserts the current value of a variable or expression into the structure.
• unquote-splicing inserts all elements of a collection into the structure right away.

Take this function that builds a user profile structure:

(defun make-user-profile (name age hobbies)
  `(:name ,name :age ,age :hobbies ,@hobbies))

Calling (make-user-profile "Alice" 30 '("hiking" "reading")) returns the list (:name "Alice" :age 30 :hobbies "hiking" "reading")—this is a data structure, not code, built on the fly during function execution.

To drive the point home, let's contrast two similar-looking uses:

Macro Usage #

(defmacro log-values (a b)
  `(format t "Value A: ~a~%Value B: ~a~%" ,a ,b))

When expanded, (log-values (+ 1 2) (* 3 4)) becomes:

(format t "Value A: ~a~%Value B: ~a~%" (+ 1 2) (* 3 4))

The ,a and ,b insert the expressions themselves—they get evaluated when the formatted string runs.

Function Usage #

(defun create-log-message (a b)
  `("Value A:" ,a "Value B:" ,b))

Calling (create-log-message (+ 1 2) (* 3 4)) returns:

("Value A:" 3 "Value B:" 12)

Here, ,a and ,b insert the results of evaluating (+1 2) and (*3 4) immediately when the function runs.

• Core truth: Backquote operators are syntax for constructing structured values—they work anywhere you can write a Lisp expression, not just macros.
• Macros: Use them to build code templates, delaying evaluation until the expanded code runs.
• Functions: Use them as a cleaner, more readable alternative to manual list/structure construction, with immediate evaluation of dynamic parts.

内容的提问来源于stack exchange，提问作者Kyuvi