Ecaml (ecaml.Ecaml)

module Advice : sig ... end

The "advice" feature lets you add to the existing definition of a function, by "advising the function". Each function can have multiple "pieces of advice", separately defined. Each defined piece of advice can be "enabled" or "disabled" explicitly. All the enabled pieces of advice for any given function actually take effect when you "activate" advice for that function, or when you define or redefine the function. Note that enabling a piece of advice and activating advice for a function are not the same thing.

module Ansi_color : sig ... end

Ansi_color translates ANSI escape sequences to Emacs faces, like (find-library "ansi-color"). Ansi_color is significantly faster than ansi-color, especially on larger inputs.

module Auto_mode_alist : sig ... end

(describe-variable 'auto-mode-alist)(Info-goto-node "(elisp)Auto Major Mode")

module Backup : sig ... end

(Info-goto-node "(elisp)Backup Files")

module Buffer : sig ... end

Buffers are used to hold the contents of files that are being visited; there may also be buffers that are not visiting files.

module Char_code : sig ... end

A character code is an integer representing a character. Emacs character codes are a superset of the Unicode standard.

module Color : sig ... end

A color name specifies a color.

module Command : sig ... end

(Info-goto-node "(elisp)Command Loop")

module Comment : sig ... end

(Info-goto-node "(emacs)Comments")

module Compilation : sig ... end

(Info-goto-node "(elisp)Compilation")

module Current_buffer : sig ... end

There are, in general, many buffers in an Emacs session. At any time, one of them is designated as the "current buffer". This is the buffer in which most editing takes place, because most of the primitives for examining or changing text in a buffer operate implicitly on the current buffer. Normally the buffer that is displayed on the screen in the selected window is the current buffer, but this is not always so: a program can temporarily designate any buffer as current in order to operate on its contents, without changing what is displayed on the screen.

module Customization : sig ... end

(Info-goto-node "(elisp)Customization")

module Directory : sig ... end

module Echo_area : sig ... end

The "echo area" is used for displaying error messages for messages made with the `message' primitive, and for echoing keystrokes. It is not the same as the minibuffer, despite the fact that the minibuffer appears (when active) in the same place on the screen as the echo area.

module Face : sig ... end

A "face" is a collection of graphical attributes for displaying text: font family, foreground color, background color, optional underlining, and so on. Faces control how buffer text is displayed, and how some parts of the frame, such as the mode-line, are displayed.

module Feature : sig ... end

A feature name is a symbol that stands for a collection of functions, variables, etc. The file that defines them should "provide" the feature. Another program that uses them may ensure they are defined by "requiring" the feature. This loads the file of definitions if it hasn't been loaded already.

module File : sig ... end

File is for functions that operate on files on the filesystem.

module Filename : sig ... end

The name of a file. Functions in this module work directly on names, but do not read from or write to the filesystem.

module Find_function : sig ... end

For jumping from an Elisp function name to the code that defines it, even when that code is Ecaml.

module Form : sig ... end

An Emacs "form", which is a Lisp object that is intended to be evaluated. (Info-goto-node "(elisp)Forms").

module Frame : sig ... end

A "frame" is a screen object that contains one or more Emacs windows. It is the kind of object called a "window" in the terminology of graphical environments; but we can't call it a "window" here, because Emacs uses that word in a different way.

module Function : sig ... end

Functions that call from Emacs to OCaml.

module Grep : sig ... end

Just as you can run a compiler from Emacs and then visit the lines with compilation errors, you can also run ‘grep’ and then visit the lines on which matches were found. This works by treating the matches reported by ‘grep’ as if they were errors.

module Hash_table : sig ... end

(Info-goto-node "(elisp)Hash Tables")

module Hook : sig ... end

A hook is a variable where you can store a function or functions to be called on a particular occasion by an existing program. Emacs provides hooks for the sake of customization.

module Input_event : sig ... end

(Info-goto-node "(elisp)Input Events")

module Key_sequence : sig ... end

A key sequence is a sequence of one or more input events that form a unit. Input events include characters, function keys, and mouse actions.

module Keymap : sig ... end

The command bindings of input events are recorded in data structures called keymaps. Each entry in a keymap associates (or "binds") an individual event type, either to another keymap or to a command. When an event type is bound to a keymap, that keymap is used to look up the next input event; this continues until a command is found. The whole process is called "key lookup".

module Load : sig ... end

Loading a file of Lisp code means bringing its contents into the Lisp environment in the form of Lisp objects. Emacs finds and opens the file, reads the text, evaluates each form, and then closes the file.

module Load_history : sig ... end

load-history is an Emacs alist that associates the names of loaded library files with the names of the functions and variables they defined, as well as the features they provided or required. This is used by find-function, find-variable, and in *Help* buffers to jump from a symbol to its definition.

module Major_mode : sig ... end

Major modes specialize Emacs for editing particular kinds of text. Each buffer has only one major mode at a time.

module Marker : sig ... end

A Marker.t specifies a position in a buffer relative to the surrounding text. A marker changes its offset from the beginning of the buffer automatically whenever text is inserted or deleted, so that it stays with the two characters on either side of it.

module Minibuffer : sig ... end

A minibuffer is a special buffer that Emacs commands use to read arguments more complicated than the single numeric prefix argument. These arguments include file names, buffer names, and command names (as in M-x). The minibuffer is displayed on the bottom line of the frame, in the same place as the echo area, but only while it is in use for reading an argument.

module Minor_mode : sig ... end

A minor mode provides optional features that users may enable or disable independently of the choice of major mode. Minor modes can be enabled individually or in combination.

module Obarray : sig ... end

An obarray is a hash table mapping strings to Symbol.ts. Symbol.intern and Form.read use an obarray.

module Point : sig ... end

"Point" is a special buffer position used by many editing commands. Like other positions, point designates a place between two characters (or before the first character, or after the last character), rather than a particular character. The value of point is a number no less than 1, and no greater than the buffer size plus 1.

module Position : sig ... end

A "position" is the index of a character in the text of a buffer. More precisely, a position identifies the place between two characters (or before the first character, or after the last character), so we can speak of the character before or after a given position. However, we often speak of the character "at" a position, meaning the character after that position.

module Process : sig ... end

Process is used to create "subprocesses" or "child processes" of the Emacs process, which is their "parent process". A subprocess of Emacs may be "synchronous" or "asynchronous", depending on how it is created. When you create a synchronous subprocess, the program waits for the subprocess to terminate before continuing execution. When you create an asynchronous subprocess, it can run in parallel with Emacs. This kind of subprocess is represented within Emacs by a Process.t. Programs can use this object to communicate with the subprocess or to control it. For example, you can send signals, obtain status information, receive output from the process, or send input to it.

module Q : sig ... end

Q is short for Emacs quote. Q defines a constant symbols.

module Regexp : sig ... end

A "regular expression", or "regexp" for short, is a pattern that denotes a (possibly infinite) set of strings.

module Selected_window : sig ... end

The selected window is the one that you edit in. When a window is selected, the buffer in the window becomes the current buffer, and the cursor will appear in it.

module Symbol : sig ... end

An Emacs symbol, i.e., an Emacs value that satisfies Value.is_symbol.

module Syntax_table : sig ... end

A syntax table specifies the syntactic textual function of each character. This information is used by the parsing functions, the complex movement commands, and others to determine where words, symbols, and other syntactic constructs begin and end.

module System : sig ... end

(Info-goto-node "(elisp)System Environment")

module Text : sig ... end

Emacs text, which is a sequence of characters, along with text properties associated with each character.

module Timer : sig ... end

You can set up a timer to call a function at a specified future time or after a certain length of idleness.

module User : sig ... end

module Value : sig ... end

module Var : sig ... end

An 'a Var.t is a symbol that holds values of type 'a, embedded in Elisp's Value.t via an 'a Type.t.

module Vector : sig ... end

A Vector.t is a general-purpose array whose elements are Value.t's.

module Window : sig ... end

A "window" in Emacs is the physical area of the screen in which a buffer is displayed.

module Working_directory : sig ... end

val defadvice : ?⁠docstring:string ‑> ?⁠position:Advice.Position.t ‑> Core_kernel.Source_code_position.t ‑> advice_name:Advice.Name.t ‑> for_function:Symbol.t ‑> (args:Value.t list ‑> inner:(Value.t list ‑> Value.t) ‑> Value.t) ‑> unit

val defun : (Symbol.t ‑> Function.Fn.t ‑> unit) Function.with_spec

val defcustom : Core_kernel.Source_code_position.t ‑> Symbol.t ‑> Customization.Type.t ‑> docstring:string ‑> group:Customization.Group.t ‑> standard_value:Value.t ‑> unit

val defvar : Core_kernel.Source_code_position.t ‑> Symbol.t ‑> Value.t ‑> docstring:string ‑> unit

val define_derived_mode : ?⁠parent:Major_mode.t ‑> Core_kernel.Source_code_position.t ‑> change_command:Symbol.t ‑> docstring:string ‑> initialize:(unit ‑> unit) ‑> mode_line:string ‑> Major_mode.t