Next: Key Binding Conventions, Up: Tips [Contents][Index]

### D.1 Emacs Lisp Coding Conventions

Here are conventions that you should follow when writing Emacs Lisp code intended for widespread use:

- Simply loading a package should not change Emacs’s editing behavior. Include a command or commands to enable and disable the feature, or to invoke it.

  This convention is mandatory for any file that includes custom definitions. If fixing such a file to follow this convention requires an incompatible change, go ahead and make the incompatible change; don’t postpone it.

- You should choose a short word to distinguish your program from other Lisp programs. The names of all global symbols in your program, that is the names of variables, constants, and functions, should begin with that chosen prefix. Separate the prefix from the rest of the name with a hyphen, ‘`-`’. This practice helps avoid name conflicts, since all global variables in Emacs Lisp share the same name space, and all functions share another name space21. Use two hyphens to separate prefix and name if the symbol is not meant to be used by other packages.

  Occasionally, for a command name intended for users to use, it is more convenient if some words come before the package’s name prefix. And constructs that define functions, variables, etc., work better if they start with ‘`defun`’ or ‘`defvar`’, so put the name prefix later on in the name.

  This recommendation applies even to names for traditional Lisp primitives that are not primitives in Emacs Lisp—such as `copy-list`. Believe it or not, there is more than one plausible way to define `copy-list`. Play it safe; append your name prefix to produce a name like `foo-copy-list` or `mylib-copy-list` instead.

  If you write a function that you think ought to be added to Emacs under a certain name, such as `twiddle-files`, don’t call it by that name in your program. Call it `mylib-twiddle-files` in your program, and send mail to ‘`bug-gnu-emacs@gnu.org`’ suggesting we add it to Emacs. If and when we do, we can change the name easily enough.

  If one prefix is insufficient, your package can use two or three alternative common prefixes, so long as they make sense.

- Put a call to `provide` at the end of each separate Lisp file. See Named Features.
- If a file requires certain other Lisp programs to be loaded beforehand, then the comments at the beginning of the file should say so. Also, use `require` to make sure they are loaded. See Named Features.
- If a file foo uses a macro defined in another file bar, but does not use any functions or variables defined in bar, then foo should contain the following expression:

      (eval-when-compile (require 'bar))

  This tells Emacs to load bar just before byte-compiling foo, so that the macro definition is available during compilation. Using `eval-when-compile` avoids loading bar when the compiled version of foo is used. It should be called before the first use of the macro in the file. See Compiling Macros.

- Avoid loading additional libraries at run time unless they are really needed. If your file simply cannot work without some other library, then just `require` that library at the top-level and be done with it. But if your file contains several independent features, and only one or two require the extra library, then consider putting `require` statements inside the relevant functions rather than at the top-level. Or use `autoload` statements to load the extra library when needed. This way people who don’t use those aspects of your file do not need to load the extra library.
- If you need Common Lisp extensions, use the `cl-lib` library rather than the old `cl` library. The latter does not use a clean namespace (i.e., its definitions do not start with a ‘`cl-`’ prefix). If your package loads `cl` at run time, that could cause name clashes for users who don’t use that package.

  There is no problem with using the `cl` package at compile time, with `(eval-when-compile (require 'cl))`. That’s sufficient for using the macros in the `cl` package, because the compiler expands them before generating the byte-code. It is still better to use the more modern `cl-lib` in this case, though.

- When defining a major mode, please follow the major mode conventions. See Major Mode Conventions.
- When defining a minor mode, please follow the minor mode conventions. See Minor Mode Conventions.
- If the purpose of a function is to tell you whether a certain condition is true or false, give the function a name that ends in ‘`p`’ (which stands for “predicate”). If the name is one word, add just ‘`p`’; if the name is multiple words, add ‘`-p`’. Examples are `framep` and `frame-live-p`.
- If the purpose of a variable is to store a single function, give it a name that ends in ‘`-function`’. If the purpose of a variable is to store a list of functions (i.e., the variable is a hook), please follow the naming conventions for hooks. See Hooks.
- If loading the file adds functions to hooks, define a function `feature-unload-hook`, where feature is the name of the feature the package provides, and make it undo any such changes. Using `unload-feature` to unload the file will run this function. See Unloading.
- It is a bad idea to define aliases for the Emacs primitives. Normally you should use the standard names instead. The case where an alias may be useful is where it facilitates backwards compatibility or portability.
- If a package needs to define an alias or a new function for compatibility with some other version of Emacs, name it with the package prefix, not with the raw name with which it occurs in the other version. Here is an example from Gnus, which provides many examples of such compatibility issues.

      (defalias 'gnus-point-at-bol
        (if (fboundp 'point-at-bol)
            'point-at-bol
          'line-beginning-position))

- Redefining or advising an Emacs primitive is a bad idea. It may do the right thing for a particular program, but there is no telling what other programs might break as a result.
- It is likewise a bad idea for one Lisp package to advise a function in another Lisp package (see Advising Functions).
- Avoid using `eval-after-load` and `with-eval-after-load` in libraries and packages (see Hooks for Loading). This feature is meant for personal customizations; using it in a Lisp program is unclean, because it modifies the behavior of another Lisp file in a way that’s not visible in that file. This is an obstacle for debugging, much like advising a function in the other package.
- If a file does replace any of the standard functions or library programs of Emacs, prominent comments at the beginning of the file should say which functions are replaced, and how the behavior of the replacements differs from that of the originals.
- Constructs that define a function or variable should be macros, not functions, and their names should start with ‘`define-`’. The macro should receive the name to be defined as the first argument. That will help various tools find the definition automatically. Avoid constructing the names in the macro itself, since that would confuse these tools.
- In some other systems there is a convention of choosing variable names that begin and end with ‘`*`’. We don’t use that convention in Emacs Lisp, so please don’t use it in your programs. (Emacs uses such names only for special-purpose buffers.) People will find Emacs more coherent if all libraries use the same conventions.
- The default file coding system for Emacs Lisp source files is UTF-8 (see Text Representations). In the rare event that your program contains characters which are not in UTF-8, you should specify an appropriate coding system in the source file’s ‘`-*-`’ line or local variables list. See Local Variables in Files in The GNU Emacs Manual.
- Indent the file using the default indentation parameters.
- Don’t make a habit of putting close-parentheses on lines by themselves; Lisp programmers find this disconcerting.
- Please put a copyright notice and copying permission notice on the file if you distribute copies. See Library Headers.

#### Footnotes

### (21)

The benefits of a Common Lisp-style package system are considered not to outweigh the costs.

Next: Key Binding Conventions, Up: Tips [Contents][Index]