How to obtain a list of all functions exclusively provided by a certain major mode

Question

This question in inspired by https://stackoverflow.com/q/605785/. By M-x describe-function <TAB> I can get a list of all interactive or nonintractive functions available in the current state of emacs. If an specific mode is activated (e.g. latex-mode) we get a longer list, as the functions available in latex-mode are also listed.

My question is how to obtain a list of all functions exclusively available in an specific mode (e.g. latex-mode)? In other words excluding all other functions not provided by that mode. Like in the above link providing a short description of the functions would also be handy.

Answer 1

What does it mean for a mode to provide a function? You say "a list of all functions exclusively available in an specific mode" and "excluding all other functions not provided by that mode".

It sounds like you are confusing a mode with the library that defines it. A library provides/defines functions. A mode generally does not do so.

If you want to get a list of all of the functions defined in a given library, then see @wvxvw's answer, for a start. You can also try matching the library prefix against function names - that is often pertinent, but it is by no means definitive.

If, however, you want to get a list of all of the functions that might be pertinent to a given mode, e.g., functions that can be used only, or are most useful, when that mode is turned on, then I'm afraid you will need to examine the library where the mode is defined. And you might even need to examine some other libraries.

A given library typically defines more than just some things that are pertinent to a given mode. And a given mode can very well make use of things that are defined in different libraries, and in some cases things that make sense only for that given mode or a set of modes that includes it.

In sum, as currently posed, your question is not very clear. You might help yourself to better answers by clarifying it.

Answer 2

Perhaps, this code will have some educational effect:

(defun remove-all-extensions (file-name)
  (let ((go-on t) next)
    (while go-on
      (setq next (file-name-sans-extension file-name))
      (setq go-on (not (string= next file-name))
            file-name next))
    next))

(defun function-symbols-of (library)
  (let ((origin (remove-all-extensions
                 (find-library-name
                  (if (stringp library) library
                    (symbol-name library)))))
        (result))
    (mapatoms (lambda (sym)
                (when (and (symbol-function sym)
                           (symbol-file sym)
                           (string= (remove-all-extensions (symbol-file sym))
                                    origin))
                  (push sym result))))
    result))

The problem

Due to non-deterministic nature of code parsing and loading several issues need to be addressed:

1. When is the function defined in a file? Functions can be defined conditionally, and predicting whether a condition will favor function definition or not is equivalent to solving the halting problem. To illustrate this, suppose this code:

   (if (> (random 100) 50)
      (defun foo ())
      (defun bar ()))
   

2. It is not generally possible to tell, whether a lisp form defined a function before (successfully) evaluating the form. This is, again, equivalent to halting problem, so, not solvable in general.
3. There are some common special cases such as aliasing and advising, which (a) create duplicates, (b) may misguide you as to the source file which declared the function.
4. Large fraction of functions are declared in C code (not necessarily accessible), which isn't really divided into libraries in the same sense that Emacs Lisp code is.

All this said, you probably want to look into find-func.el for inspiration, to get the general idea of the layout and the problems related to locating the source code for Emacs Lisp functions.

Answer 3

I've just added this functionality to lispy. The new command, lispy-goto-elisp-commands, is bound to oge.

The generic g (lispy-goto) gives a list of all tags, highlighting commands with a different face, while lispy-goto-elisp-commands only gives the command tags.

Code listing

(defun lispy-goto-elisp-commands (&optional arg)
  "Jump to Elisp commands within current file.
When ARG is non-nil, force a reparse."
  (interactive "P")
  (deactivate-mark)
  (let ((lispy-force-reparse arg))
    (lispy--fetch-tags (list (buffer-file-name)))
    (let ((struct (gethash (buffer-file-name) lispy-db)))
      (lispy--select-candidate
       (mapcar #'lispy--format-tag-line
               (delq nil
                     (cl-mapcar
                      (lambda (tag pretty-tag)
                        (when (semantic-tag-get-attribute tag :user-visible-flag)
                          pretty-tag))
                      (lispy-dbfile-plain-tags struct)
                      (lispy-dbfile-tags struct))))
       #'lispy--action-jump))))

This is just to show that CEDET's semantic is used to obtain the list of tags; (semantic-tag-get-attribute tag :user-visible-flag) is used to determine if the tag is a command or not.

How to use

1. Navigate to the file that contains the code. This can be done with f1 f. I like to use counsel-describe-function instead, since pressing C-. there omits having to go through *Help* buffer.

2. Make point special (move it before open paren, or activate region) and press oge. It's also possible to just use M-x lispy-goto-elisp-commands.

Answer 4

The smex package has code to list all commands of a package. You could adapt this code to get all functions.