Subject: Re: 31.0.50; Improve ispell.el documentation

From: Lockywolf <[email-masked]>
Date: Wed, 10 Sep 2025 10:43:00 +0800

Apologies, the previous patch got mangled, please see the patch attached
to this message.

>From 199ba4f08bf746a233a0bafd7bea62da77b88eea Mon Sep 17 00:00:00 2001
From: Lockywolf <[email-masked]>
Date: Wed, 10 Sep 2025 10:05:31 +0800
Subject: [PATCH] Improve ispell-mode and flyspell-mode documentation.

* doc/emacs/fixit.texi (Checking and Correcting Spelling):
 1. Fix documentation errors for various ispell-* functions.
 2. Document ispell-minor-mode
 3. Document ispell word completion functionality
 4. Document LocalWords syntax
 5. Expand dictionary selection documentation
---
 doc/emacs/fixit.texi | 468 ++++++++++++++++++++++++++++++++++---------
 1 file changed, 369 insertions(+), 99 deletions(-)

diff --git a/doc/emacs/fixit.texi b/doc/emacs/fixit.texi
index f240057aa69..17fa71b7def 100644
--- a/doc/emacs/fixit.texi
+++ b/doc/emacs/fixit.texi
@@ -263,20 +263,222 @@ Spelling
 @xref{Top, Aspell,, aspell, The Aspell Manual}.
 @end ifnottex
 
+Note, however, that this section will only help you fix spelling errors,
+not grammatical or punctuation errors.
+
 @vindex ispell-program-name
+@defvar ispell-program-name
+Choose the default spell-checking program by customizing this variable.
+@end defvar
   If you have only one of the spelling checker programs installed,
 Emacs will find it when you invoke for the first time one of the
 commands described here.  If you have more than one of them installed,
 you can control which one is used by customizing the variable
