Emakso kaj Paroj

Esperante · English
la 9-an de Julio 2018
Laste ŝanĝita: la 9-an de Julio 2018

La blanka bruo kiu batas ene la blanka mallumo estas la ritmo de la vivo; estas la pulso kiu neniam vere foriris la podion.
―Ergo PROXY, Ergo Proxy

En ĉi tiu artikolo, mi eksklusive parolas pri smartparens—pako kiun oni esperis, ke oni jam uzis antaŭe, supozante ĝin oni ne jam uzis. Se oni estas komencanto pri ĝi, laŭlegu; se ne, ĉi tio eble estas bona memorigilo.

smartparens estas unu el tiuj pakoj kiu draste plibonigas, kaj ŝanĝas kiel emakson oni uzas. Similas al kibernetikajn membrojn—onin igas por pli alte salti kaj pli forte pugnobati.

Tenu en la kalkulo, ke la nomo estas iomete malprava tial, ke ne nur rondajn krampojn ĝi traktas. Ankaŭ iujn ajn kiuj pariĝas ĝi traktas, kaj ilin ĝi traktas stele.

Enhavotabelo

Instalo

Na smartparens instali simplas:

M-x package-install REV smartparens REV

Agordaĵo

Na smartparens oni ŝaltu en la startigo, kaj ĝin oni kroĉu al egaj kroĉiloj:

(use-package smartparens-config
    :ensure smartparens
    :config
    (progn
      (show-smartparens-global-mode t)))

(add-hook 'prog-mode-hook 'turn-on-smartparens-strict-mode)
(add-hook 'markdown-mode-hook 'turn-on-smartparens-strict-mode)

Uzado

Parigitajn karakterojn kiel rondaj krampoj, kurbaj krampoj, kvadrataj krampoj, citiloj, angulaj krampoj, kaj aliaj koncepteblaj parigeblaj karakteroj mastrumi jam estas ĉiam doloraj. Tiun problemon aliaj pakoj solvas parte. Bedaŭrinde, kelkajn punktojn ili maltrafas.

En la kodetoj ĉi-sube, la ^ simbolo estos uzita por la punkton reprezenti.

Bazaj

Smartparens-e, kiam parigeblan karakteron oni enigas:


(defn foo )
          ^

la kongruan paron ankaŭ eniĝas, kaj la punkto estas poziciita ene la paro:


(defn foo [])
           ^

Navigado

Komencoj kaj finoj

Sa le jenan esprimon oni havas:


(let [x "foo bar baz ... blah"])
                         ^

kaj la punkton oni volas movi en la komenco de la signovico:


(let [x "foo bar baz ... blah"])
         ^

Na sp-beginning-of-sexp plenumu. Ĝin mi bindis al C-M-a.

Male, por la punkton movi al la fino de la esprimo:


(let [x "foo bar baz ... blah"])
                             ^

Na sp-end-of-sexp plenumu. Ĝin mi bindis al C-M-e.

Listojn trairi

Se la jenan esprimon oni havas:


(defun format-date (format)
  (let ((system-time-locale "en_US.UTF-8"))
    (insert (format-time-string format)))) ^

kaj la punkton oni volas movi al insert:


(defun format-date (format)
  (let ((system-time-locale "en_US.UTF-8"))
    (insert (format-time-string format))))
     ^

Na sp-down-sexp plenumu. Ĝin mi bindis al C-down.

Sa le jenan esprimon oni havas:


(str "foo" "bar baz qux")
    ^

kaj la punkton oni volas movi post ):


(str "foo" "bar baz qux")
                         ^

Na sp-up-sexp plenumu. Ĝin mi bindis al C-up.

Se la jenan esprimon oni havas:


(defn foo [bar] (let [x 0] x))
                ^

kaj la punkton oni volas movi al la apuda ]:


(defn foo [bar] (let [x 0] x))
              ^

Na sp-backward-down-sexp plenumu. Ĝin mi bindis al M-down.

Sa la jenan esprimon oni havas:


(insert (format-time-string format))
                           ^

kaj la punkton oni volas movi al (format:


(insert (format-time-string format))
        ^

Na sp-backward-up-sexp plenumu. Ĝin mi bindis al M-up.

Blokaj movadoj

Sa la jenan esprimon oni havas:


(:require [clojure.string :as s])
          ^

kaj la punkton oni volas movi post ]:


(:require [clojure.string :as s])
                                ^

