Wie benutze ich Flyspell, um das vorherige Wort effizient zu korrigieren?

Von dem Moment an, als ich mit Flyspell anfing, war es immer schmerzhaft, es zu benutzen. Ich überprüfe selten den gesamten Puffer auf falsch geschriebene Wörter. Normalerweise tippe ich ein und sobald ich ein unterstrichenes Wort sehe, möchte ich es sofort korrigieren und mit der Eingabe fortfahren. Dies liegt einfach daran, dass ich befürchte, zu vergessen, das Wort später zu korrigieren, und dass iSpell zu viele falsche Positive ausgibt, wenn ich mit der umfassenden Überprüfung des Puffers beginne. So korrigiere ich Wörter fast immer so schnell wie möglich, während ich tippe.

Hier sind die eingebauten Funktionen, die ich kenne, und die Gründe, warum sie (für mich) nicht effizient sind:

• flyspell-correct-word- Dies ist an einen Mausklick gebunden. Vergiss es, ich werde keine Maus benutzen.

• flyspell-correct-word-before-point- Ich habe es eine Weile benutzt. Es hat zwei Nachteile:

  1. Standardmäßig wird das GUI-Menü angezeigt, das ohne Maus nur schwer zu bedienen ist, und es ist sehr umständlich, wenn Sie eine Liste mit Korrekturen mit mehr als 10 Elementen haben.

  2. Es funktioniert nicht lange vor dem Punkt für ein Wort . Ich tippe schnell und wenn ich falsch geschriebene Wörter finde, habe ich normalerweise ein oder zwei Wörter zwischen dem falsch geschriebenen Wort und dem Punkt. Ich muss Punkt verschieben, Wort korrigieren, zurückkehren. Oh.

• flyspell-auto-correct-word - Siehe Punkt 2 ↑ und es funktioniert nicht gut, wenn Sie eine lange Liste von Abschlüssen haben (wegen Radfahren).

F: Wie kann ich Flyspell effizient einsetzen, mit der Tastatur, in der Lage, aus einer Liste von Vervollständigungen zu wählen, ohne Rad fahren zu müssen, und mit der Fähigkeit, noch mehr oder weniger entfernte Wörter zu korrigieren?

Akzeptable Antworten sind Pakete, mit deren Hilfe Sie zu früheren falsch geschriebenen Wörtern navigieren, diese korrigieren und zurückkehren können, sowie kleine Ausschnitte, möglicherweise aus Ihrer eigenen Konfigurationsdatei, da ich glaube, dass andere Leute ihre Möglichkeiten gefunden haben, effizient mit Flyspell zu interagieren.

Das eingebaute flyspell-auto-correct-previous-wordwirkt wie ein Zauber für mich. Ich habe es gebunden F12und ich habe nicht zurückgeschaut. Es hat für mich durchweg richtige Wörter, egal wie viele Wörter zurück das falsche Wort waren.

Aus der Funktionsdokumentation:

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.

Wenn die Autokorrektur beim ersten Mal nicht das richtige Wort ergab, drücken Sie weiterhin auf Ihren gebundenen Schlüssel ( F12in meinem Fall), um alle Optionen zu durchlaufen.

[Meine Rechtschreibprüfung]

Ich bin mir ziemlich sicher, dass andere Leute andere Lösungen finden werden, die für zukünftige Leser nützlich sein werden. Hier ist jedoch, wie ich derzeit damit umgehe.

Ich denke, es flyspell-correct-word-before-pointist ein guter Anfang, da es zumindest per Tastendruck aufgerufen werden kann und ein Menü mit möglichen Korrekturen anzeigt. Um das Menü zu reparieren, habe ich das Paket Ace Popup Menu geschrieben , das Avy als Backend verwendet. Dies ersetzt das GUI-Popup-Menü, das flyspell-correct-word-before-pointverwendet (die Funktion wird aufgerufen x-popup-menu), durch ein Text-Popup-Menü, das beschriftete Menüelemente anzeigt: Ein oder zwei Tastenanschläge, und Sie sind fertig.

Um das zweite Problem zu lösen (Unfähigkeit, Wörter "auf Distanz" zu korrigieren), habe ich diesen Helfer geschrieben:

(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))

Das scheint zu funktionieren.

Mit helm-flyspell können Sie effizient aus der Liste der Korrekturen auswählen. Ich verwende den folgenden Code, um zu den Fehlern zu springen und sie damit zu korrigieren. Er speichert die Position des Punkts an der Stelle, an der mark-ringSie zuvor begonnen oder Wörter korrigiert haben.

(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"))