-@code{ispell-program-name}.
+@code{ispell-program-name} or adding the following line into your init
+file: @code{(setopt ispell-program-name "hunspell")}.
+
+@cindex @code{ispell} program
+@findex ispell-kill-ispell
+@deffn Command ispell-kill-ispell
+Kill the spell-checker subprocess.
+@end deffn
+
+Once started, the spell-checker subprocess continues
+to run, waiting for something to do, so that subsequent spell-checking
+commands complete more quickly.  If you want to get rid of the
+process, use @w{@kbd{M-x ispell-kill-ispell}}.  This is not usually
+necessary, since the process uses no processor time except when you do
+spelling correction, but might come in handy when the process is used
+for the purposes other than interactive spell-checking by externally
+installed packages.
+
+Note that if you use Flyspell-mode for on-the-fly spell-checking
+@pxref{flyspell-mode}, and you frequently switch between buffers using
+different spell-checking dictionaries, the spell-checking program will
+be restarted on each buffer switch, which might be slowing down Emacs if
+creating new processes is expensive on your Operating System.
+
+@subsection Spelling Dictionary Selection
+@cindex spell-checking dictionary
+
+In addition to having the spell checker program installed it is also
+important to have spellchecking dictionaries matching the language and
+orthography of your preferred writing installed system-wide.  You can
+check if a dictionary supporting the language you need to have checked
+is present by examining the contents of the library directories, usually
+printed by the commands in the left column in the following table.  The
+typical values for GNU/Linux are shown in the right column.
+@table @samp
+@item @code{ispell -vv}
+@code{/usr/lib64/ispell}
+@item @code{aspell config}
+@code{/usr/lib64/aspell/}
+@item Hunspell
+@code{/usr/share/hunspell/}
+@item Enchant
+Uses dictionaries from either Aspell or Hunspell.
+@end table
+Dictionaries typically consist of two files, one @code{.aff} file with
+the grammar, and one @code{.hash} or @code{.dict} with the dictionary.
+
+  Spell-checkers look up spelling in two dictionaries: @emph{the dictionary
+installed together with the spell-checker program} (or as a system
+add-on) and your @emph{personal dictionary}, which is usually empty when you
+have not been using spell-checking for a long time.
+
+@cindex spell-checking different languages
+@cindex language for spell-checking
+  Usually, a dictionary used by a spell-checker is for a specific
+language.  The default language is determined from your system's
+environment and locale.  Both the standard dictionary and your personal
+dictionary should be changed if you want to spell-check text in a
+different language.  You can use the @code{ispell-change-dictionary}
+command for that.
+
+@vindex ispell-dictionary
+@vindex ispell-local-dictionary
+@findex ispell-change-dictionary
+@defopt ispell-dictionary
+@defoptx ispell-local-dictionary
+The value of this variables shows the current selected spell-checking
+dictionary.
+@end defopt
+@deffn Command ispell-change-dictionary dictionary &optional globalp
+Change the spell-checking dictionary (language) for the current buffer.
+With a prefix argument change it globally instead.
+@end deffn
+
+  The system-wide dictionary (language) used by the spell-checker is
+chosen by using the command @w{@kbd{M-x ispell-change-dictionary}}.
+When called with a prefix argument or, in the lisp code, with
+@code{(ispell-change-dictionary "en_UK" t)}, it sets the value of the
+dictionary used for all new buffers saved in the variable
+@code{ispell-dictionary}, and without prefix argument it sets it
+buffer-locally, setting the variable @code{ispell-local-dictionary}.
+
+  Alternatively, it is possible to override the buffer-local value for
+the dictionary by adding @code{"Local IspellDict: en_UK"} at the bottom
+of the buffer, within a comment line, and reverting the buffer.  This is
+useful if the same file has to be shared by multiple developers, some of
+which do not use Emacs.  This value is usually passed to the spell
+checker program using the @code{-d} command-line switch.
+
+If both @code{ispell-dictionary} and @code{ispell-local-dictionary} are
+@code{nil}, that is, if a dictionary has never been changed, the system
+will call the spell-checking program without explicitly selecting a
+dictionary (language), and the language to be checked will be determined
+by the spell-checking program itself.  This may be useful if you prefer
+to set the language there, so that all client programs using the same
+backend spell-checking program would have the same default setting.
+
+@cindex spell-checking multi-lingual text
+@findex ispell-hunspell-add-multi-dic
+@deffn Command ispell-hunspell-add-multi-dic
+Define a multi-language dictionary to be used with Hunspell.
+@end deffn
+  Hunspell is special in that it supports spell-checking using several
+different dictionaries in parallel.  To use this feature, invoke the
+@w{@kbd{M-x ispell-hunspell-add-multi-dic}} command before you start
+using Hunspell for a particular combination of dictionaries.  This
+command prompts for the dictionary combination, which should be a
+comma-separated list of language-specific dictionary names, such as
+@samp{en_US,de_DE,ru_RU}.  Thereafter, you can spell-check text which
+mixes these languages without changing the dictionaries each time.
+(Caveat: when several languages use the same script, it is possible that
+a word that is mis-spelled in one language is found as a valid spelling
+in the dictionary of another language; in that case, the mis-spelled
+word might be missed.)
+
+For example, you can add the following to your Emacs init file:
+@lisp
+(use-package ispell
+   ;; uses (setopt ispell-set-spellchecker-params)
+  (setopt ispell-program-name "hunspell")
+  (ispell-hunspell-add-multi-dic "en_GB-ise,russian_aot_yo")
+  (ispell-change-dictionary "en_GB-ise,russian_aot_yo" t))
+@end lisp
+
+@vindex ispell-personal-dictionary
+@defvar ispell-personal-dictionary
+The value of this variable is either the name or the full path to the
+personal dictionary passed to the spell-checking program using the
+@code{-p} command-line switch.
+@end defvar
+
+  A ``personal dictionary'' is the file where you can add your own words
+to, for example, account for imperfections of the system-wide dictionary
+or to avoid less known proper nouns being marked as misspelled.  Your
+personal dictionary is specified by the variable
+@code{ispell-personal-dictionary}.  If that is @code{nil}, the spelling
+program looks for a personal dictionary in a default location, which is
+specific to each spell-checker.  In particular Aspell will save the
+personal dictionary in @code{~/.aspell.<language_name>.pws}, Ispell uses
+@code{~/.ispell_<language-name>}, but it will also pick up a file with
+the same name if it is present in the current directory, so check the
+manual to your spell-checking program.  A directory-local personal
+dictionary may happen to be useful for the case when you are
+contributing to a project which uses many domain-specific words which
+you might normally consider containing typos.
+
+@cindex adding spell-checking exceptions
+@cindex spell-checking exceptions
+@anchor{spell-checking local words}
+As opposed to defining a personal dictionary, which would be decoupled
+from the file being checked, sometimes it is advantageous to keep
+spelling exceptions stored in the same file, especially if the syntax
+used in the file allows that.  File-local exceptions can be added
+interactively when using one of the proofreading commands
+(@pxref{Proofreading}), or manually by writing exceptions at the bottom
+of the file following the keyword @code{"LocalWords: "}.  This allows
+preserving the list of exceptions when sending the file over electronic
+mail to your collaborators.
+
+It is also possible to add exceptions for the duration of the running
+Emacs session, using the interactive proofreading interface
+(@pxref{Proofreading}).  These words will be lost after Emacs is
+restarted, so you are free to experiment with spelling exceptions
+without the fear that a careless addition might end up in a missed typo.
+
+@subsection Synchronous Spell-Checking (Proofreading)
+@cindex proofreading
+@cindex spell-checking (synchronous)
+@anchor{Proofreading}
+
+Emacs spell-checking subsystem is originally designed for purposeful
+(synchronous) spell-checking, and expects ``writing'' and ``proofing''
+to be two separate activities.  If you need less rigorous asynchronous
+spell-checking, @pxref{On-the-Fly Spell-Checking}.
+
+Proofreading in Emacs is usually broken into ``sessions'', which consist
+of selecting a piece of text in one way or another (for example, a
+region or a whole buffer) and feeding it all (sometimes de-formatted
+inside Emacs) to the spell-checking program, prompting the user for
+an action when a typo is discovered.
+
+Throughout the spelling session, the prompted word in question will be
+highlighted using the @code{ispell-highlight-face}, which can be
+customized.
+
+@deffn Face ispell-highlight-face
+@vindex ispell-highlight-face
+@anchor{ispell-highlight-face}
+Face to use for highlighting spelling mistakes as identified by
+@code{ispell-word} and similar functions.
+@end deffn
+
+@subsubsection Calling the Spell-Checker
 
 @table @kbd
 @item M-$
