Rimuovere le parentesi nella regione

Esiste un'alternativa migliore a questa funzione che utilizzo per rimuovere le parentesi in una regione? Sto cercando un built-in Emacs, o qualcosa di meglio scritto, qualcosa che rimuoverà qualsiasi coppia intorno alla regione selezionata (es: parentesi, parentesi graffe, doppie virgolette, virgolette singole)

(defun my-delete-surrounded-parens ()
  (interactive)
  ;; save where region begins & ends                                                                            
  (let ((beginning (region-beginning))
        (end (region-end)))
    (cond ((not (eq (char-after beginning) ?\())
           ;; if region not begins by (, trigger error                                                          
           (error "Char at region-begin not an open-parens"))
          ((not (eq (char-before end) ?\)))
           ;; if region not ends by ), trigger error                                                            
           (error "Char at region-end not a close-parens"))
          ;; save mark, pt, current buffer & execute body                                                       
          ((save-excursion
             (goto-char beginning)
             (forward-sexp)
             (not (eq (point) end)))
           ;; if parens are not balanced, trigger error                                                         
           (error "parens not balanced"))
          (t (save-excursion
               (goto-char end)
               (delete-char -1)
               (goto-char beginning)
               (delete-char 1)))))) 

Se installi smartparens , puoi utilizzare la funzione sp-splice-sexp, che fa esattamente quello che stai chiedendo. Funziona su tutti i tipi validi di parentesi graffe e virgolette, secondo l'attuale modalità principale. Vedi i documenti per maggiori dettagli.

Modifica: il vantaggio principale di smartparensover paredit(vedi la risposta di rekado) è che smartparensha un supporto migliore per lingue diverse da lisp. Consente inoltre delimitatori multi-carattere come le virgolette triple in Python o i tag in XML / HTML.

C'è pareditquale ha una funzione paredit-splice-sexp, che potrebbe fare quello che vuoi.

In questo esempio |indica il punto:

(hello world "no |way")  ; run paredit-splice-sexp
(hello world no way)

Ecco un altro esempio:

(let ((a b))
  (fo|rmat #t "meh")) ; run paredit-splice-sexp

(let ((a b))
  format #t "meh")

Lo fa Non lavoro al livello superiore, però, perché questo si tradurrebbe in un invalido s-espressione. Inoltre, non opera su una regione ma su espressioni-s.