Re: The definition of orig-fn.

[Hongyi Zhao]

On Tue, Oct 5, 2021 at 6:26 PM Emanuel Berg via Users list for the GNU
Emacs text editor <help-gnu-emacs@gnu.org> wrote:
>
> Hongyi Zhao wrote:
>
> > Without further keyboard remapping, this scheme will require
> > at least two keystrokes to complete a candidate insertion.
> > I think abo-abo's customized function is just for solving
> > this type of problem: One keystroke for one
> > candidate insertion.
>
> I don't know if/how related this is, but take a look at this
> [code last - yes, I see I should fix the initial comments ...]
>
> Anyway it works like this, it presents you with shortcuts to
> shown alternatives - the shortcuts are ?\r ?\s ?\t ... and
> so on.
>
> But if you don't hit a shortcut but instead hit, say, the
> letter "l", that letter will be inserted instead.
>
> So if you, for example, have the man page ls(1) open you will
> be presented with
>
>   [ RET:ls ]
>
> You can then hit RET to go to the ls man page buffer. But you
> can also type "ls" just as you would with
>
>   M-x ls RET
>
> and it doesn't require more keystrokes than that.
>
> Very clever if I may, only bummer was I could never find
> another use case but the man pages. A good one by all means
> but nonetheless ...
>
> ;;; buc.el --- move between buffers based on category -*- lexical-binding: t
> ;;;
> ;;; Author: Emanuel Berg (incal) <moasenwood@zoho.eu>
> ;;; Created: 2021-05-23
> ;;; Keywords: docs, files
> ;;; License: GPL3+
> ;;; Package-Requires: ((cl-lib "1.0"))
> ;;; URL: https://dataswamp.org/~incal/emacs-init/buc.el
> ;;; Version: 1.0.4
> ;;;
> ;;; Commentary:
> ;;;
> ;;; This package enables you to move between similar buffers.
> ;;; So far I have only found one use case for it, namely
> ;;; accessing man pages - try `man-buc' below.
> ;;;
> ;;; The general idea behind the interface is to present
> ;;; alternatives based on your recent answers to the same
> ;;; questions. The alternatives are sorted to present you with
> ;;; the most relevant one first. You pick an alternative by
> ;;; hitting a single key. If your desired choice is not among
> ;;; the alternatives, start typing, that will bypass the
> ;;; interface and the default interface will be used as
> ;;; a fallback. (But technically it is not a fallback, rather
> ;;; the interfaces are cooperating covering different parts of
> ;;; one problem.)
> ;;;
> ;;; Note that If you count the number of keypresses you see
> ;;; the advantage with this package. When the buc interface is
> ;;; used, the count is much lower, since making a choice
> ;;; involves hitting a single key or combination. But even
> ;;; when it is not used, the count still is not higher than
> ;;; what you would use anyway, since the default interface
> ;;; immediately comes to life and utilizes the first keydown
> ;;; as its first input char. Again, try `man-buc' to see how
> ;;; it works first hand.
> ;;;
> ;;; Or take a look at this screenshot:
> ;;;
> ;;;   https://dataswamp.org/~incal/dumps/buc.png
> ;;;
> ;;; The principle behind the interface is similar to that of
> ;;; a computer hardware memory cache: proximity in space and
> ;;; time, with updates on every single access.
> ;;;
> ;;; The interface is an hybrid between the GUI and CLI style,
> ;;; only the GUI "icons" are here words! Some say icons are
> ;;; more intuitive than words. Well, that is were we agree to
> ;;; disagree - perhaps that holds for infants but not to
> ;;; adults who have spent a HUGE part of their life reading
> ;;; and writing.
> ;;;
> ;;; Because we believe intuition is an acquired skill - just
> ;;; like everything else.
> ;;;
> ;;; Code:
>
> (require 'cl-lib)
>
> (defvar nav-keys     nil "The keys used to select buffers.")
> (defvar nav-keys-str nil "Descriptions of the buffer-select keys.")
>
> (setq nav-keys    '(?\r ?\s ?\t ?\d ?\C-j ?\C-k ?\C-l ?\C-u ?\C-o ?\C-p))
> (setq nav-keys-str (split-string (key-description nav-keys)))
>
> (defun buffer-names ()
>   "Get the names of all open buffers, as strings."
>   (mapcar #'buffer-name (buffer-list)) )
>
> (defun extract-strings (strings match)
>   "From STRINGS, get a list with the parts that MATCH."
>   (remove nil
>     (mapcar
>      (lambda (s) (when (string-match match s)
>                    (match-string 1 s) ))
>      strings) ))
>
> (defun get-ps (names)
>   "Make the prompt-string, with NAMES."
>   (let ((k -1)
>         (s " [") )
>     (dolist (e names (concat s "] "))
>       (setq s (format "%s %s:%s "
>                       s (nth (cl-incf k) nav-keys-str) e) ))))
>
> (defun navigate-buffer-category (prefix &optional bad-key &rest args)
>   "Display all buffers that start with PREFIX.
> If none of the offered buffers are chosen by the user's keystroke,
> evaluate (BAD-KEY ARGS)."
>   (let ((pages (extract-strings (buffer-names)
>                                 (format "%s%s" prefix "\\(.*\\)\\*") )))
>     (if pages
>         (let*((ps         (get-ps pages))
>               (key        (read-key ps))
>               (page-index (cl-position key nav-keys))
>               (page       (when page-index
>                             (nth page-index pages)) ))
>           (if (= key 7)
>               (message "quit")
>             (if page
>                 (switch-to-buffer (format "%s%s*" prefix page))
>               (when bad-key
>                 (apply bad-key `(,@args ,key)) ))))
>       (if bad-key
>           (apply bad-key args)
>         (error "Empty category and no fallback function") ))))
>
> (defun switch-to-type (ps fun &optional key)
>   "Ask for a string with the prompt-string PS.
> Use the string as input to FUN.
> If KEY, it'll be the first KEY of the string, auto-inserted."
>   (apply fun
>          (list (read-string ps
>                             (when key
>                               (char-to-string key))
>                             nil) )))
>
> (defun man-buc ()
>   "Show man pages.
> If you start typing, you get the common prompt."
>   (interactive)
>   (navigate-buffer-category "*Man "
>                             #'switch-to-type
>                             "[buc] man page: "
>                             'man) )
>
> (provide 'buc)
> ;;; buc.el ends here

Apart from expressing my admiration for your research spirit, I also
see no clues that I can use further.

HZ