D.1 Emacs Lisp Coding Conventions

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

• Simply loading the 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.

• Since all global variables share the same name space, and all functions share another name space, you should choose a short word to distinguish your program from other Lisp programs¹. Then take care to begin the names of all global variables, constants, and functions in your program with the chosen prefix. This helps avoid name conflicts.

  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.

  Separate the prefix from the rest of the symbol name with a hyphen, `-'. This will be consistent with Emacs itself and with most Emacs Lisp programs.

• Put a call to provide at the end of each separate Lisp file.
• 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.
• If one file foo uses a macro defined in another file bar, foo should contain this expression before the first use of the macro:

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

  (And the library bar should contain (provide 'bar), to make the require work.) This will cause bar to be loaded when you byte-compile foo. Otherwise, you risk compiling foo without the necessary macro loaded, and that would produce compiled code that won't work right. See Compiling Macros.

  Using eval-when-compile avoids loading bar when the compiled version of foo is used.

• Please don't require the cl package of Common Lisp extensions at run time. Use of this package is optional, and it is not part of the standard Emacs namespace. If your package loads cl at run time, that could cause name clashes for users who don't use that package.

  However, 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.

• 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'. 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 a user option variable records a true-or-false condition, give it a name that ends in `-flag'.
• 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. In any case, it is a problem for debugging, because the advised function doesn't do what its source code says it does. If the programmer investigating the problem is unaware that there is advice on the function, the experience can be very frustrating.

  We hope to remove all the places in Emacs that advise primitives. In the mean time, please don't add any more.

• It is likewise a bad idea for one Lisp package to advise a function in another Lisp package.
• Likewise, avoid using eval-after-load (see Hooks for Loading) in libraries and packages. 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 functions or library programs of standard 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 `def'.
• Macros that define a functions or variables should take 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.
• Please keep the names of your Emacs Lisp source files to 13 characters or less. This way, if the files are compiled, the compiled files' names will be 14 characters or less, which is short enough to fit on all kinds of Unix systems.
• 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.) The users will find Emacs more coherent if all libraries use the same conventions.
• If your program contains non-ASCII characters in string or character constants, you should make sure Emacs always decodes these characters the same way, regardless of the user's settings. There are two ways to do that:
  • Use coding system emacs-mule, and specify that for coding in the `-*-' line or the local variables list.

                   ;; XXX.el  -*- coding: emacs-mule; -*-
              

  • Use one of the coding systems based on ISO 2022 (such as iso-8859-n and iso-2022-7bit), and specify it with `!' at the end for coding. (The `!' turns off any possible character translation.)

                   ;; XXX.el -*- coding: iso-latin-2!; -*-
              

• Indent each function with C-M-q (indent-sexp) using the default indentation parameters.
• Don't make a habit of putting close-parentheses on lines by themselves; Lisp programmers find this disconcerting. Once in a while, when there is a sequence of many consecutive close-parentheses, it may make sense to split the sequence in one or two significant places.
• Please put a copyright notice and copying permission notice on the file if you distribute copies. Use a notice like this one:

            ;; Copyright (C) year name
            
            ;; This program is free software; you can redistribute it and/or
            ;; modify it under the terms of the GNU General Public License as
            ;; published by the Free Software Foundation; either version 2 of
            ;; the License, or (at your option) any later version.
            
            ;; This program is distributed in the hope that it will be
            ;; useful, but WITHOUT ANY WARRANTY; without even the implied
            ;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
            ;; PURPOSE.  See the GNU General Public License for more details.
            
            ;; You should have received a copy of the GNU General Public
            ;; License along with this program; if not, write to the Free
            ;; Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
            ;; Boston, MA 02110-1301 USA
       

  If you have signed papers to assign the copyright to the Foundation, then use `Free Software Foundation, Inc.' as name. Otherwise, use your name. See also See Library Headers.