Na sp-forward-sexp plenumu. Ĝin mi bindis al C-M-f.

Male, por ĝin movi reen al [:


(:require [clojure.string :as s])
          ^

Na sp-backward-sexp plenumu. Ĝin mi bindis al C-M-b.

Supra niveleca trairado

Se la jenan esprimon oni havas:


(defn blah
  "Returns blah of foo."
  [foo]                 ^
  )

kaj la punkton oni volas movi al [:


(defn blah
  "Returns blah of foo."
  [foo]
  ^)

Na sp-next-sexp plenumu. Ĝin mi bindis al C-M-n.

Male, por ĝin movi reen:


(defn blah
  "Returns blah of foo."
  [foo]                 ^
  )

Na sp-previous-sexp plenumu. Ĝin mi bindis al C-M-p.

Libermanaj movadoj

Se la jenan esprimon oni havas:


(defn blah [] (let [x 0 y 1] (+ x 1)))
               ^

kaj la punkton oni volas movi al blah:


(defn blah [] (let [x 0 y 1] (+ x 1)))
      ^

Na sp-backward-symbol plenumu. Ĝin mi bindis al C-S-b.

Male, sa la jenan esprimon oni havas:


(defn blah [] (let [x 0 y 1] (+ x 1)))
            ^

kaj la punkton oni volas movi tuj post (let:


(defn blah [] (let [x 0 y 1] (+ x 1)))
                  ^

Na sp-forward-symbol plenumu. Ĝin mi bindis al C-S-f.

Kion ili faras, estas, ili ĉirkaŭnavigas kvazaŭ ne ekzistas la limiligoj kiel rondaj krampoj, kvadrataj krampoj, kaj kurbaj krampoj.

Manipulado

Faldado

Se la jenan esprimon oni havas:


var mods = "vars";
           ^

kaj na "vars" oni volas esti ĉirkaŭitaj per [ kaj ]:


var mods = ["vars"];
            ^

Na C-M-SpaceESC C-Space premu sekvonte de [ la tutan regionon igas esti ĉirkaŭitaj per kongruaj [ kaj ]. Ankaŭ aplikeblas al klavoj kiel (, {, ", ', *, _, ktp, dependas per la regimo kiun oni uzas.

Alternative, faldadajn funkciojn oni povas difini:

(defmacro def-pairs (pairs)
  `(progn
     ,@(loop for (key . val) in pairs
          collect
            `(defun ,(read (concat
                            "wrap-with-"
                            (prin1-to-string key)
                            "s"))
                 (&optional arg)
               (interactive "p")
               (sp-wrap-with-pair ,val)))))

(def-pairs ((paren . "(")
            (bracket . "[")
            (brace . "{")
            (single-quote . "'")
            (double-quote . "\"")
            (back-quote . "`")))

La avantaĝon de regionojn ne postuli ĉi tiuj havas por kunoperacii. La unuajn tri funkciojn mi bindis al C-c (, C-c [, kaj C-c {, respektive. Do, se la jenan esprimon oni havas:


(defn foo args (let [x 0] (inc x)))
          ^

kaj na args oni volas ĉirkaŭi per [ kaj ]:


(defn foo [args] (let [x 0] (inc x)))
           ^

Na C-c [ premu.

Fojfoje, unu el la paraj paroj oni malatentence forviŝas—ĉi tio rezultas en malekvilibrigita esprimo. Onin smartparens malpermesas por tion fari. Se na Backspace oni premas en la jena esprimo:


var mods = ["vars"];
            ^

Okazas nenio. Onin smartparens savas el multe da ĝeno, ĉi tie.

Malfaldado

Se la jenan esprimon oni havas:


(foo (bar x y z))
     ^

kaj la bar esprimon oni volas malfaldi, la rondajn krampojn forigante ĉirkaŭ foo:


foo (bar x y z)
    ^

Na sp-backward-unwrap-sexp plenumu. Ĝin mi bindis al M-[.

Male, se la bar esprimon oni volas malfaldi, la rondajn krampojn forigante ĉirkaŭ bar:


(foo bar x y z)
     ^

Na sp-unwrap-sexp plenumu. Ĝin mi bindis al M-].

Glutado kaj vomado

Sa la jenan esprimon oni havas:


[foo bar] baz
        ^

kaj na baz oni volas esti parto de foo kaj bar:


[foo bar baz]
        ^

Na sp-forward-slurp-sexp plenumu. Ĝin mi bindis al C-right.

Male, se na baz oni volas forigi:


[foo bar] baz
        ^

Na sp-forward-barf-sexp plenumu. Ĝin mi bindis al M-right.

Se la jenan esprimon oni havas:


blah [foo bar]
             ^

kaj na blah oni volas esti parto de foo kaj bar:


[blah foo bar]
             ^

Na sp-backward-slurp-sexp plenumu. Ĝin mi bindis al C-left.

Male, se na blah oni volas forigi:


blah [foo bar]
             ^

Na sp-backward-barf-sexp plenumu. Ĝin mi bindis al M-left.

Interŝanĝado

Se la jenan esprimon oni havas:


"foo" "bar"
      ^

kaj na "foo" kaj "bar" oni volas interŝanĝi:


"bar" "foo"
      ^

Na sp-transpose-sexp plenumu. Ĝin mi bindin al C-M-t.

Mortigado

Se la jenan esprimon oni havas:


(let [x "xxx" y "y yy yyy" z 0])
               ^

kaj nur na"y yy yyy" oni volas mortigi:


(let [x "xxx" y z 0])
               ^

Na sp-kill-sexp plenumu. Ĝin mi bindis al C-M-k.

Se na "y yy yyy" z 0 oni volas mortigi:


(let [x "xxx" y])
               ^

Na sp-kill-hybrid-sexp plenumu. Ĝin mi bindis al C-k.

Se la jenan esprimon oni havas:


(:require [clojure.string :as s])
                                ^

kaj na [clojure.string :as s] oni volas mortigi:


(:require )
          ^

Na sp-backward-kill-sexp plenumu. Ĝin mi bindis al M-k.

Klavoj

La uzatajn klavkombinojn en ĉi tiu artikolo la jena kodeto resumas. Na bind-keys mi uzas por miajn klavojn oportune mapi. Ĝin mi diskutis en antaŭa artikolo.

(bind-keys
 :map smartparens-mode-map
 ("C-M-a" . sp-beginning-of-sexp)
 ("C-M-e" . sp-end-of-sexp)

 ("C-<down>" . sp-down-sexp)
 ("C-<up>"   . sp-up-sexp)
 ("M-<down>" . sp-backward-down-sexp)
 ("M-<up>"   . sp-backward-up-sexp)

 ("C-M-f" . sp-forward-sexp)
 ("C-M-b" . sp-backward-sexp)

 ("C-M-n" . sp-next-sexp)
 ("C-M-p" . sp-previous-sexp)

 ("C-S-f" . sp-forward-symbol)
 ("C-S-b" . sp-backward-symbol)

 ("C-<right>" . sp-forward-slurp-sexp)
 ("M-<right>" . sp-forward-barf-sexp)
 ("C-<left>"  . sp-backward-slurp-sexp)
 ("M-<left>"  . sp-backward-barf-sexp)

 ("C-M-t" . sp-transpose-sexp)
 ("C-M-k" . sp-kill-sexp)
 ("C-k"   . sp-kill-hybrid-sexp)
 ("M-k"   . sp-backward-kill-sexp)
 ("C-M-w" . sp-copy-sexp)
 ("C-M-d" . delete-sexp)

 ("M-<backspace>" . backward-kill-word)
 ("C-<backspace>" . sp-backward-kill-word)
 ([remap sp-backward-kill-word] . backward-kill-word)

 ("M-[" . sp-backward-unwrap-sexp)
 ("M-]" . sp-unwrap-sexp)

 ("C-x C-t" . sp-transpose-hybrid-sexp)

 ("C-c ("  . wrap-with-parens)
 ("C-c ["  . wrap-with-brackets)
 ("C-c {"  . wrap-with-braces)
 ("C-c '"  . wrap-with-single-quotes)
 ("C-c \"" . wrap-with-double-quotes)
 ("C-c _"  . wrap-with-underscores)
 ("C-c `"  . wrap-with-back-quotes))

Finrimaroj

La pletoro de la komandoj en smartparens eble komence senkuraĝigas, tamen la investo per tempo en ilin lerni, minimumas kontraste al la gajnojn oni povas rikolti.

smartparens estas la elpensintaĵo de Matus Goljer. Por pli da informo pri smartparens, ĉi tien iru. Se ĉi tiun projekton oni ŝatas, oni povas donaci ĉi tie.