GNU Info

Info Node: (elisp)Coding Conventions

(elisp)Coding Conventions


Next: Compilation Tips Up: Tips
Enter node , (file) or (file)node

Emacs Lisp Coding Conventions
=============================

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

   * 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.(1)  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.

     This recommendation applies even to names for traditional Lisp
     primitives that are not primitives in Emacs Lisp--even to
     `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 may 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.

   * It is often useful to put a call to `provide' in each separate
     library program, at least if there is more than one entry point to
     the program.

   * If a file requires certain other library 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.  Note: 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, for the sake of macros.  You do that like this:

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

   * When defining a major mode, please follow the major mode
     conventions.  Note: Major Mode Conventions.

   * When defining a minor mode, please follow the minor mode
     conventions.  Note: 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'.

   * Please do not define `C-c LETTER' as a key in your major modes.
     These sequences are reserved for users; they are the *only*
     sequences reserved for users, so do not block them.

     Instead, define sequences consisting of `C-c' followed by a control
     character, a digit, or certain punctuation characters.  These
     sequences are reserved for major modes.

     Changing all the Emacs major modes to follow this convention was a
     lot of work.  Abandoning this convention would make that work go
     to waste, and inconvenience users.

   * Sequences consisting of `C-c' followed by `{', `}', `<', `>', `:'
     or `;' are also reserved for major modes.

   * Sequences consisting of `C-c' followed by any other punctuation
     character are allocated for minor modes.  Using them in a major
     mode is not absolutely prohibited, but if you do that, the major
     mode binding may be shadowed from time to time by minor modes.

   * Function keys <F5> through <F9> without modifier keys are reserved
     for users to define.

   * Do not bind `C-h' following any prefix character (including
     `C-c').  If you don't bind `C-h', it is automatically available as
     a help character for listing the subcommands of the prefix
     character.

   * Do not bind a key sequence ending in <ESC> except following
     another <ESC>.  (That is, it is OK to bind a sequence ending in
     `<ESC> <ESC>'.)

     The reason for this rule is that a non-prefix binding for <ESC> in
     any context prevents recognition of escape sequences as function
     keys in that context.

   * Anything which acts like a temporary mode or state which the user
     can enter and leave should define `<ESC> <ESC>' or `<ESC> <ESC>
     <ESC>' as a way to escape.

     For a state which accepts ordinary Emacs commands, or more
     generally any kind of state in which <ESC> followed by a function
     key or arrow key is potentially meaningful, then you must not
     define `<ESC> <ESC>', since that would preclude recognizing an
     escape sequence after <ESC>.  In these states, you should define
     `<ESC> <ESC> <ESC>' as the way to escape.  Otherwise, define
     `<ESC> <ESC>' instead.

   * Applications should not bind mouse events based on button 1 with
     the shift key held down.  These events include `S-mouse-1',
     `M-S-mouse-1', `C-S-mouse-1', and so on.  They are reserved for
     users.

   * Special major modes used for read-only text should usually redefine
     `mouse-2' and <RET> to trace some sort of reference in the text.
     Modes such as Dired, Info, Compilation, and Occur redefine it in
     this way.

   * When a package provides a modification of ordinary Emacs behavior,
     it is good to include a command to enable and disable the feature,
     Provide a command named `WHATEVER-mode' which turns the feature on
     or off, and make it autoload (Note: Autoload).  Design the
     package so that simply loading it has no visible effect--that
     should not enable the feature.(2)  Users will request the feature
     by invoking the command.

   * It is a bad idea to define aliases for the Emacs primitives.  Use
     the standard names instead.

   * 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 discouraged.  It
     may do the right thing for a particular program, but there is no
     telling what other programs might break as a result.

   * 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.

   * 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.

   * Don't use `next-line' or `previous-line' in programs; nearly
     always, `forward-line' is more convenient as well as more
     predictable and robust.  Note: Text Lines.

   * Don't call functions that set the mark, unless setting the mark is
     one of the intended features of your program.  The mark is a
     user-level feature, so it is incorrect to change the mark except
     to supply a value for the user's benefit.  Note: The Mark.

     In particular, don't use any of these functions:

        * `beginning-of-buffer', `end-of-buffer'

        * `replace-string', `replace-regexp'

     If you just want to move point, or replace a certain string,
     without any of the other features intended for interactive users,
     you can replace these functions with one or two lines of simple
     Lisp code.

   * Use lists rather than vectors, except when there is a particular
     reason to use a vector.  Lisp has more facilities for manipulating
     lists than for vectors, and working with lists is usually more
     convenient.

     Vectors are advantageous for tables that are substantial in size
     and are accessed in random order (not searched front to back),
     provided there is no need to insert or delete elements (only lists
     allow that).

   * The recommended way to print a message in the echo area is with
     the `message' function, not `princ'.  Note: The Echo Area.

   * When you encounter an error condition, call the function `error'
     (or `signal').  The function `error' does not return.  Note:
     Signaling Errors.

     Do not use `message', `throw', `sleep-for', or `beep' to report
     errors.

   * An error message should start with a capital letter but should not
     end with a period.

   * In `interactive', if you use a Lisp expression to produce a list
     of arguments, don't try to provide the "correct" default values for
     region or position arguments.  Instead, provide `nil' for those
     arguments if they were not specified, and have the function body
     compute the default value when the argument is `nil'.  For
     instance, write this:

          (defun foo (pos)
            (interactive
             (list (if SPECIFIED SPECIFIED-POS)))
            (unless pos (setq pos DEFAULT-POS))
            ...)

     rather than this:

          (defun foo (pos)
            (interactive
             (list (if SPECIFIED SPECIFIED-POS
                       DEFAULT-POS)))
            ...)

     This is so that repetition of the command will recompute these
     defaults based on the current circumstances.

     You do not need to take such precautions when you use interactive
     specs `d', `m' and `r', because they make special arrangements to
     recompute the argument values on repetition of the command.

   * Many commands that take a long time to execute display a message
     that says something like `Operating...' when they start, and
     change it to `Operating...done' when they finish.  Please keep the
     style of these messages uniform: _no_ space around the ellipsis,
     and _no_ period after `done'.

   * Try to avoid using recursive edits.  Instead, do what the Rmail `e'
     command does: use a new local keymap that contains one command
     defined to switch back to the old local keymap.  Or do what the
     `edit-options' command does: switch to another buffer and let the
     user switch back at will.  Note: Recursive Editing.

   * 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.

   * Try to avoid compiler warnings about undefined free variables, by
     adding `defvar' definitions for these variables.

     Sometimes adding a `require' for another package is useful to avoid
     compilation warnings for variables and functions defined in that
     package.  If you do this, often it is better if the `require' acts
     only at compile time.  Here's how to do that:

          (eval-when-compile
            (require 'foo)
            (defvar bar-baz))

     If you bind a variable in one function, and use it or set it in
     another function, the compiler warns about the latter function
     unless the variable has a definition.  But often these variables
     have short names, and it is not clean for Lisp packages to define
     such variable names.  Therefore, you should rename the variable to
     start with the name prefix used for the other functions and
     variables in your package.

   * 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 on the file if you give copies to
     anyone.  Use a message 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., 59 Temple Place, Suite 330, Boston,
          ;; MA 02111-1307 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.

   ---------- Footnotes ----------

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

   (2) Consider that the package may be loaded arbitrarily by Custom
for instance.


automatically generated by info2www version 1.2.2.9