Come usare Flyspell per correggere efficacemente la parola precedente?

Dal momento in cui ho iniziato a usare Flyspell, è sempre stato doloroso da usare. Raramente controllo l'intero buffer alla ricerca di parole errate, di solito scrivo e una volta che vedo una parola sottolineata voglio correggerla all'istante e continuare a digitare. Questo è semplicemente perché ho paura di dimenticare di correggere la parola in seguito e perché quando inizio il controllo completo del buffer, iSpell dà troppi falsi positivi. Quindi, quasi sempre correggo le parole il prima possibile mentre scrivo.

Ecco le funzioni integrate che conosco e le ragioni per cui non sono efficienti (per me):

• flyspell-correct-word- Questo è legato al clic del mouse. Lascia perdere, non ho intenzione di usare il mouse.

• flyspell-correct-word-before-point- L'ho usato per un po 'di tempo. Ha due aspetti negativi:

  1. Per impostazione predefinita, mostra il menu della GUI che è difficile da usare senza il mouse ed è davvero ingombrante quando si dispone di un elenco di correzioni con più di 10 voci.

  2. Non funziona a parole molto prima. Scrivo velocemente e quando rilevo una parola errata in genere ho una o due parole tra la parola e il punto errati. Devo spostare il punto, correggere la parola, tornare indietro. Oh.

• flyspell-auto-correct-word - Vedi punto 2 ↑ in più non funziona bene quando hai una lunga lista di completamenti (a causa del ciclismo).

D: Come posso usare Flyspell in modo efficiente, con la tastiera, potendo scegliere dall'elenco dei completamenti senza andare in bicicletta e con la possibilità di correggere parole ancora più o meno distanti?

Le risposte accettabili includono pacchetti che aiutano a navigare verso una parola errata, correggerla e tornare indietro o qualcosa del genere, così come piccoli frammenti, possibilmente dal tuo file di configurazione, dal momento che credo che altre persone abbiano trovato il modo di interagire in modo efficiente con Flyspell.

L'integrato flyspell-auto-correct-previous-wordfunziona come un incantesimo per me. L'ho legato F12e non ho guardato indietro. Ha sempre parole correttamente corrette per me, non importa quante parole siano state errate.

Dalla documentazione della funzione:

flyspell-auto-correct-previous-word is an interactive compiled Lisp
function in `flyspell.el'.

(flyspell-auto-correct-previous-word POSITION)

For more information check the manuals.

Auto correct the first misspelled word that occurs before point.
But don't look beyond what's visible on the screen.

Inoltre, se la prima volta la correzione automatica non ti ha dato la parola giusta, continua a premere la chiave associata ( F12nel mio caso) per scorrere tutte le opzioni.

[Configura controllo ortografico]

Sono abbastanza sicuro che altre persone troveranno diverse soluzioni che saranno utili per i futuri lettori. Tuttavia, ecco come lo gestisco attualmente.

Penso che flyspell-correct-word-before-pointsia un buon punto di partenza, perché almeno può essere invocato premendo il tasto e visualizza il menu delle possibili correzioni. Per correggere il menu ho scritto il pacchetto Ace Popup Menu che usa Avy come backend. Questo sostituisce il menu a comparsa della GUI che flyspell-correct-word-before-pointutilizza (la funzione viene chiamata x-popup-menu) con il menu a comparsa testuale che presenta le voci di menu etichettate: uno o due tasti e il gioco è fatto.

Per risolvere il secondo problema (incapacità di correggere le parole "a distanza") ho scritto questo aiuto:

(defun flyspell-correct-previous (&optional words)
  "Correct word before point, reach distant words.

WORDS words at maximum are traversed backward until misspelled
word is found.  If it's not found, give up.  If argument WORDS is
not specified, traverse 12 words by default.

Return T if misspelled word is found and NIL otherwise.  Never
move point."
  (interactive "P")
  (let* ((Δ (- (point-max) (point)))
         (counter (string-to-number (or words "12")))
         (result
          (catch 'result
            (while (>= counter 0)
              (when (cl-some #'flyspell-overlay-p
                             (overlays-at (point)))
                (flyspell-correct-word-before-point)
                (throw 'result t))
              (backward-word 1)
              (setq counter (1- counter))
              nil))))
    (goto-char (- (point-max) Δ))
    result))

Questo sembra funzionare.

Con helm-flyspell puoi scegliere in modo efficiente dall'elenco delle correzioni. Uso il seguente codice per saltare agli errori e correggerli con esso, salva la posizione del punto in mark-ringmodo da poter tornare alla posizione in cui hai iniziato o corretto le parole in precedenza:

(defun flyspell-goto-previous-error (arg)
  "Go to arg previous spelling error."
  (interactive "p")
  (while (not (= 0 arg))
    (let ((pos (point))
          (min (point-min)))
      (if (and (eq (current-buffer) flyspell-old-buffer-error)
               (eq pos flyspell-old-pos-error))
          (progn
            (if (= flyspell-old-pos-error min)
                ;; goto beginning of buffer
                (progn
                  (message "Restarting from end of buffer")
                  (goto-char (point-max)))
              (backward-word 1))
            (setq pos (point))))
      ;; seek the next error
      (while (and (> pos min)
                  (let ((ovs (overlays-at pos))
                        (r '()))
                    (while (and (not r) (consp ovs))
                      (if (flyspell-overlay-p (car ovs))
                          (setq r t)
                        (setq ovs (cdr ovs))))
                    (not r)))
        (backward-word 1)
        (setq pos (point)))
      ;; save the current location for next invocation
      (setq arg (1- arg))
      (setq flyspell-old-pos-error pos)
      (setq flyspell-old-buffer-error (current-buffer))
      (goto-char pos)
      (if (= pos min)
          (progn
            (message "No more miss-spelled word!")
            (setq arg 0))))))


(defun check-previous-spelling-error ()
  "Jump to previous spelling error and correct it"
  (interactive)
  (push-mark-no-activate)
  (flyspell-goto-previous-error 1)
  (call-interactively 'helm-flyspell-correct))

(defun check-next-spelling-error ()
  "Jump to next spelling error and correct it"
  (interactive)
  (push-mark-no-activate)
  (flyspell-goto-next-error)
  (call-interactively 'helm-flyspell-correct))

(defun push-mark-no-activate ()
  "Pushes `point' to `mark-ring' and does not activate the region
 Equivalent to \\[set-mark-command] when \\[transient-mark-mode] is disabled"
  (interactive)
  (push-mark (point) t nil)
  (message "Pushed mark to ring"))