+@itemx M-x @code{ispell-word}
+@anchor{ispell-word}
 Check and correct spelling of the word at point (@code{ispell-word}).
 If the region is active, do it for all words in the region instead.
+(This is the most frequently used command.)
 @item C-u M-$
+@itemx M-x @code{ispell-continue}
 If a previous spelling operation was interrupted, continue that
-operation (@code{ispell-continue}).
+operation.
 @item M-x ispell
 Check and correct spelling of all words in the buffer.  If the region
 is active, do it for all words in the region instead.
@@ -286,25 +488,18 @@ Spelling
 Check and correct spelling in the region.
 @item M-x ispell-message
 Check and correct spelling in a draft mail message, excluding cited
-material.
+material, header fields (@code{To:, From:, Cc:}).
 @item M-x ispell-comments-and-strings
 Check and correct spelling of comments and strings in the buffer or region.
 @item M-x ispell-comment-or-string-at-point
 Check the comment or string at point.
-@item M-x ispell-change-dictionary @key{RET} @var{dict} @key{RET}
-Restart the spell-checker process, using @var{dict} as the dictionary.
-@item M-x ispell-kill-ispell
-Kill the spell-checker subprocess.
-@item M-@key{TAB}
-@itemx @key{ESC} @key{TAB}
-@itemx C-M-i
-Complete the word before point based on the spelling dictionary and
-other completion sources (@code{completion-at-point}).
-@item M-x flyspell-mode
-Enable Flyspell mode, which highlights all misspelled words.
-@item M-x flyspell-prog-mode
-Enable Flyspell mode for comments and strings only.
 @end table
