Re: Skipping words with C-<right> like other editors do

[Yuri Khan]

On Mon, Apr 16, 2018 at 3:22 PM, Yuri Khan <yuri.v.khan@gmail.com> wrote:
>>> !text! ---! ^^^! ***! ///! ;;;! aa!-!xx! bb!
>>> !text !--- !^^^ !*** !/// !;;; !aa!-!xx !bb!

> * Emacs makes much fewer stops in comparison with other editors.
> Namely, it stops only at transitions from letters to non-letters,
> while most other editors stop at transitions from letters to
> whitespace, letters to punctuation, and punctuation to whitespace.

I came up with the following functions. Usage:

(require 'yk-word)
(global-set-key [remap forward-word] 'yk-word-forward)
(global-set-key [remap backward-word] 'yk-word-backward)
(global-set-key [remap left-word] 'yk-word-left)
(global-set-key [remap right-word] 'yk-word-right)
(global-set-key [remap kill-word] 'yk-word-kill-forward)
(global-set-key [remap backward-kill-word] 'yk-word-kill-backward)


=== : yk-word.el
(defun yk-word--motion (count skip char-at)
  "Move point COUNT words in the direction defined by SKIP and CHAR-AT."
  (let ((table (make-syntax-table (syntax-table))))
    (modify-syntax-entry ?\n "-" table)
    (with-syntax-table table
      (dotimes (_ count)
        (funcall skip "-")
        (pcase (funcall char-at (point))
          ('nil)
          ((app char-syntax ?w) (funcall skip "w"))
          (_ (funcall skip "^-w"))))))
  t)

(defun yk-word-forward (&optional count)
  "Move point COUNT words forward."
  (interactive "^p")
  (if (and count (> 0 count))
      (yk-word-backward (- count))
    (yk-word--motion (or count 1) #'skip-syntax-forward #'char-after)))

(defun yk-word-backward (&optional count)
  "Move point COUNT words backward."
  (interactive "^p")
  (if (and count (> 0 count))
      (yk-word-forward (- count))
    (yk-word--motion (or count 1) #'skip-syntax-backward #'char-before)))

(defun yk-word-right (&optional count)
  "Move point COUNT words to the right."
  (interactive "^p")
  (if (eq (current-bidi-paragraph-direction) 'left-to-right)
      (yk-word-forward n)
    (yk-word-backward n)))

(defun yk-word-left (&optional count)
  "Move point COUNT words to the left."
  (interactive "^p")
  (if (eq (current-bidi-paragraph-direction) 'left-to-right)
      (yk-word-backward n)
    (yk-word-forward n)))


(defun yk-word-kill-forward (count)
  "Kill COUNT words after point."
  (interactive "p")
  (let ((start (point)))
    (yk-word-forward count)
    (kill-region start (point))))

(defun yk-word-kill-backward (count)
  "Kill COUNT words before point."
  (interactive "p")
  (let ((start (point)))
    (yk-word-backward count)
    (kill-region start (point))))

(defun yk-word-delete-forward (count)
  "Delete COUNT words after point."
  (interactive "p")
  (let ((start (point)))
    (yk-word-forward count)
    (delete-region start (point))))

(defun yk-word-delete-backward (count)
  "Delete COUNT words before point."
  (interactive "p")
  (let ((start (point)))
    (yk-word-backward count)
    (delete-region start (point))))


(provide 'yk-word)