จะเปลี่ยนวงเล็บที่ตรงกันได้อย่างไร

ฉันเขียน (และเขียนใหม่) สูตรทางคณิตศาสตร์จำนวนมากใน LaTeX กับ Emacs ฉันมักจะเจอสถานการณ์ที่ฉันต้องการเปลี่ยนวงเล็บคู่ที่ตรงกันเพื่อปรับปรุงความสามารถในการอ่าน Emacs ของฉันใจดีพอที่จะแสดงตัวคั่นที่ตรงกัน แต่ฉันจะเปลี่ยนเป็นโปรแกรมได้อย่างไร

ตัวอย่างเช่นเปลี่ยนตัวคั่นภายนอกในครั้งเดียว:

( (\sqrt{a} + b)^{-1} + c^{-1} )

ถึง

[ (\sqrt{a} + b)^{-1} + c^{-1} ]

ใช้smartparensแพ็คเกจ มันมีฟังก์ชั่นที่เรียกว่าsp-rewrap-sexpซึ่งเป็นสิ่งที่คุณต้องการ หน้าแรกของโครงการ ( https://github.com/Fuco1/smartparens ) มี gif บางตัวที่แสดงการทำงานอย่างชัดเจน

สำหรับผู้ที่ใช้ความชั่วคุณสามารถใช้ความชั่วร้ายล้อมรอบซึ่งทำให้คุณc sเคลื่อนไหว (เปลี่ยน, ล้อมรอบ)

สำหรับตัวอย่างของคุณให้ทำc s ( [(การเคลื่อนไหวจากประเภทของ paren ไปยังประเภท paren)

ผมใช้โค้ดด้านล่างและผูกไปyf/replace-or-delete-pairM-D

ตัวอย่างการใช้งาน: ด้วยจุดบน(ฉันตีM-D [และ()ทั้งคู่กลายเป็น[]คู่ หากคุณกดM-D RETแทนทั้งคู่จะถูกลบออก

รหัสนี้ใช้ตารางไวยากรณ์ซึ่งหมายความว่าสำหรับบางคู่คุณจะต้องระบุการปิด paren ด้วยตัวคุณเอง เช่นใน html โหมด()สามารถถูกแทนที่ด้วยโดยการกดปุ่ม<> M-D <อย่างไรก็ตามในหลายโหมด<>ไม่ใช่คู่ที่รู้จักและM-D <จะพูดว่า "ไม่ทราบวิธีปิด <" คุณสามารถพิมพ์>ได้

(defun yf/replace-or-delete-pair (open)
  "Replace pair at point by OPEN and its corresponding closing character.
The closing character is lookup in the syntax table or asked to
the user if not found."
  (interactive
   (list
    (read-char
     (format "Replacing pair %c%c by (or hit RET to delete pair):"
             (char-after)
             (save-excursion
               (forward-sexp 1)
               (char-before))))))
  (if (memq open '(?\n ?\r))
      (delete-pair)
    (let ((close (cdr (aref (syntax-table) open))))
      (when (not close)
        (setq close
              (read-char
               (format "Don't know how to close character %s (#%d) ; please provide a closing character: "
                       (single-key-description open 'no-angles)
                       open))))
      (yf/replace-pair open close))))

(defun yf/replace-pair (open close)
  "Replace pair at point by respective chars OPEN and CLOSE.
If CLOSE is nil, lookup the syntax table. If that fails, signal
an error."
  (let ((close (or close
                   (cdr-safe (aref (syntax-table) open))
                   (error "No matching closing char for character %s (#%d)"
                          (single-key-description open t)
                          open)))
        (parens-require-spaces))
    (insert-pair 1 open close))
  (delete-pair)
  (backward-char 1))

ar-parentized2bracketed-atpt จะทำภารกิจ

มันมาพร้อมกับar-braced2parentized-atptและชุดค่าผสมทั้งหมดตามลำดับ

รับจาก thingatpt-transform-delimited.el ของ

URL: https://github.com/andreas-roehler/thing-at-point-utils

คลาสที่เป็นคำสั่งที่เป็นนามธรรมจะแปลงรูปแบบที่คั่นด้วยตัวอย่างเช่น:

ar-delimited2bracketed-atpt

คำสั่งเหล่านี้จะถูกส่งใน repo เดียวกันโดย

thingatpt-เปลี่ยนทั่วไป-delimited.el

show-paren-modeวงเล็บที่ตรงกันจะมองเห็นด้วย วิธีการแบบลอจิคัลคือการสร้างฟังก์ชันพื้นฐานเพื่อเปลี่ยน parens เป็นตรรกะและฟังก์ชันพื้นฐานที่เหมือนกัน เมื่อจับคู่ parens ถูกไฮไลต์คุณสามารถเรียกใช้ฟังก์ชันที่toggle-parensกำหนดไว้ด้านล่าง:

(defun toggle-parens ()
  "Toggle parens () <> [] at cursor.

Turn on `show-paren-mode' to see matching pairs of parentheses
and other characters in buffers. This function then uses the same
function `show-paren-data-function' to find and replace them with
the other pair of brackets.

This function can be easily modified and expanded to replace
other brackets. Currently, mismatch information is ignored and
mismatched parens are changed based on the left one."
  (interactive)
  (let* ((parens (funcall show-paren-data-function))
         (start (if (< (nth 0 parens) (nth 2 parens))
                    (nth 0 parens) (nth 2 parens)))
         (end (if (< (nth 0 parens) (nth 2 parens))
                  (nth 2 parens) (nth 0 parens)))
         (startchar (buffer-substring-no-properties start (1+ start)))
         (mismatch (nth 4 parens)))
    (when parens
      (pcase startchar
        ("(" (toggle-parens--replace "[]" start end))
        ("[" (toggle-parens--replace "()" start end))))))

(defun toggle-parens--replace (pair start end)
  "Replace parens with a new PAIR at START and END in current buffer.

A helper function for `toggle-parens'."
  (goto-char start)
  (delete-char 1)
  (insert (substring pair 0 1))
  (goto-char end)
  (delete-char 1)
  (insert (substring pair 1 2)))