Widely used "need-to-know" conventions:
| foo-bar | "-" is used as a word delimiter |
| *foo* | (global) special variable |
| foo* | slightly different variant of the foo operator |
| &foo | lambda list keyword. These symbols will be in the lambda-list-keywords list. |
| nfoo | (possibly) destructive (non-consing) function |
| foop | predicate (also foo-p); see notes below for when to hyphenate |
| foof | place changing (like in SETF, INCF, ...) (also foo-f) |
| +foo+ | constant, or single CLOS instance |
| %foo | low-level, fast, dangerous function, or Lisp system specific implementation of foo |
| make-foo | create a foo and return it |
| define-foo | (globally) define a new foo (also short version: "deffoo") |
| with-foo | create a dynamic context with a foo |
| do-foo | iterate through a foo |
| foo-case | foo-specific case expression |
| foo-bar | type-slot, converting FOO to BAR |
| foo-to-bar | converting FOO to BAR |
Often seen, but not-quite-so-common conventions:
| bar-of | slot bar of an object |
| foo/bar | type/operation, foo with bar, bar version of foo |
| foo.bar | type.slot or, in some implementations conventional hierarchical package (e.g. ACL and CMUCL) |
| ?foo | variable in embedded language |
| <foo< | variable in embedded language |
Occasionally seen:
| <foo> | class |
| %foo% | local special variable |
| .foo. | internal special variable |
| .foo. | private macro symbol |
| /foo/ | global lexical variable |
| $foo | function visible from Macsyma |
| foo& | foo, operating on fixnums |
| foo$ | foo, operating on floats |
Conventions in Scheme:
| foo! | destructive function |
| foo? | predicate |
| $foo | constant |
| call-with-foo | Invoke a thunk in some dynamic context |
| foo->bar | Coerce object of type foo to object of type bar |
This is standard syntax, not convention:
| :bar | keyword |
| foo:bar | external symbol bar in package foo |
| foo::bar | internal symbol bar in package foo (don't try this at home, kids!) |
| #:bar | uninterned symbol (does not belong to any package) |
These will annoy people:
| CamelCaseIdentifiers | Use identifiers-like-this |
| identifiers_with_underscores | are harder to type |
| hungarian-identifiers-pcsnsi | |
| abbrv-idntfrs | Use Emacs to expand them. |
Unless there is a good reason to use them (for instance, you need to interface to a third-party package that uses them), they should be avoided.
Some additional style notes:
- A function that tests for something involving its arguments is called a predicate and usually ends in p or -p. CLTL2 explains the rationale for each suffix:
By convention, the names of predicates usually end in the letter p (which stands for "predicate"). Common Lisp uses a uniform convention in hyphenating names of predicates. If the name of the predicate is formed by adding a p to an existing name, such as the name of a data type, a hyphen is placed before the final p if and only if there is a hyphen in the existing name. For example, number begets numberp but standard-char begets standard-char-p. On the other hand, if the name of a predicate is formed by adding a prefixing qualifier to the front of an existing predicate name, the two names are joined with a hyphen and the presence or absence of a hyphen before the final p is not changed. For example, the predicate string-lessp has no hyphen before the p because it is the string version of lessp (a MACLISP function that has been renamed < in Common Lisp). The name string-less-p would incorrectly imply that it is a predicate that tests for a kind of object called a string-less, and the name stringlessp would connote a predicate that tests whether something has no strings (is "stringless")!
- There are useful conventions for macros: deffoo or define-foo defines objects of type foo. Setting up a context for some actions, usually performing some binding, and including setup and teardown code, is usually a with-foo. Iterating macros are defined usually as do-foo.
- deffoo vs. define-foo used to be, and is in the spec, determined by foo. If foo is a hyphenated name, then the define-foo format is used, otherwise deffoo is used. For example, defmethod and defsetf vs. define-method-combination and define-setf-expander.
- Occasionally, there will be a pair of operator functions, and one is a destructive version of the other. Historical tradition will name the destructive variant nfoo for the basic non-destructive function, but this is inconsistently used.
- The CLIM specification supports a rather large protocol, and has a "spread arguments" convention for functions where there is a desire not to have to construct a large object just to call one function with it. A spread function takes many small constituent arguments and is named foo* for a basic function foo.
- There are some various methods ending in f, notably setf (but some advanced ones include locf for old ZetaLisp). The f stands for a generic field of an object, like a part of a cons cell, structure, vector, array, class instance, and so forth. Kent M. Pitman explained the origin of it on comp.lang.lisp.
- Note that nested conversions (e.g., (bar-to-baz (foo-to-bar x)) or (bar->baz (foo->bar x))) compose nicer if written the other way around: (baz-from-bar (bar-from-foo x)), (baz<-bar (bar<-foo x)).