Eliminar paréntesis alrededor de la región

¿Existe una mejor alternativa a esta función que uso para eliminar a los padres de una región? Estoy buscando un Emacs incorporado, o algo mejor escrito, algo que elimine cualquier par alrededor de la región seleccionada (por ejemplo: corchetes, corchetes, comillas dobles, comillas simples)

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

Si instala smartparens , puede usar la función sp-splice-sexp, que hace exactamente lo que está pidiendo. Funciona en todos los tipos válidos de llaves y comillas, de acuerdo con el modo principal actual. Ver los documentos para más detalles.

Editar: La principal ventaja de smartparensover paredit(ver la respuesta de rekado) es que smartparenstiene un mejor soporte para otros idiomas además de lisp. También permite delimitadores de varios caracteres, como comillas triples en python o etiquetas en XML / HTML.

Hay pareditcuál tiene una función paredit-splice-sexp, que podría hacer lo que quieras.

En este ejemplo |indica punto:

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

Aquí hay otro ejemplo:

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

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

Sin embargo, no funciona en el nivel superior, ya que eso daría como resultado una expresión s no válida. Tampoco no operar en una región, sino en s-expresiones.