Книга: Practical Common Lisp
How the Reader Uses Packages
How the Reader Uses Packages
In Chapter 4 I discussed briefly how the Lisp reader translates names into symbols, but I glossed over most of the details—now it's time to take a closer look at what actually happens.
I'll start by describing the syntax of names understood by the reader and how that syntax relates to packages. For the moment you can think of a package as a table that maps strings to symbols. As you'll see in the next section, the actual mapping is slightly more flexible than a simple lookup table but not in ways that matter much to the reader. Each package also has a name, which can be used to find the package using the function
The two key functions that the reader uses to access the name-to-symbol mappings in a package are
INTERN. Both these functions take a string and, optionally, a package. If not supplied, the package argument defaults to the value of the global variable
*PACKAGE*, also called the current package.
FIND-SYMBOL looks in the package for a symbol with the given string for a name and returns it, or
NIL if no symbol is found.
INTERN also will return an existing symbol; otherwise it creates a new symbol with the string as its name and adds it to the package.
Most names you use are unqualified, names that contain no colons. When the reader reads such a name, it translates it to a symbol by converting any unescaped letters to uppercase and passing the resulting string to
INTERN. Thus, each time the reader reads the same name in the same package, it'll get the same symbol object. This is important because the evaluator uses the object identity of symbols to determine which function, variable, or other program element a given symbol refers to. Thus, the reason an expression such as
(hello-world) results in calling a particular
hello-world function is because the reader returns the same symbol when it reads the function call as it did when it read the
DEFUN form that defined the function.
A name containing either a single colon or a double colon is a package-qualified name. When the reader reads a package-qualified name, it splits the name on the colon(s) and uses the first part as the name of a package and the second part as the name of the symbol. The reader looks up the appropriate package and uses it to translate the symbol name to a symbol object.
A name containing only a single colon must refer to an external symbol—one the package exports for public use. If the named package doesn't contain a symbol with a given name, or if it does but it hasn't been exported, the reader signals an error. A double-colon name can refer to any symbol from the named package, though it's usually a bad idea—the set of exported symbols defines a package's public interface, and if you don't respect the package author's decision about what names to make public and which ones to keep private, you're asking for trouble down the road. On the other hand, sometimes a package author will neglect to export a symbol that really ought to be public. In that case, a double-colon name lets you get work done without having to wait for the next version of the package to be released.
Two other bits of symbol syntax the reader understands are those for keyword symbols and uninterned symbols. Keyword symbols are written with names starting with a colon. Such symbols are interned in the package named
KEYWORD and automatically exported. Additionally, when the reader interns a symbol in the
KEYWORD, it also defines a constant variable with the symbol as both its name and value. This is why you can use keywords in argument lists without quoting them—when they appear in a value position, they evaluate to themselves. Thus:
(eql ':foo :foo) ==> T
The names of keyword symbols, like all symbols, are converted to all uppercase by the reader before they're interned. The name doesn't include the leading colon.
(symbol-name :foo) ==> "FOO"
Uninterned symbols are written with a leading
#:. These names (minus the
#:) are converted to uppercase as normal and then translated into symbols, but the symbols aren't interned in any package; each time the reader reads a
#: name, it creates a new symbol. Thus:
(eql '#:foo '#:foo) ==> NIL
You'll rarely, if ever, write this syntax yourself, but will sometimes see it when you print an s-expression containing symbols returned by the function
(gensym) ==> #:G3128