Expandable 'thing' navigation

[soil-less]

Hello,

I started trying out meow and i wanted to be able to navigate to 'things' using hints as can be done for expanding selections.
So far i have implemented navigation with hints for strings, pairs (round, curly, square, angle), defuns, paragraphs and sentences.

I don't know if it is something that could be integrated into meow or not.

If someone wants to try it you can load the code below and call the interactive functions :

• navtm-inner-*
• navtm-bounds-*
• navtm-expand-*
• navtm-reverse

There are two meow functions overridden (meow--direction-backward-p and meow--direction-forward-p), those are used to display hints by meow functions. Otherwise it should be unobtrusive.

It's the first time i write elisp beyond simple configuration for emacs, so feedback is welcome.

;;; nav-thing-meow --- meow things hint and expand -*- lexical-binding:t; -*-

;;; Commentary:

;; Import file after loading meow

;;; Code:

;;; Strings:
(defun navtm-next-string (direction)
  "Return the point/bounds of the next string in direction.

   DIRECTION can either be `forward' or `backward'."
  (let* (
    (start-bounds (bounds-of-thing-at-point 'string))
    (start (if (eq direction 'forward)
               (if start-bounds (cdr start-bounds) (point))
             (if start-bounds (- (car start-bounds) 1) (point))))
    (search-count (if (eq direction 'forward) '1 '-1)))
    (goto-char start)
    (while (and
      (not (bounds-of-thing-at-point 'string))
      (re-search-forward "[\x27\x22]" nil t search-count)))
      (bounds-of-thing-at-point 'string)))

(defun navtm-next-inner-string (&optional return-bounds)
  "Return the point or the bounds of the next inner string.

   RETURN-BOUNDS if nil or omitted return point,
   if t return bounds."
  (let ((bounds (navtm-next-string 'forward)))
    (when bounds (if return-bounds
        (cons (+ (car bounds) 1) (- (cdr bounds) 1))
      (+ (car bounds) 1)))))

(defun navtm-prev-inner-string (&optional return-bounds)
  "Return the point or the bounds of the previous inner string.

   RETURN-BOUNDS if nil or omitted return point,
   if t return bounds."
  (let ((bounds (navtm-next-string 'backward)))
    (when bounds (if return-bounds
        (cons (+ (car bounds) 1) (- (cdr bounds) 1))
      (+ (car bounds) 1)))))

(defun navtm-inner-string ()
  "Select the current / next inner string."
  (interactive)
  (meow--cancel-selection)
  (let* ((type '(select . string))
         (current-bounds (bounds-of-thing-at-point 'string))
	     (bounds (if current-bounds
             (cons (+ (car current-bounds) 1) (- (cdr current-bounds) 1))
               (navtm-next-inner-string t))))
    (when bounds
      (thread-first
        (meow--make-selection type (cdr bounds) (car bounds))
        (meow--select))
      (setq navtm-thing-direction 'forward)
      (navtm--maybe-highlight-num-positions
       '(navtm-prev-inner-string . navtm-next-inner-string)))))

(defun navtm-next-bounds-string (&optional return-bounds)
  "Return the point or the bounds of the next string.

   RETURN-BOUNDS if nil or omitted return point,
   if t return bounds."
  (let ((bounds (navtm-next-string 'forward)))
    (when bounds (if return-bounds
        bounds
      (car bounds)))))

(defun navtm-prev-bounds-string (&optional return-bounds)
  "Return the point or the bounds of the previous string.

   RETURN-BOUNDS if nil or omitted return point,
   if t return bounds."
  (let ((bounds (navtm-next-string 'backward)))
    (when bounds (if return-bounds
        bounds
      (car bounds)))))

(defun navtm-bounds-string ()
  "Select the current / next string."
  (interactive)
  (meow--cancel-selection)
  (let* ((type '(select . string))
         (current-bounds (bounds-of-thing-at-point 'string))
	     (bounds (if current-bounds
                   current-bounds
                 (navtm-next-bounds-string t))))
    (when bounds
      (thread-first
        (meow--make-selection type (cdr bounds) (car bounds))
        (meow--select))
      (setq navtm-thing-direction 'forward)
      (navtm--maybe-highlight-num-positions
       '(navtm-prev-bounds-string . navtm-next-bounds-string)))))

;;; Pairs:

(defun navtm-create-pair-functions (push pop inner)
  "Define functions for next/previous pair.

   PUSH is the regexp for opening pair.
   POP is the regexp for closing pair.
   INNER is nil for bounds, t for inner pair.
   Those functions are used to hint and expand."
  (defun navtm-next-pair-function (&optional return-bound)
    "Return point/bounds of the next pair.

     RETURN-BOUND is nil or omitted when point should be returned
     and t when bounds should be returned."
    (if return-bound
        (navtm-next-pair push pop inner 'forward)
      (car (navtm-next-pair push pop inner 'forward))))
  (defun navtm-prev-pair-function (&optional return-bound)
    "Return point/bounds of the previous pair.

     RETURN-BOUND is nil or omitted when point should be returned
     and t when bounds should be returned."
  (if return-bound
          (navtm-next-pair push pop inner 'backward)
        (car (navtm-next-pair push pop inner 'backward)))))

(defun navtm-next-pair (push pop inner direction)
  "Return the next inner/bounds pair in direction.

   PUSH is the regexp for the opening pair.
   POP is the regexp for the closing pair.
   INNER is t for inner of pair, nil for bounds of pair.
   DIRECTION is either `forward' or `backward'.
   Moves the point to the beginning of the match if one is found."
  (let* (
    (p (point))
    (start-bounds (progn
             (unless inner (goto-char (+ (point) 1)))
             (meow--thing-pair-function push pop inner)
    ))
    (start-offset
      (if (eq direction 'forward)
           ;; inner ; bounds
        (if inner '1 '2) ;; forward
        (if inner -1 '0) ;; backward
    ))
    (start (if start-bounds (+ (car start-bounds) start-offset) (point)))
    (search-count (if (eq direction 'forward) '1 '-1))
    (search-offset (if (eq direction 'forward) '0 '1)))
    (goto-char start)
    (while (and
      (not (eq (point) (car (meow--thing-pair-function push pop t))))
      (and (re-search-forward push nil t search-count)
           (goto-char (+ (point) search-offset)))))
    (let (( bounds (meow--thing-pair-function push pop t)))
      (if (and bounds (not (eq (car bounds) p)))
          (if inner
              (progn (goto-char (car bounds)) bounds)
            (progn
              (goto-char (- (car bounds) 1))
              (cons (- (car bounds) 1) (+ (cdr bounds) 1))))
        (progn (goto-char p) 'nil)))))

(defun navtm-pair (push pop inner type-name)
  "Select the current / next inner / bounds pair.

   PUSH is the regexp for opening pair.
   POP is the regexp for closing pair.
   INNER is nil for bounds, t for inner pair.
   TYPE-NAME is the type of selection e.g. parenthesis."
  (meow--cancel-selection)
  (let* (
    (type (cons 'select type-name))
    (push push)
    (pop pop)
    (current-bounds (meow--thing-pair-function push pop inner))
    (bounds (if current-bounds
                current-bounds
              (navtm-next-pair push pop inner 'forward))))
    (when bounds
      (navtm-create-pair-functions push pop inner)
      (thread-first
        (meow--make-selection type (cdr bounds) (car bounds))
        (meow--select))
      (setq navtm-thing-direction 'forward)
      (navtm--maybe-highlight-num-positions
       '(navtm-prev-pair-function . navtm-next-pair-function)))))

(defun navtm-inner-round ()
  "Select the current/next inner parenthesis."
  (interactive)
  (navtm-pair "(" ")" 't 'round))
(defun navtm-bounds-round ()
  "Select the current/next parenthesis."
  (interactive)
  (navtm-pair "(" ")" 't 'round))

(defun navtm-inner-square ()
  "Select the current/next inner parenthesis."
  (interactive)
  (navtm-pair "[[]" "[]]" 't 'square))
(defun navtm-bounds-square ()
  "Select the current/next parenthesis."
  (interactive)
  (navtm-pair "[[]" "[]]" 'nil 'square))

(defun navtm-inner-curly ()
  "Select the current/next inner parenthesis."
  (interactive)
  (navtm-pair "{" "}" 't 'curly))
(defun navtm-bounds-curly ()
  "Select the current/next parenthesis."
  (interactive)
  (navtm-pair "{" "}" 'nil 'curly))

(defun navtm-inner-angle ()
  "Select the current/next inner parenthesis."
  (interactive)
  (navtm-pair "<" ">" 't 'angle))
(defun navtm-bounds-angle ()
  "Select the current/next parenthesis."
  (interactive)
  (navtm-pair "<" ">" 'nil 'angle))

;;; Defun: TODO: Add bounds ? Is it really useful ?
(defun navtm-next-defun (direction)
  "Return the point/bounds of the next defun in direction.

   DIRECTION can either be `forward' or `backward'."
  (let* (
    (start-bounds (bounds-of-thing-at-point 'defun))
    (start (if (eq direction 'forward)
               (if start-bounds (+ (cdr start-bounds) 1) (point))
             (if start-bounds (- (car start-bounds) 1) (point))))
    (search-count (if (eq direction 'forward) '1 '-1)))
    (goto-char start)
    (while (and
      (not (bounds-of-thing-at-point 'defun))
      (forward-line search-count)))
      (bounds-of-thing-at-point 'defun)))

(defun navtm-next-inner-defun (&optional return-bounds)
  "Return the point or the bounds of the next inner defun.

   RETURN-BOUNDS if nil or omitted return point,
   if t return bounds."
  (let ((bounds (navtm-next-defun 'forward)))
    (when bounds (if return-bounds
        (cons (car bounds) (- (cdr bounds) 1))
      (+ (car bounds) 1)))))

(defun navtm-prev-inner-defun (&optional return-bounds)
  "Return the point or the bounds of the previous inner defun.

   RETURN-BOUNDS if nil or omitted return point,
   if t return bounds."
  (let ((bounds (navtm-next-defun 'backward)))
    (when bounds (if return-bounds
        (cons (car bounds) (- (cdr bounds) 1))
      (+ (car bounds) 1)))))

(defun navtm-inner-defun ()
  "Select the current/next inner defun."
  (interactive)
  (meow--cancel-selection)
  (let* ((type '(select . defun))
         (current-bounds (bounds-of-thing-at-point 'defun))
	     (bounds (if current-bounds
             (cons (car current-bounds) (- (cdr current-bounds) 1))
               (navtm-next-inner-defun t))))
    (when bounds
      (thread-first
        (meow--make-selection type (cdr bounds) (car bounds))
        (meow--select))
      (setq navtm-thing-direction 'forward)
      (navtm--maybe-highlight-num-positions
       '(navtm-prev-inner-defun . navtm-next-inner-defun)))))

;;; Paragraphs: TODO
(defun navtm-next-paragraph (direction)
  "Return the point/bounds of the next paragraph in direction.

   DIRECTION can either be `forward' or `backward'."
  (let* (
    (start-bounds (bounds-of-thing-at-point 'paragraph))
    (start (if (eq direction 'forward)
               (if start-bounds (+ (cdr start-bounds) 1) (point))
             (if start-bounds (- (car start-bounds) 1) (point))))
    (search-count (if (eq direction 'forward) '1 '-1)))
    (goto-char start)
    (while (and
      (not (bounds-of-thing-at-point 'paragraph))
      (forward-line search-count)))
      (bounds-of-thing-at-point 'paragraph)))

(defun navtm-next-inner-paragraph (&optional return-bounds)
  "Return the point or the bounds of the next inner paragraph.

   RETURN-BOUNDS if nil or omitted return point,
   if t return bounds."
  (let ((bounds (navtm-next-paragraph 'forward)))
    (when bounds (if return-bounds
        (cons (+ (car bounds) 1) (- (cdr bounds) 1))
      (+ (car bounds) 1)))))

(defun navtm-prev-inner-paragraph (&optional return-bounds)
  "Return the point or the bounds of the previous inner paragraph.

   RETURN-BOUNDS if nil or omitted return point,
   if t return bounds."
  (let ((bounds (navtm-next-paragraph 'backward)))
    (when bounds (if return-bounds
        (cons (+ (car bounds) 1) (- (cdr bounds) 1))
      (+ (car bounds) 1)))))

(defun navtm-inner-paragraph ()
  "Select the current/next inner paragraph."
  (interactive)
  (meow--cancel-selection)
  (let* ((type '(select . paragraph))
         (current-bounds (bounds-of-thing-at-point 'paragraph))
	     (bounds (if current-bounds
             (cons (+ (car current-bounds) 1) (- (cdr current-bounds) 1))
               (navtm-next-inner-paragraph t))))
    (when bounds
      (thread-first
        (meow--make-selection type (cdr bounds) (car bounds))
        (meow--select))
      (setq navtm-thing-direction 'forward)
      (navtm--maybe-highlight-num-positions
       '(navtm-prev-inner-paragraph . navtm-next-inner-paragraph)))))

(defun navtm-next-bounds-paragraph (&optional return-bounds)
  "Return the point or the bounds of the next bounds paragraph.

   RETURN-BOUNDS if nil or omitted return point,
   if t return bounds."
  (let ((bounds (navtm-next-paragraph 'forward)))
    (when bounds (if return-bounds
        (cons (+ (car bounds) 1) (+ (cdr bounds) 1))
      (+ (car bounds) 1)))))

(defun navtm-prev-bounds-paragraph (&optional return-bounds)
  "Return the point or the bounds of the previous bounds paragraph.

   RETURN-BOUNDS if nil or omitted return point,
   if t return bounds."
  (let ((bounds (navtm-next-paragraph 'backward)))
    (when bounds (if return-bounds
        (cons (+ (car bounds) 1) (+ (cdr bounds) 1))
      (+ (car bounds) 1)))))

(defun navtm-bounds-paragraph ()
  "Select the current/next bounds paragraph."
  (interactive)
  (meow--cancel-selection)
  (let* ((type '(select . paragraph))
         (current-bounds (bounds-of-thing-at-point 'paragraph))
	     (bounds (if current-bounds
             (cons (+ (car current-bounds) 1) (+ (cdr current-bounds) 1))
               (navtm-next-bounds-paragraph t))))
    (when bounds
      (thread-first
        (meow--make-selection type (cdr bounds) (car bounds))
        (meow--select))
      (setq navtm-thing-direction 'forward)
      (navtm--maybe-highlight-num-positions
       '(navtm-prev-bounds-paragraph . navtm-next-bounds-paragraph)))))

;;; Sentences: TODO: bounds sentence necessary ?
(defun navtm-next-sentence (direction)
  "Return the next bounds of sentence in direction.

   DIRECTION is either `forward' or `backward'."
  (let* (
    (p (point))
    (start-bounds (bounds-of-thing-at-point 'sentence))
    (start (if start-bounds
	       (if (eq direction 'forward)
                    (+ (cdr start-bounds) 1)
                 (- (car start-bounds) 1))
	     (point)))
    (search-count (if (eq direction 'forward) '1 '-1))
    (search-offset (if (eq direction 'forward) '0 '-1)))
    (goto-char start)
    (while (and (not (eq (point)
                         (when (cdr (bounds-of-thing-at-point 'sentence))
                           (+ (cdr (bounds-of-thing-at-point 'sentence))
			      search-offset))))
                (re-search-forward "[\x2E!\x3F]" nil t search-count)))
    (let (( bounds (bounds-of-thing-at-point 'sentence)))
      (if (and bounds (not (eq (car bounds) p)))
              (progn (goto-char (car bounds)) bounds)
        (progn (goto-char p) 'nil)))))

(defun navtm-next-inner-sentence (&optional return-bounds)
  "Return the point or the bounds of the next inner sentence.

   RETURN-BOUNDS if nil or omitted return point,
   if t return bounds."
  (let ((bounds (navtm-next-sentence 'forward)))
    (when bounds (if return-bounds
        (cons (car bounds) (cdr bounds))
      (car bounds)))))

(defun navtm-prev-inner-sentence (&optional return-bounds)
  "Return the point or the bounds of the previous inner sentence.

   RETURN-BOUNDS if nil or omitted return point,
   if t return bounds."
  (let ((bounds (navtm-next-sentence 'backward)))
    (when bounds (if return-bounds
        (cons (car bounds) (cdr bounds))
      (car bounds)))))

(defun navtm-inner-sentence ()
  "Select the current/next inner sentence."
  (interactive)
  (meow--cancel-selection)
  (let* ((type '(select . sentence))
         (current-bounds (bounds-of-thing-at-point 'sentence))
	     (bounds (if current-bounds
             (cons (car current-bounds) (cdr current-bounds))
               (navtm-next-inner-sentence t))))
    (when bounds
      (thread-first
        (meow--make-selection type (cdr bounds) (car bounds))
        (meow--select))
      (setq navtm-thing-direction 'forward)
      (navtm--maybe-highlight-num-positions
       '(navtm-prev-inner-sentence . navtm-next-inner-sentence)))))

;;; Buffer: TODO ?

;;; Window: TODO ?

;;; Lines: TODO ?

;;; Visual Lines: TODO ?

;;; Common:

(defun navtm--select-expandable-p ()
  "Return non-nil if selection is expandable."
  (when (meow-normal-mode-p)
    (when-let ((sel (meow--selection-type)))
      (let ((type (cdr sel)))
        (or (member type navtm-expandable-types)
	    (member type navtm-expandable-things))))))

(defun navtm-reverse ()
  "Reverse hint directions or exchange point and mark.

  If the selection is an expandable thing, reverse hints direction,
  otherwise exchange point and mark.
  This command supports `meow-selection-command-fallback' ?"
  (interactive)
  (meow--with-selection-fallback
  (let ((sel (meow--selection-type)))
    (if (and sel (member (cdr sel) navtm-expandable-things))
      (if (and (bound-and-true-p navtm-thing-direction)
	           (eq 'forward navtm-thing-direction))
        (setq navtm-thing-direction 'backward)
        (setq navtm-thing-direction 'forward))
      (meow--execute-kbd-macro meow--kbd-exchange-point-and-mark))
     (if (member last-command
               '(meow-visit meow-search meow-mark-symbol meow-mark-word))
       (meow--highlight-regexp-in-buffer (car regexp-search-ring))
     (navtm--maybe-highlight-num-positions)))))

(setq navtm-expandable-types '(word line block find till))
(setq navtm-expandable-things '(string round square curly angle defun
				paragraph sentence))
(setq meow-expand-hint-counts '(
  (word . 30) (line . 30) (block . 30) (find . 30) (till . 30) (string . 30)
  (round . 30) (square . 30) (curly . 30) (angle . 30) (defun . 30)
  (paragraph . 30) (sentence . 30)
))

(defun navtm--maybe-highlight-num-positions (&optional nav-functions)
  "Highlight hints if selection is an expandable thing.

  NAV-FUNCTIONS is a cons cell with car the function to call to find previous
  matches and cdr the function to call to find next matches."
  (when (navtm--select-expandable-p)
    (setq meow--expand-nav-function
	  (or nav-functions meow--expand-nav-function))
    (when (and (not (member major-mode meow-expand-exclude-mode-list))
               meow--expand-nav-function)
      (let ((num (alist-get (cdr (meow--selection-type))
			    meow-expand-hint-counts)))
        (meow--highlight-num-positions num)))))


(defun navtm-expand-1 () "Expand 1." (interactive) (navtm-expand 1))
(defun navtm-expand-2 () "Expand 2." (interactive) (navtm-expand 2))
(defun navtm-expand-3 () "Expand 3." (interactive) (navtm-expand 3))
(defun navtm-expand-4 () "Expand 4." (interactive) (navtm-expand 4))
(defun navtm-expand-5 () "Expand 5." (interactive) (navtm-expand 5))
(defun navtm-expand-6 () "Expand 6." (interactive) (navtm-expand 6))
(defun navtm-expand-7 () "Expand 7." (interactive) (navtm-expand 7))
(defun navtm-expand-8 () "Expand 8." (interactive) (navtm-expand 8))
(defun navtm-expand-9 () "Expand 9." (interactive) (navtm-expand 9))
(defun navtm-expand-0 () "Expand 0." (interactive) (navtm-expand 0))
(defun navtm-expand (&optional n)
  "Expand selection by N matches or select the Nth next match.

   If selection is an expandable thing select the Nth next/previous match,
   otherwise call meow-expand."
  (interactive)
  (when (and meow--expand-nav-function
             (region-active-p)
             (meow--selection-type))
    (let* ((n (or n (string-to-number (char-to-string last-input-event)))))
      (if (not (member (cdr (meow--selection-type)) navtm-expandable-things))
          (meow-expand n)
        (let* (
	      (nav-function (if (meow--direction-backward-p)
			       (car meow--expand-nav-function)
			       (cdr meow--expand-nav-function)))
	      (sel-type (cons meow-expand-selection-type
			      (cdr (meow--selection-type)))))
          (save-mark-and-excursion
	        (dotimes (_ n)
		  (setq +tempbounds (funcall nav-function 't))))
	      (when (not (eq nil +tempbounds))
          (thread-first
	    (meow--make-selection sel-type
				  (cdr +tempbounds)
				  (car +tempbounds))
            (meow--select)))
	      (navtm--maybe-highlight-num-positions
	       meow--expand-nav-function))))))

;;; Overrides :

;; Those overrides are necessary because those functions are used
;; by meow itself when determining which direction should be
;; highlighted / expanded.

(defun meow--direction-backward-p ()
  "Return whether we have a backward selection."
  (let ((sel (meow--selection-type)))
    (if (and sel (member (cdr sel) navtm-expandable-things))
      (and (region-active-p) (bound-and-true-p navtm-thing-direction)
	       (eq 'backward navtm-thing-direction))
      (and (region-active-p) (> (mark) (point))))))

(defun meow--direction-forward-p ()
  "Return whether we have a forward selection."
  (let ((sel (meow--selection-type)))
    (if (and sel (member (cdr sel) navtm-expandable-things))
      (and (region-active-p) (bound-and-true-p navtm-thing-direction)
	       (eq 'forward navtm-thing-direction))
      (and (region-active-p) (<= (mark) (point))))))

(provide 'nav-thing-meow)
;;; nav-thing-meow.el ends here

[eshrh]

Wow, nice! I definitely remember people wanting this...

Some small feedback:

• typically we don't write functions that make named functions. what you're trying to do is typically cleaner and better practice with a macro.
• we shouldn't be hard-coding regexps for things like strings. those are syntax dependent and need to be looked up in the syntax table, see meow--bounds-of-string.
• in meow (and in some other parts of emacs like thingatpt), we typically use prefix args to manage direction when it's not super important, so (interactive "P") and (meow--with-negative-argument-p).
• I think it's really annoying to be globally stateful (navtm-thing-direction). I'd rather sacrifice inner/bounds cursor positioning if that's what it takes, it's a nightmare to debug and add features to. Worst case, modify meow--highlight-num-positions to be overridable or something

As an architecture suggestion though, to better integrate with meow we should make use of the meow thing tablemeow--thing-registry which contains functions to select the inner/bounds of an object (when you're already on the object). So, maybe the way to go is to add 1 more element to that plist that specify how to jump to the next object, and how to jump to the previous object. Then, it can integrate with the table popup and so on... for this route you'd only need to implement one function generator for a

• SYMBOL (built into bound-of-thing-at-point, trivial if symbol has forward-op) property, for ex (forward-thing 'paragraph) but otherwise needs to be hardcoded (like string))
• SYNTAX-EXPR (lookup syntax table, trivial)
• REGEXP-EXPR (trivial)
• PAIRED-EXP (trivial)

in particular these may be implemented in meow--thing-parse, and then this would be extensible by the user with no extra boilerplate. It would also give you a lot of things for free, like all pairs, lines, buffer, window, etc. This way we don't need to think about selecting things (already handled by the two existing functions), and both next-inner* and next-bounds* reuse the third function and then pick either the inner-fn or bounds-fn.

[soil-less]

Hello,

Thank you very much for the feedback.

I'm going to look into macros.
I did not know about syntax tables, i took a look at the code of meow--bounds-of-strings and i'm going to read the info pages.

For the way to handle direction i agree and would have preferred to keep the check on whether point was greater than mark.
The problem i encountered is that when you select a pair of parenthesis for example and you want to expand (really narrow) to some inner parenthesis inside your selection you could not do it.
When the point is at the end of the selection, hints and expand functions will only select after it, when the point is at the start of the selection hints and expand functions only select before it.
Something that would be possible would be to set the type of selection to something like (select-forward . round) or (select-backward . round). That avoids creating a new variable for it and the type of selection would be reset by other commands the next time they are used. I don't know if it is a satisfactory solution as it would still mean that you need two different commands to change direction and to switch point and mark.

I will try to integrate with the meow--thing-registry as you recommended, i had seen it but since the functions used by it didn't call meow--maybe-highlight-num-positions i took meow-next-word as the example to follow.
If that is ok i would like to add a variable that can be set by the user to change the behavior of meow-inner-of-thing / meow-bound-of-thing so if you are not inside inner/bounds of the thing it jumps and selects the next one.

[soil-less]

I have set up a temporary repo.
So far i have redefined the thing-registry entries to be of the form:

((inner-fn . (prev-inner-fn . next-inner-fn)) . (bounds-fn . (prev-bounds-fn . next-bounds-fn)))

Redefined thing-parse to use new function generators that provides both the selection and the previous/next functions.

Defined generator functions for :

• symbols
• syntax-expr
• regexp-expr
• paired-expr

Redefined thing-next-string to use syntax tables as you sugested.

I have no clue about what should be done for multi-expressions.

Redefined parse-range-of-thing to get the function for the new entry types.
Defined parse-prev-of-thing and parse-next-of-thing.

I tried to stay as close as possible to the meow naming scheme just replacing meow by navtm to not override existing functions.
I have not registered things or tested everything for now but before going further could you confirm if the approach seems OK (particularly the form of the thing-registry entries) and in line with what you suggested ?

Thank you in advance.

[soil-less]

I have made some progress.

I have for now entries in the thing-registry of the form :

((inner-thing prev-inner-thing next-inner-thing) (bounds-thing prev-bounds-thing next-bounds-thing))

I can now register everything except multi-expressions.
I have the hints end expansion (selection really) working for inner and bounds.

I started implementing start-of/end-of and i ran into a bit of a flaw in what i had done.
For things that can be nested the next end-of-thing cannot be inferred from next-inner-thing or prev-inner-thing.
For example :

( 1
  ( 2 | ( 3 ) )
  ( 4 ( 5 ) )
)

With | being the cursor, the next thing will be pair 3, and the thing after that will be pair 4 and 5, i cannot select the end of pair 2 or pair 1.
And even for pair 4 and 5 if i was to put the hint at the end of the thing as they should be for expending to the end-of-thing, the hints would be out of order.

To be able to select correctly until the end-of-thing i would need to have one more function that looks forward for the pop-token instead of looking for the push-token. That does not seem very elegant.

Or have the following functions defined for each thing : select-inner select-bounds next-inner next-bounds start-of-prev end-of-next with next-inner and next-bounds receiving a direction argument.

Does someone have a better approach or input on how it should be done ?

[DogLooksGood]

A little bit off-topic. Do we need expand things, or we want to navigate on things with same type, just like those features implemented in objed

[semenInRussia]

1. From the description of meow: 0 dependencies!

2. From the description of objed: development on pause!

[soil-less]

Hello,

I personally was mainly interested in the navigation / selection of inner/bounds, very similar to the project you linked.
For inner/bounds things i think navigation fits better than expansion.
For startof/endof things expansion would make more sense imo.