+@defvar ispell-check-comments
+@vindex ispell-check-comments
+Adjust the aforementioned commands' behaviour in modes based on
+@code{text-mode}, but using a lot of structured markup, such as
+@code{org-mode}.
+@end defvar
 
 @kindex M-$
 @findex ispell-word
@@ -325,18 +520,30 @@ Spelling
 @findex ispell-comments-and-strings
 @findex ispell-comment-or-string-at-point
 @cindex spell-checking the active region
-  Similarly, the command @kbd{M-x ispell} performs spell-checking in
-the region if one is active, or in the entire buffer otherwise.  The
+  Similarly, the command @kbd{M-x ispell} performs spell-checking in the
+region if one is active, or in the entire buffer otherwise.  The
 commands @w{@kbd{M-x ispell-buffer}} and @w{@kbd{M-x ispell-region}}
 explicitly perform spell-checking on the entire buffer or the region
 respectively.  To check spelling in an email message you are writing,
 use @w{@kbd{M-x ispell-message}}; that command checks the whole buffer,
-except for material that is indented or appears to be cited from other
-messages.  @xref{Sending Mail}.  When dealing with source code, you
+except for material that is indented, appears to be cited from other
+messages, or belongs to the email message formal syntax (@code{To:,
+From:, Cc:}).  @xref{Sending Mail}.  When dealing with source code, you
 can use @kbd{M-x ispell-comments-and-strings} or @w{@kbd{M-x
 ispell-comment-or-string-at-point}} to check only comments or string
 literals.
 
+  By default in modes based on @code{text-mode}, the aforementioned
+commands will perform spell-checking on all of the text, even if is
+commented-out.  Sometimes, however, you might want to comment-out pieces
+of structural markup, such as @code{org-mode}'s tags, which might not be
+proper words, but due to being commented-out are indistinguishable from
+normal comment text.  To prevent checking of comments in text modes, set
+@code{ispell-check-comments} to @code{nil}.  Setting it to
+@code{'exclusive} will make the spell-checker check @emph{only} comments.
+
+@subsubsection Correcting Spelling Mistakes
+@cindex spell-checking (correcting mistakes)
   When one of these commands encounters what appears to be an
 incorrect word, it asks you what to do.  It usually displays a list of
 numbered @dfn{near-misses}---words that are close to the incorrect word.
@@ -355,7 +562,8 @@ Spelling
 
 @item r @var{new} @key{RET}
 Replace the word, just this time, with @var{new}.  (The replacement
-string will be rescanned for more spelling errors.)
+string will be rescanned for more spelling errors, thus marking other
+of the occurrences of the same spelling as correct.)
 
 @item R @var{new} @key{RET}
 Replace the word with @var{new}, and do a @code{query-replace} so you
@@ -368,11 +576,13 @@ Spelling
 
 @item A
 Accept the incorrect word---treat it as correct, but only in this
-editing session and for this buffer.
+file. (This adds @code{LocalWords: } syntax to the file footer
+(@pxref{spell-checking local words}).)
 
 @item i
-Insert this word in your personal dictionary file so that it will be
-considered correct from now on, even in future sessions.
+Insert this word in your personal dictionary file (the spell-checking
+program does the insertion) so that it will be considered correct from
+now on, even in future sessions and even outside Emacs.
 
 @item m
 Like @kbd{i}, but you can also specify dictionary completion
@@ -383,10 +593,10 @@ Spelling
 file.
 
 @item l @var{word} @key{RET}
