Cách nhanh chóng để chuyển đổi một biến

Sẽ rất tốt nếu có một cách nhanh chóng để chuyển đổi một biến. Đây là một cái gì đó mà tôi có trong tâm trí.

• Gọi hàm "chuyển đổi var".
• Chỉ completing-readnên liệt kê các biến có các giá trị đơn (không liệt kê hoặc không tồn tại). Tôi không biết nếu điều đó có thể được thực hiện. Sẽ tốt hơn nữa nếu nó chỉ liệt kê các lọ có giá trị là thoặc nil. Khá chắc chắn rằng điều này không thể được thực hiện.
• Sau đó, hàm đặt giá trị var thành tnếu giá trị hiện tại của nó là nilvà ngược lại.

Câu hỏi là nếu chúng ta đã có một chức năng elisp làm điều này. Nếu không, và nếu mọi người đã giải quyết vấn đề này bằng giải pháp tùy chỉnh của họ, muốn xem họ làm như thế nào.

Cập nhật:

Một tính năng phần thưởng sẽ là làm cho completing-readgợi ý biểu tượng dưới điểm (nếu có) để chuyển đổi.

Vì vậy, nếu "chuyển đổi var" fn bị ràng buộc C-c ~, việc sử dụng sẽ ngắn như C-c ~ RET.

Quy trình hiện tại của tôi để chuyển đổi một var như sau:

• C-h v VAR, nhận giá trị var hiện tại.
• M-: (setq VAR toggled-value).

hoặc là

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

Tôi đang tìm cách để tăng tốc quá trình này (ít gõ).

Đây là một câu trả lời nhanh -

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

Nhưng nếu bạn sử dụng Icicles thì bạn chỉ có thể sử dụng lệnh icicle-toggle-option(với tiền tố phủ định arg, nếu bạn muốn bất kỳ biến nào, và không chỉ là tùy chọn người dùng):

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

Nếu bạn đã cài đặt helm, bạn có thể sử dụng lệnh helm-apropos, nó

• cung cấp giao diện hoàn thành cho tất cả các biến
• có thể chọn mỗi biến tại điểm nếu có
• cung cấp hành động để thay đổi giá trị của biến (bạn cần chèn giá trị mới vào Minibuffer)

lợi thế là bạn có thể tra cứu chuỗi doc của biến và thay đổi giá trị của nó trong một helm-aproposphiên.

Hãy thử lispy-setq để chuyển đổi biến tại điểm hoặc ora-custom-setq từ cấu hình của tôi để đặt biến khi hoàn thành:

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