Utilizzo di Paredit per avvolgere l'espressione esistente

Question

Uso Emacs in modalità Paredit per codice Lisp.

Sto cercando di avvolgere una chiamata di funzione in println:

(square 5) 
(println (square 5)) 

ciò che finisce accadendo in paredit è questo:

(square 5) 
(println) (square 5) 

Non c'è modo posso cancellare parentesi di chiusura println e spostarlo fino alla fine.

Il modo in cui sto facendo ora è quello di: 1. Eliminare chiamata di funzione e tirare entro println 2. println scrittura senza parentesi, selezionare visivamente codice e racchiudere in parentesi

(square 5) 
println (square 5) 
=> select block of code and type (
(println (square 5)) 

Entrambi questi approcci sono noiosi. Questo sembra essere un problema comune ogni volta che scrivo il codice dentro a Paredit. Qualsiasi aiuto sarebbe apprezzato

Answer 1

paredit-wrap-round comando può aiutare (legato a M- (in versione paredit io uso).

Answer 2

M- (

È possibile chiamare paredit-insert-html-examples per generare un bigino pagina web HTML. Una versione è here.

Answer 3

Nel tuo caso la soluzione è M-2 M-( o M-(C-).

Answer 4

In contrasto con le altre risposte, tendo a usare Ctrl-Destra per questo: dopo aver ottenuto

(println|) (square 5) 

(dove | è dove si trova il cursore), ho semplicemente premere CTRL-destra per ottenere il risultato corretto.

Answer 5

Io uso MC- (, che immediatamente avvolgere il seguente sexp in parentesi.

Answer 6

Ci sono diversi modi per farlo. Il modo in cui faccio di solito questo è il tipo di

"("

che si ottiene

() println

e poi CS-), che si ottiene

(println)

Il modo migliore per utilizzare paredit per iniziare è disporre del foglio di calcolo paredit su un pezzo di carta attaccato al lato del monitor. Oppure, puoi anche installare il menu paredit che aggiunge una voce di menu con suggerimenti che mostrano gli stessi esempi di cheetsheet.

Answer 7

Tre modi per avvolgere un modulo di stampa attorno a un modulo quadrato, in progressioni progressive.(Due modi dei tre sono già menzionate in altre risposte)

(1) Tagliare & tipo & pasta

(+ (square 3) 4) 
;;; make sure cursor is at right place (| is cursor) 
(+ |(square 3) 4) 
;;; mark-sexp and kill-region 
(+ | 4) 
;;; type the print form and make sure cursor is at right place 
(+ (print |) 4) 
;;; paste 
(+ (print (square 3)) 4) 

(2) digitare & slurf

(+ (square 3) 4) 
;;; make sure cursor is at right place (| is cursor) 
(+ |(square 3) 4) 
;;; type the print form and make sure cursor is at right place 
(+ (print|) (square 3) 4) 
;;; paredit-forward-slurp-sexp 
(+ (print (square 3)) 4) 

(3) avvolgere & type

(+ (square 3) 4) 
;;; make sure cursor is at right place (| is cursor) 
(+ |(square 3) 4) 
;;; paredit-wrap-round 
(+ (|(square 3)) 4) 
;;; type print 
(+ (print (square 3)) 4) 

Taglio & tipo & pasta è il più noioso. Essa non dipende paredit ed è più facile da generalizzare al caso di avvolgere una forma esteriore complessa intorno a più moduli interni che possono essere in formato multilinea, per esempio, tornitura

(let ((x 1)) 
    (moo) 
    (oink) 
    (oink)) 

in

(let ((x 1)) 
    (moo) 
    (mapc (lambda (x) 
      (oink) 
      (oink)) 
     (list 1 2 3))) 

avvolgendo una forma mapc-over-lambda attorno a due oink.

Il tipo & sembra il più conosciuto. Può essere generalizzato anche al caso mapc-over-lambda.

Wrap & tipo è il più semplice da digitare. Quando si generalizza questo al caso map-over-lambda, si selezionano due oink, e si preme ( per avvolgerlo, e si finisce di scrivere il modulo lambda, e selezionare il modulo lambda, premere ( per avvolgerlo, digitare mapc, e si può usa CMf per attraversare il modulo lambda e digitare (lista 1 2 3).