-Look in the dictionary for words that match @var{word}.  These words
-become the new list of near-misses; you can select one of them as
-the replacement by typing a digit.  You can use @samp{*} in @var{word} as a
-wildcard.
+Look up the words that match @var{word} in the completion dictionary
+(@pxref{plain-text completion}).  These words become the new list of
+near-misses; you can select one of them as the replacement by typing a
+digit.  You can use @samp{*} in @var{word} as a wildcard.
 
 @item C-g
 @itemx X
@@ -416,6 +626,51 @@ Spelling
 
 @item ?
 Show the list of options.
+@end table
+
+@subsection Plain-Text Word Completion
+@cindex completion (plain-text)
+@cindex completion (words)
+@cindex word completion
+@anchor{plain-text completion}
+Emacs also supports words completion based on a simple plain-text list
+of words separated by newlines, with no support for morphology.  Despite
+being quite primitive, this mechanism is often the only way of
+assistance a text editor can provide for the user writing a text without
+spending a lot of computational resources on syntactic and semantic
+analysis of the text.
+
+@vindex ispell-complete-word-dict
+@defvar ispell-complete-word-dict
+@defvarx ispell-alternate-dictionary
+  Primary and fallback dictionary for plain-text completion.
+@end defvar
+
+  A separate (from @code{ispell-dictionary} and
+@code{ispell-local-dictionary}) dictionary is used for plain-text word
+completion.  The variable @code{ispell-complete-word-dict} specifies the
+file name of this dictionary.  The completion dictionary must be
+different because it cannot use the information about roots and affixes
+of the words, which spell-checking uses to detect variations of words.
+For some languages, there is a spell-checking dictionary but no word
+completion dictionary.  The variable @code{ispell-alternate-dictionary}
+serves the same purpose, but points to the system-wide dictionary, which
+is usually pre-installed by your Operating System vendor.  On GNU/Linux
+this is often a wordlist extracted from the Webster dictionary (with
+definitions removed), shipped with some older editions of UNIX,
+installed at @code{/usr/share/dict/words}.  The ``GNU Miscfiles''
+project provides a (relatively limited) sample of such a wordlist if
+necessary.
+
+@table @kbd
+@item M-@key{TAB}
+@itemx @key{ESC} @key{TAB}
+@itemx C-M-i
+@itemx @kbd{Tools -> Spell Checking -> Complete Word}
+@itemx @kbd{Tools -> Spell Checking -> Complete Word Fragment}
+Complete the word before point based on the spelling dictionary and
+other completion sources (@code{completion-at-point},
+@code{ispell-complete-word}, @code{ispell-complete-word-interior-frag}).
 @end table
 
   Use the command @kbd{M-@key{TAB}} (@code{completion-at-point}) to
@@ -424,68 +679,25 @@ Spelling
 window manager intercepts @kbd{M-@key{TAB}}, type @w{@kbd{@key{ESC}
 @key{TAB}}} or @kbd{C-M-i}.)
 
