Module Ecaml

module Advice : sig ... end

The "advice" feature lets you add to the existing definition of a function, by wrapping around the original function a "piece of advice".

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 Async_ecaml : sig ... end
module Auto_mode_alist : sig ... end

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

module Background : sig ... end

A background job is an Async job that the emacs UI is not blocking on. These jobs are special -- they can only interact with the UI in limited ways to avoid interfering with blocking jobs, or with the user. For example, background jobs may not change the current buffer.

module Backup : sig ... end

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

module Bookmark : sig ... end
module Browse_url : sig ... end

Pass a URL to a WWW browser. Ecaml bindings for browse-url.el

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 Buffer_local : sig ... end
module Caml_embed = Ecaml_value.Caml_embed
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 Completing : sig ... end

Prompts for input, with completion from a static collection of suggestions.

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
module Debugger : sig ... end

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

module Defconst : sig ... end

Define constants. (N.B. Elisp constants are mutable. Read the docs.)

module Defun : sig ... end
module Defvar : sig ... end
module Directory : sig ... end
module Display : sig ... end

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

module Display_property : sig ... end
module Documentation : sig ... end

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

module Ecaml_profile : 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 Ediff : sig ... end

Side-by-side diffing of files or buffers.

module Elisp_gc : sig ... end

(Info-goto-node "(elisp)Garbage Collection")

module Elisp_time : sig ... end

Elisp's analog of Core.Time_ns, but with picosecond precision and a wider range of allowed times.

module Emacs_backtrace : sig ... end

View the current emacs stack.

module Emacs_version : sig ... end

Emacs_version provides information about the version and build info of the running instance of Emacs.

module Eval : sig ... end
module Evil : sig ... end

Functions for interacting with evil-mode

module Expect_test_config = Async_ecaml.Expect_test_config
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 = Ecaml_value.Form
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 Funcall = Ecaml_value.Funcall
module Function = Ecaml_value.Function
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 Help : sig ... end

Emacs "online" help.

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 Line_and_column : sig ... end
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
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 Mode_line : sig ... end
module Modified_tick : sig ... end

A Modified_tick.t is an integer value of one of the two modification counters that Emacs maintains for each buffer:

module Obarray : sig ... end

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

module Obsolete : sig ... end

(Info-goto-node "(elisp)Obsolete Functions")

module Ocaml_or_elisp_value : sig ... end
module Org_table : sig ... end

(Info-goto-node "(org)Orgtbl mode")

module Overlay : sig ... end

Overlays modify the appearance of a buffer's text, for presentation's sake.

module Plist : sig ... end

A property list (“plist” for short) is a list of paired elements. Each of the pairs associates a property name (usually a symbol) with a property or value.

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 Regexp : sig ... end

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

module Rx : sig ... end
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 Sync_or_async : sig ... end
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 Tabulated_list : sig ... end

Tabulated lists display table data, one line per record and one column per field.

module Terminal : sig ... end

A terminal is a device capable of displaying one or more Emacs frames.

module Text : sig ... end

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

module Thing_at_point : sig ... end

Support for detecting something at point---a filename, URL, what-have-you.

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 = Ecaml_value.Value
module Valueable = Ecaml_value.Valueable
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 Variable_watcher : sig ... end

A variable watcher provides a way to run a function when the value of a variable is changed.

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
module Q : sig ... end

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

include Async_ecaml.Export
module Async_process = Async.Process

Async.Process is shadowed by Ecaml.Process, so we make it available as Async_process.

module Async = Async

This lets us reliably shadow Async values in Import.

