Supprimer les parenthèses autour de la région

Existe-t-il une meilleure alternative à cette fonction que j'utilise pour supprimer les parens autour d'une région? Je recherche un module intégré Emacs, ou quelque chose de mieux écrit, quelque chose qui supprimera toutes les paires autour de la région sélectionnée (ex: crochets, accolades, guillemets doubles, guillemets 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 vous installez des smartparens , vous pouvez utiliser la fonction sp-splice-sexp, qui fait exactement ce que vous demandez. Il fonctionne sur tous les types d'accolades et de guillemets valides, selon le mode principal actuel. Voir les documents pour plus de détails.

Edit: Le principal avantage de smartparensover paredit(voir la réponse de rekado) est qu'il smartparensprend mieux en charge les langues autres que lisp. Il permet également des délimiteurs à plusieurs caractères tels que des guillemets triples en python ou des balises en XML / HTML.

Il y a pareditqui a une fonction paredit-splice-sexp, qui pourrait faire ce que vous voulez.

Dans cet exemple |indique le point:

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

Voici un autre exemple:

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

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

Cependant, cela ne fonctionne pas au niveau supérieur, car cela entraînerait une expression s non valide. Il ne fonctionne pas non plus sur une région mais sur des expressions s.