-@cindex @code{ispell} program
-@findex ispell-kill-ispell
-  Once started, the spell-checker subprocess continues
-to run, waiting for something to do, so that subsequent spell-checking
-commands complete more quickly.  If you want to get rid of the
-process, use @w{@kbd{M-x ispell-kill-ispell}}.  This is not usually
-necessary, since the process uses no processor time except when you do
-spelling correction.
-
-@vindex ispell-dictionary
-@vindex ispell-local-dictionary
-@vindex ispell-personal-dictionary
-@findex ispell-change-dictionary
-  Spell-checkers look up spelling in two dictionaries:
-the standard dictionary and your personal dictionary.  The standard
-dictionary is specified by the variable @code{ispell-local-dictionary}
-or, if that is @code{nil}, by the variable @code{ispell-dictionary}.
-If both are @code{nil}, the spelling program's default dictionary is
-used.  The command @w{@kbd{M-x ispell-change-dictionary}} sets the
-standard dictionary for the buffer and then restarts the subprocess,
-so that it will use a different standard dictionary.  Your personal
-dictionary is specified by the variable
-@code{ispell-personal-dictionary}.  If that is @code{nil}, the
-spelling program looks for a personal dictionary in a default
-location, which is specific to each spell-checker.
-
-@cindex spell-checking different languages
-@cindex language for spell-checking
-  Usually, a dictionary used by a spell-checker is for a specific
-language.  The default language is determined from your system's
-environment and locale.  Both the standard dictionary and your personal
-dictionary should be changed if you want to spell-check text in a
-different language.  You can use the @code{ispell-change-dictionary}
-command for that.
-
-@cindex spell-checking multi-lingual text
-@findex ispell-hunspell-add-multi-dic
-  Hunspell is special in that it supports spell-checking using several
-different dictionaries in parallel.  To use this feature, invoke the
-@kbd{M-x ispell-hunspell-add-multi-dic} command before you start using
-Hunspell for a particular combination of dictionaries.  This command
-prompts for the dictionary combination, which should be a
-comma-separated list of language-specific dictionary names, such as
-@samp{en_US,de_DE,ru_RU}.  Thereafter, you can spell-check text which
-mixes these languages without changing the dictionaries each time.
-(Caveat: when several languages use the same script, it is possible that
-a word that is mis-spelled in one language is found as a valid spelling
-in the dictionary of another language; in that case, the mis-spelled
-word might be missed.)
 
-@vindex ispell-complete-word-dict
-  A separate dictionary is used for word completion.  The variable
-@code{ispell-complete-word-dict} specifies the file name of this
-dictionary.  The completion dictionary must be different because it
-cannot use the information about roots and affixes of the words, which
-spell-checking uses to detect variations of words.  For some
-languages, there is a spell-checking dictionary but no word completion
-dictionary.
+@subsection Asynchronous (On-the-Fly) Spell-Checking
+@cindex on-the-fly spell-checking
+@cindex spell-checking (on-the-fly)
+@anchor{On-the-Fly Spell-Checking}
 
 @cindex Flyspell mode
 @cindex mode, Flyspell
 @findex flyspell-mode