module Async_kernel = Async_kernel
val don't_wait_for : unit Async.Deferred.t -> unit
include Composition_infix
val (>>) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c
val (<<) : ('b -> 'c) -> ('a -> 'b) -> 'a -> 'c
val concat : ?⁠sep:string -> string list -> string
val defalias : Symbol.t -> Core_kernel.Source_code_position.t -> ?⁠docstring:string -> alias_of:Symbol.t -> unit -> unit
val defconst : Symbol.t -> Core_kernel.Source_code_position.t -> docstring:string -> type_:'a Ecaml__.Import.Value.Type.t -> value:'a -> 'a Var.t
val defconst_i : Symbol.t -> Core_kernel.Source_code_position.t -> docstring:string -> type_:'a Ecaml__.Import.Value.Type.t -> value:'a -> unit
val defcustom : ?⁠show_form:bool -> Symbol.t -> Core_kernel.Source_code_position.t -> docstring:string -> group:Customization.Group.t -> type_:'a Ecaml__.Import.Value.Type.t -> customization_type:Customization.Type.t -> standard_value:'a -> ?⁠on_set:('a -> unit) -> unit -> 'a Customization.t
val defgroup : string -> Core_kernel.Source_code_position.t -> docstring:string -> parents:Customization.Group.t list -> Customization.Group.t
val define_derived_mode : Symbol.t -> Core_kernel.Source_code_position.t -> docstring:string -> ?⁠define_keys:(string * Symbol.t) list -> mode_line:string -> ?⁠parent:Major_mode.t -> ?⁠initialize:((unit, 'a) Defun.Returns.t * (unit -> 'a)) -> unit -> (module Major_mode.S)
val define_minor_mode : Symbol.t -> Core_kernel.Source_code_position.t -> docstring:string -> ?⁠define_keys:(string * Symbol.t) list -> mode_line:string -> global:bool -> ?⁠initialize:(unit -> unit) -> unit -> Minor_mode.t
val defun : Symbol.t -> Core_kernel.Source_code_position.t -> ?⁠docstring:string -> ?⁠should_profile:bool -> ?⁠define_keys:(Keymap.t * string) list -> ?⁠obsoletes:Symbol.t -> ?⁠interactive:Defun.Interactive.t -> ?⁠evil_config:Evil.Config.t -> ('a, 'b) Defun.Returns.t -> 'b Defun.t -> unit
val defun_nullary : Symbol.t -> Core_kernel.Source_code_position.t -> ?⁠docstring:string -> ?⁠define_keys:(Keymap.t * string) list -> ?⁠obsoletes:Symbol.t -> ?⁠interactive:Defun.Interactive.t -> ?⁠evil_config:Evil.Config.t -> ('a, 'b) Defun.Returns.t -> (unit -> 'b) -> unit
val defun_nullary_nil : Symbol.t -> Core_kernel.Source_code_position.t -> ?⁠docstring:string -> ?⁠define_keys:(Keymap.t * string) list -> ?⁠obsoletes:Symbol.t -> ?⁠interactive:Defun.Interactive.t -> ?⁠evil_config:Evil.Config.t -> (unit -> unit) -> unit
val defvar : Symbol.t -> Core_kernel.Source_code_position.t -> docstring:string -> type_:'a Ecaml__.Import.Value.Type.t -> initial_value:'a -> ?⁠include_in_all_defvar_symbols:bool -> unit -> 'a Var.t
val defvaralias : Symbol.t -> Core_kernel.Source_code_position.t -> ?⁠docstring:string -> alias_of:Symbol.t -> unit -> unit
val inhibit_messages : ('a, 'b) Sync_or_async.t -> (unit -> 'b) -> 'b
val lambda : Core_kernel.Source_code_position.t -> ?⁠docstring:string -> ?⁠interactive:Defun.Interactive.t -> ('a, 'b) Defun.Returns.t -> 'b Defun.t -> Ecaml__.Import.Function.t
val lambda_nullary : Core_kernel.Source_code_position.t -> ?⁠docstring:string -> ?⁠interactive:Defun.Interactive.t -> ('a, 'b) Defun.Returns.t -> (unit -> 'b) -> Ecaml__.Import.Function.t
val lambda_nullary_nil : Core_kernel.Source_code_position.t -> ?⁠docstring:string -> ?⁠interactive:Defun.Interactive.t -> (unit -> unit) -> Ecaml__.Import.Function.t
val message : ?⁠echo:bool -> string -> unit
val messagef : ?⁠echo:bool -> ('a, unit, string, unit) Core_kernel.format4 -> 'a
val message_s : ?⁠echo:bool -> Core_kernel.Sexp.t -> unit
val message_text : ?⁠echo:bool -> Text.t -> unit
val print_s : ?⁠hide_positions:Base.bool -> Base.Sexp.t -> Base.unit
val raise_string : Core_kernel__.Import.string list -> 'a
val sec_ns : Core_kernel__.Import.float -> Core_kernel.Time_ns.Span.t
val wrap_message : ?⁠echo:bool -> string -> f:(unit -> 'a Async_kernel.Deferred.t) -> 'a Async_kernel.Deferred.t
module Returns = Defun.Returns
val provide : Feature.t -> unit
val inhibit_read_only : ('a, 'b) Sync_or_async.t -> (unit -> 'b) -> 'b
val debug_embedded_caml_values : unit -> Core_kernel.Sexp.t
module Ref : sig ... end