Cara cepat untuk beralih variabel

Alangkah baiknya memiliki cara cepat untuk beralih variabel. Inilah sesuatu yang ada dalam pikiran saya.

• Panggil fungsi "toggle var".
• The completing-readseharusnya hanya daftar variabel yang memiliki nilai tunggal (bukan daftar atau alists). Saya tidak tahu apakah itu bisa dilakukan. Akan lebih baik jika daftar hanya vars yang memiliki nilai sebagai tatau nil. Cukup yakin ini tidak bisa dilakukan.
• Fungsi kemudian menetapkan nilai var ke tjika nilai saat ini adalah nil, dan sebaliknya.

Pertanyaannya adalah apakah kita sudah memiliki fungsi elisp yang melakukan ini. Jika tidak, dan jika orang telah mengatasi masalah ini dengan solusi khusus mereka, ingin melihat bagaimana mereka melakukannya.

Memperbarui:

Fitur bonus adalah untuk membuat completing-readsaran simbol di bawah titik (jika ada) untuk beralih.

Jadi jika "toggle var" fn terikat C-c ~, penggunaannya akan sesingkat C-c ~ RET.

Prosedur saya saat ini untuk beralih var adalah sebagai berikut:

• C-h v VAR, dapatkan nilai var saat ini.
• M-: (setq VAR toggled-value).

atau

• M-: (setq VAR (not VAR)).

Saya mencari cara untuk mempercepat proses ini (kurang mengetik).

Inilah jawaban cepat -

(defun my-toggle-var (var)
  "..."
  (interactive
   (let* ((def  (variable-at-point))
          (def  (and def 
                     (not (numberp def))
                     (memq (symbol-value def) '(nil t))
                     (symbol-name def))))
     (list
      (completing-read
       "Toggle value of variable: "
       obarray (lambda (c)
                 (unless (symbolp c) (setq c  (intern c)))
                 (and (boundp c)  (memq (symbol-value c) '(nil t))))
       'must-confirm nil 'variable-name-history def))))
  (let ((sym  (intern var)))
    (set sym (not (symbol-value sym)))
    (message "`%s' is now `%s'" var (symbol-value sym))))

Tetapi jika Anda menggunakan Icicles maka Anda bisa menggunakan perintah icicle-toggle-option(dengan arg awalan negatif, jika Anda menginginkan variabel apa pun, dan bukan hanya opsi pengguna):

icicle-toggle-option is an interactive compiled Lisp function in
`icicles-cmd1.el'.

It is bound to menu-bar options icicles icicle-toggle-option.

(icicle-toggle-option)

Toggle option’s value.  This makes sense for binary (toggle) options.
By default, completion candidates are limited to user options that
have ‘boolean’ custom types.  However, there are many "binary" options
that allow other non-nil values than t.

You can use a prefix argument to change the set of completion
candidates, as follows:

 - With a non-negative prefix arg, all user options are candidates.
 - With a negative prefix arg, all variables are candidates.

Read input, then act on it.

Input-candidate completion and cycling are available.  While cycling,
these keys with prefix ‘C-’ are active:

‘C-mouse-2’, ‘C-return’ - Act on current completion candidate only
‘C-down’, ‘C-wheel-down’ - Move to next completion candidate and act
‘C-up’, ‘C-wheel-up’ - Move to previous completion candidate and act
‘C-next’  - Move to next apropos-completion candidate and act
‘C-prior’ - Move to previous apropos-completion candidate and act
‘C-end’   - Move to next prefix-completion candidate and act
‘C-home’  - Move to previous prefix-completion candidate and act
‘C-!’     - Act on *all* candidates, successively (careful!)

When candidate action and cycling are combined (e.g. ‘C-next’), user
option ‘icicle-act-before-cycle-flag’ determines which occurs first.

With prefix ‘C-M-’ instead of ‘C-’, the same keys (‘C-M-mouse-2’,
‘C-M-RET’, ‘C-M-down’, and so on) provide help about candidates.

Use ‘mouse-2’, ‘RET’, or ‘S-RET’ to finally choose a candidate, or
‘C-g’ to quit.

This is an Icicles command - see command ‘icicle-mode’.

(defun toggle-variable (variable)
  (interactive
   (let ((v (variable-at-point))
         val)
     (setq val (completing-read (if (symbolp v)
                                    (format
                                     "Toggle variable (default %s (= %s)): " v (symbol-value v))
                                  "Toggle variable: ")
                                obarray
                                'boundp
                                t nil nil
                                (if (symbolp v) (symbol-name v))))
     (list (if (equal val "")
               v (intern val)))))
  (set variable (not (symbol-value variable)))
  (message "%s toggled (= %s)" variable (symbol-value variable)))

Jika Anda telah menginstal helm, Anda dapat menggunakan perintah helm-apropositu

• menyediakan antarmuka penyelesaian untuk semua variabel
• dapat memilih variabel pada titik jika ada
• memberikan tindakan untuk mengubah nilai variabel (Anda perlu memasukkan nilai baru di Minibuffer)

keuntungannya adalah Anda dapat mencari string dokumen dan mengubah nilainya dalam satu helm-apropossesi.

Coba lispy-setq untuk beralih variabel pada titik atau ora-custom-setq dari konfigurasi saya untuk mengatur variabel dengan penyelesaian:

(defun ora-custom-setq ()
  "Set a custom variable, with completion."
  (interactive)
  (let ((sym (intern
              (ivy-read "Variable: "
                        (counsel-variable-list))))
        sym-type
        cands)
    (when (and (boundp sym)
               (setq sym-type (get sym 'custom-type)))
      (cond
        ((and (consp sym-type)
              (memq (car sym-type) '(choice radio)))
         (setq cands (mapcar #'lispy--setq-doconst (cdr sym-type))))
        ((eq sym-type 'boolean)
         (setq cands
               '(("nil" . nil) ("t" . t))))
        (t
         (error "Unrecognized custom type")))
      (let ((res (ivy-read (format "Set (%S): " sym) cands)))
        (when res
          (setq res
                (if (assoc res cands)
                    (cdr (assoc res cands))
                  (read res)))
          (eval `(setq ,sym ,res)))))))