+@anchor{flyspell-mode}
+@table @kbd
+@item M-x flyspell-mode
+Enable Flyspell mode, which highlights all misspelled words.  (Most
+useful in modes based on @code{text-mode}.)
+
+Note that @code{flyspell-mode}, when enabled, will change the value of
+@code{ispell-highlight-face} (@pxref{ispell-highlight-face}).
+@end table
+
   Flyspell mode is a minor mode that performs automatic spell-checking
 of the text you type as you type it.  When it finds a word that it
 does not recognize, it highlights that word.  Type @w{@kbd{M-x
@@ -493,31 +705,89 @@ Spelling
 enable Flyspell mode in all text mode buffers, add
 @code{flyspell-mode} to @code{text-mode-hook}.  @xref{Hooks}.  Note
 that, as Flyspell mode needs to check each word across which you move,
-it will slow down cursor motion and scrolling commands.  It also
-doesn't automatically check the text you didn't type or move across;
-use @code{flyspell-region} or @code{flyspell-buffer} for that.
+it will slow down cursor motion and scrolling commands.
 
 @vindex flyspell-check-changes
-  Normally, Flyspell mode highlights misspelled words that you typed or
-modified, but also words you move across without changing them.  But if
-you customize the variable @code{flyspell-check-changes} to a
+@defvar flyspell-check-changes
+Enable spell-checking words you move across.
+@end defvar
+@deffn Face flyspell-error
+@deffnx Face flyspell-duplicate
+@vindex flyspell-error
+@vindex flyspell-duplicate
+These two faces define how the spelling mistake will be highlighted
+by @code{flyspell-mode}, the first being used for highlighting first
+occurrences of errors, and the second used for all subsequent identical
+misspellings.  These will override @code{ispell-highlight-face}.
+@end deffn
+@deffn Command flyspell-region
+@deffnx Command flyspell-buffer
+Highlight spelling mistakes in a region or in a buffer.
+@end deffn
+  Normally, Flyspell mode highlights both misspelled words that you
+typed or modified, and also words you move across without changing them.
+But if you customize the variable @code{flyspell-check-changes} to a
 non-@code{nil} value, Flyspell mode will check only the words you typed
-or edited in some way.
+or edited in some way. It @emph{doesn't automatically check the text you
+didn't type or move across}; use @code{flyspell-region} or
+@code{flyspell-buffer} for that.
+
 
 @findex flyspell-correct-word
-@findex flyspell-auto-correct-word
 @findex flyspell-correct-word-before-point
+@findex flyspell-auto-correct-word
+@table @kbd
+@item @kbd{mouse-2}
+@itemx @code{(flyspell-correct-word)}
+Display a menu of possible correction using mouse.
+@item @kbd{C-c $}
+@itemx @code{(flyspell-correct-word-before-point)}
+Display a menu of possible corrections using keyboard.
+@item @kbd{M-@key{TAB}}
+@itemx @kbd{C-M-i}
+@itemx @kbd{@key{ESC} @key{TAB}}
+@itemx @kbd{C-.}
+@itemx (@code{flyspell-auto-correct-word})
+Automatically correct word before point.
+@end table
   When Flyspell mode highlights a word as misspelled, you can click on
 it with @kbd{mouse-2} (@code{flyspell-correct-word}) to display a menu
 of possible corrections and actions.  If you want this menu on
-@kbd{mouse-3} instead, enable @code{context-menu-mode}.  In addition,
-@kbd{C-.} or @kbd{@key{ESC} @key{TAB}} (@code{flyspell-auto-correct-word})
-will propose various successive corrections for the word at point, and
-@w{@kbd{C-c $}} (@code{flyspell-correct-word-before-point}) will pop
-up a menu of possible corrections.  Of course, you can always correct
-the misspelled word by editing it manually in any way you like.
+@kbd{mouse-3} instead, enable @code{context-menu-mode}.  Note, however,
+that @code{flyspell-mode} needs to be enable @emph{after}
+@code{context-menu-mode}, because it will @emph{redefine} the context
+menu already installed there by other modes.  In addition, @kbd{C-.} or
+@kbd{@key{ESC} @key{TAB}} (@code{flyspell-auto-correct-word}) will
+propose various successive corrections for the word at point, and
+@w{@kbd{C-c $}} (@code{flyspell-correct-word-before-point}) will pop up
+a menu of possible corrections.  Of course, you can always correct the
+misspelled word by editing it manually in any way you like, or use
+@w{@kbd{M-$}} @pxref{ispell-word}.
+
+@cindex Ispell Minor Mode
+@cindex mode, Ispell Minor
+@anchor{ispell-minor-mode}
+@findex ispell-minor-mode
+@table @kbd
+@item M-x ispell-minor-mode
+Enable spell-checking of the last typed word only.
+@end table
+
+If @code{flyspell-mode} proves to be too burdensome for your computer,
+or if it is producing too many false positives and visually clutters
+your display, @code{ispell-minor-mode} is a much more lightweight
+alternative, which only checks the last word as you are typing it, and
+shows a brief message in the echo area.
 
+@cindex Flyspell Prog mode
+@cindex mode, Flyspell Prog
+@anchor{flyspell-prog-mode}
 @findex flyspell-prog-mode
+@table @kbd
+@item M-x flyspell-prog-mode
+Enable Flyspell mode for comments and strings only. (Most useful for
+modes based on @code{prog-mode}.)
+@end table
   Flyspell Prog mode works just like ordinary Flyspell mode, except
 that it only checks words in comments and string constants.  This
 feature is useful for editing programs.  Type @w{@kbd{M-x
-- 
2.46.4

-- 
Your sincerely,
Vladimir Nikishkin (MiEr, lockywolf)
(Laptop)