Go to the previous, next section.

Commands for Fixing Typos

In this chapter we describe the commands that are especially useful for the times when you catch a mistake in your text just after you have made it, or change your mind while composing text on line.

Killing Your Mistakes

Delete last character (delete-backward-char).
Kill last word (backward-kill-word).
Kill to beginning of sentence (backward-kill-sentence).

The DEL character (delete-backward-char) is the most important correction command. When used among graphic (self-inserting) characters, it can be thought of as canceling the last character typed.

When your mistake is longer than a couple of characters, it might be more convenient to use M-DEL or C-x DEL. M-DEL kills back to the start of the last word, and C-x DEL kills back to the start of the last sentence. C-x DEL is particularly useful when you change your mind about the phrasing of the text you are writing. M-DEL and C-x DEL save the killed text for C-y and M-y to retrieve. See section Yanking.

M-DEL is often useful even when you have typed only a few characters wrong, if you know you are confused in your typing and aren't sure exactly what you typed. At such a time, you cannot correct with DEL except by looking at the screen to see what you did. It requires less thought to kill the whole word and start over again.

Transposing Text

Transpose two characters (transpose-chars).
Transpose two words (transpose-words).
Transpose two balanced expressions (transpose-sexps).
C-x C-t
Transpose two lines (transpose-lines).

The common error of transposing two characters can be fixed, when they are adjacent, with the C-t command (transpose-chars). Normally, C-t transposes the two characters on either side of point. When given at the end of a line, rather than transposing the last character of the line with the newline, which would be useless, C-t transposes the last two characters on the line. So, if you catch your transposition error right away, you can fix it with just a C-t. If you don't catch it so fast, you must move the cursor back to between the two transposed characters. If you transposed a space with the last character of the word before it, the word motion commands are a good way of getting there. Otherwise, a reverse search (C-r) is often the best way. See section Searching and Replacement.

M-t (transpose-words) transposes the word before point with the word after point. It moves point forward over a word, dragging the word preceding or containing point forward as well. The punctuation characters between the words do not move. For example, `FOO, BAR' transposes into `BAR, FOO' rather than `BAR FOO,'.

C-M-t (transpose-sexps) is a similar command for transposing two expressions (see section Lists and Sexps), and C-x C-t (transpose-lines) exchanges lines. They work like M-t except in determining the division of the text into syntactic units.

A numeric argument to a transpose command serves as a repeat count: it tells the transpose command to move the character (word, sexp, line) before or containing point across several other characters (words, sexps, lines). For example, C-u 3 C-t moves the character before point forward across three other characters. It would change `f-!-oobar' into `oobf-!-ar'. This is equivalent to repeating C-t three times. C-u - 4 M-t moves the word before point backward across four words. C-u - C-M-t would cancel the effect of plain C-M-t.

A numeric argument of zero is assigned a special meaning (because otherwise a command with a repeat count of zero would do nothing): to transpose the character (word, sexp, line) ending after point with the one ending after the mark.

Case Conversion

M-- M-l
Convert last word to lower case. Note Meta-- is Meta-minus.
M-- M-u
Convert last word to all upper case.
M-- M-c
Convert last word to lower case with capital initial.

A very common error is to type words in the wrong case. Because of this, the word case-conversion commands M-l, M-u and M-c have a special feature when used with a negative argument: they do not move the cursor. As soon as you see you have mistyped the last word, you can simply case-convert it and go on typing. See section Case Conversion Commands.

Checking and Correcting Spelling

This section describes the commands to check the spelling of a single word or of a portion of a buffer.

Check and correct spelling of word at point (ispell-word).
M-x ispell-buffer
Check and correct spelling of each word in the buffer.
M-x ispell-region
Check and correct spelling of each word in the region.
M-x ispell-string RET word RET
Check spelling of word.
M-x ispell-complete-word
Complete the word before point based on the spelling dictionary.
M-x reload-ispell
Make the Ispell subprocess reread your private dictionary.
M-x kill-ispell
Kill the Ispell subprocess.

To check the spelling of the word around or next to point, and optionally correct it as well, use the command M-$ (ispell-word). If the word is not correct, the command offers you various alternatives for what to do about it.

To check the entire current buffer, use M-x ispell-buffer. Use M-x ispell-region to check just the current region. Each time these commands encounter an incorrect word, they ask you what to do.

Whenever one of these commands finds an incorrect word, it displays a list of alternatives, usually including several "near-misses"---words that are close to the word being checked. Here are the valid responses:

Skip this word--continue to consider it incorrect, but don't change it here.

r new RET
Replace the word (just this time) with new.

Replace the word (just this time) with one of the displayed near-misses. Each near-miss is listed with a digit; type that digit to select it.

Accept the incorrect word--treat it as correct, but only in this editing session.

Insert this word in your private dictionary file so that Ispell will consider it correct it from now on, even in future sessions.

l regexp RET
Look in the dictionary for words that match regexp. These words become the new list of "near-misses"; you can select one of them to replace with by typing a digit.

Quit interactive spell checking. You can restart it again afterward with C-u M-$.

The command ispell-complete-word, which is bound to the key M-TAB in Text mode and related modes, performs completion based on spelling correction. Insert the beginning of a word, and then type M-TAB; the command inserts as many more letters as can be uniquely determined from the letters in the buffer, based on your currently loaded dictionaries. See section Text Mode.

The first time you use any of the spell checking commands, it starts an Ispell subprocess. The first thing the subprocess does is read your private dictionary, which is the file `~/ispell.words'. Words that you "insert" with the i command are added to that file, but not right away--only at the end of the interactive replacement procedure. Use the M-x reload-ispell command to reload your private dictionary from `~/ispell.words' if you edit the file outside of Ispell.

Once started, the Ispell 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 Ispell process, use M-x kill-ispell. This is not usually necessary, since the process uses no time except when you do spelling correction.

Go to the previous, next section.