Vlákno názorů k článku Užitečné skripty a pluginy pro textový editor Vim (6.část – cestování v čase) od RM - Chtělo by to uvést někde :help usr_32, když...

ad Steve Losh: Krome zmineneho ma zajimavy blog nejenom o vimu a jeho videa "A Whirlwind Tour of my Vimrc" stoji za shlednuti.

Muzes se trochu rozepsat o tom expressions registru, nebo me odkazat na zdroj (myslim nejaky "nebludny" :)). Docela by me to zajimalo.

Na vimcasts.org se koukam selektivne, treba ta posledni videa o UltiSnips me moc neberou a uz davno nebyl novy update. Kdyz jsme u vimcastu, znas knizku Practival Vim?

Dalsim vybornym zdrojem o Vimu jsou videa Damiana Conwaya (a ne neprogramuju v Perlu :)) napr. "More Instantly Better Vim" nebo serie "Mastering Vim"

Zdroje prozkoumám, díky.

O tom že @= není nic víc než spouštění záznamu, stejné jako třeba @a jsem už napsal. Kdo používá záznamník, ví, že se prostě jen přehrají všechny příkazy uvnitř registru. Ten, kdo ví, jak se takový výraz ve výsledku rozvine, nemusí ani záznamník spouštět pro uložení záznamu a používá jej jen tak, že si do registru výraz zapíše a pak jej spustí pomocí @x (je dobré studovat výraz v registru po uložení záznamníkem). V tomhle expression registr není jinej. Takže si třeba zapíšu do registru příkaz :normal a za něj příkaz normal módu pro nalezení # a vložení >

:let @a=":normal /^#\<cr>I>\<esc>"

nebo zkušený mazák už použije rozvinutý výraz rovnou:

let @a=':normal /^#^V^MI>^V^[^M'

(^V^M vytvoříme CTRL-V ENTER a ^V^[ vytvoříme CTRL-V ESC)
čímž vimu trochu ulehčíme práci a svůj výtvor trochu zašifrujeme :)

Pokud stiskneš v normal módu @a tak se záznam z registru přehraje -- najdou se řádky začínající # a vloží se před ně >

Expression registr není nic jiného, až na to, že má něco jako vlastní mód (takže nepoužiješ příkaz :let. Takže CTRL-R = v řádku a pak zadat to samé:

=":normal /^#\<cr>I>\<esc>"

a pak to přehraješ @= a výsledek by měl bejt stejnej. úspora tedy jedno :let :))). Malé plus je, že pro :map je extra příkaz @='.....' , který zajistí zapsání do registru i spuštění. Přičemž s normálním registrem se to musí provést odděleně.

Ukázku na vimcasts.org považuju za slabou :)). Musí tam totiž nejprve blok označit a pak do příkazového řádku zadat příkaz za normal, už vidím jak to někdo takhle dělá. Já bych to udělal tak:

:noremap <F3> :normal 0yt=A<c-v><c-r>=<c-v><c-r>"<c-v><cr><c-v><esc>j<cr>

čímž mi stačí jen tupě mačkat nad řádky F3 a ono to počítá a dosazuje výsledek :). Navíc :normal funguje také pro celou označenou oblast ve visual módu a podporuje také zadané číslo před tím (já tomu říkám multiplikátor) , který vše provede pro N řádek.

ještě pro porovnání. To samé se nechá provést také s expr registrem:

:nnoremap Q @='0yt=A<c-v><c-r>=<c-v><c-r>"<c-v><cr><c-v><esc>j'<cr>

ten multiplikátor také podporuje, ale nefunguje pro označenou oblast ve visual módu. Pro ni musíme tedy udělat ještě namapování extra využijeme vlastností příkazu :normal tak::

:vnoremap Q :normal Q<cr>

Výsledek bude tedy stejný (jen jsem zde použíl místo F3 Q, protože namapovat F3 se mi nějak nedařilo za vnoremap za příkazem :normal. Možností je tedy často víc a používat expression registr bývá často výhodné, ač ne vždy. Losh ještě celý namapovaný výraz s :normal obaluje do execute, což má zas některé jiné výhody, ale také nevýhody; použitím :execute ztratíme vlastnost multiplikátoru u příkazu :normal, ač i to se dá obejít proměnnou :count ....

Ještě jsem udělal výraz, který dělá to samé (obdoba prvního s :normal, tem mi v tomto případě přijde vhodnější než spouštět záznam z registru).
Předchozí výrazy byly postavené na rozvinutí výrazu pomocí expr. registru přesně tak, jak to ukazovalo video. Nyní jsem si (vzdorovitě) řekl, že expr reg. pro tento případ vůbec nepoužiji a zde je výsledek:

:noremap <F3> :normal 0yt=<cr>:let @@=eval(@@)<cr>:­normal f=""p<cr> <cr>

:normal 0yt= .... zkopíruje vše od začátku řádky až po = do unnamed registru
:let @@=eval(@@) .... do stejného reg. si zapíšeme výsledek, který vytvoří funkce eval() ( musíme použít funkci eval, protože kopírováním registru k rozvoji nedojde)
:normal f=""p ... přesune kurzor za = a vloží výsledek z unnamed reg.

Tady ještě to video, o kterém zde píši:
http://vimcasts.org/episodes/simple-calculations-with-vims-expression-register/

Celé video je dost nevhodně udělané. Dalo by se totiž předvést i víc. Třeba se nechá počítat s reálnými čísly a nebo použít třeba sqrt(3)= (většinou s podporou reálných čísel bude vim přeložen). Totiž až v těchto případech se zde ukáže výhoda expr. registru. Pokud bychom použili funkci sqrt nebo reálná čísla, pak tento namapovaný výraz s eval nebude fungovat (eval zahlásí chybu, že string je float a funkci také nezvládne). Výsledek z eval (reálné číslo) totiž nejde zapsat do registru přímo, ale je třeba jej převést na string. Můžeme si ale snadnno pomoct funkcí string().

:noremap <F3> :normal 0yt=<cr>:let @@=string(eval(@@))<cr>­:normal f=""p<cr> <cr>

Takže už to i počítá reálná čísla. Nelze pouze počítat s funkcí (sqrt), kterou bychom museli volat pomocí :call namísto :eval. Zde vidím třeba drobnou výhodu expr. registru; ale kdy až takovou specialitu potřebujeme.

Já jinak nic proti expression registru nemám :), jen mi přijde že jeho používání je až příliš adorované. Přičemž bez něj to jde také.

za :noremap by to ještě chtělo použít <silent> aby to nekecalo do příkazového řádku

jo a před posledním <cr> nemá být mezera, takže tak:

:noremap <silent> <F3> :normal 0yt=<cr>:let @@=string(eval(@@))<cr>­:normal f=""p<cr><cr>

ale... nebude tu fungovat s multiplikátorem ani ve visual módu to nepůjde, což jsem nějak nedomyslel, protože obě vlastnosti se použijí pouze pro první :normal .

Takže přece bude potřeba spustit z registru (použiju expression reg):

nnoremap <silent> <F3> @=':normal 0yt=<c-v><cr>:let @@=string(eval(@@))<c-v><cr>:normal f=""pj<c-v><cr>'<cr>

Jen jsem zabalil výraz do @='....' a <cr> jsem nahradil <c-v><cr>. Parser příkazu :map si je převede na znaky ^M, které se jinak vytvoří pomocí CTRL-V a ENTER a šly by také použít místo <c-v><cr>
Tím máme funkční multiplikátor, ale nebude to fungovat pro rozsah označené oblasti, protože @= (obecně spouštění z registru) nepodporuje na vstupu něco jako rozsah '<,'> Musíme tedy namapovat extra vnoremap a použít :normal, což už bylo ukázáno, a není to žádná velká práce.

Stejně jsem tedy skončil u expr. registru, abych měl funkční vše. Jenže v tomto případě, jak jsem psal, kdy potřebujeme zabalit výraz pro spuštění záznamu, má expr. registr opodstatnění. Šlo by to uložit i do obyčejného registru, ale opět bychom narazili na problém, protože spuštění obsahu z registru by bylo až na konci (@a), čímž by nám nefungoval multiplikátor, který se přilepí vždy jen k prvnímu příkazu! Což bychom museli pak řešit proměnnou v:count . Ale to už zacházím do příliš hlubokých vod :)). Ale přesto ukážu analogické řešení k @='...' bez použití expr registru :):

nnoremap <silent> <F3> :<c-u>let @a=':normal 0yt=<c-v><cr>:let @@=string(eval(@@))<c-v><cr>:normal f=""p<c-v><cr>' \| let @b=v:count1 . '@a'<cr>@b

Není toho tam zas o tolik víc, ale s multiplikátorem a proměnnou v: count1 jsou přecejen nějaké ty starosti navíc :).

Jinak, pokud jsem někoho vyděsil, pak to bude asi tím, že všechno systím na řádek. Vytvořením funkce ve skriptu a zavoláním za :map pomocí :call (podporuje rozsah i multiplikátor) se zbavíme mnoha zvláštností. Ne všechno musí být one-liner.

Možná jsem se do toho včera neměl pouštět, je to trochu mimo topic. Ale zas bych nerad zanechal nějaké chyby. Myslím ,že teď už mám zameteno :).

No, možná jsem si udělal nesprávný závěr na základě těch několika dotazů a odpovědí na fórech, které vesměs dělaly z expr. registru zázrak století. Přišlo mi, že nikdo neměl tušení o tom, že rozvinutí výrazu se provede zápisem do registru nebo proměnné stejně:

:let @a=1+1
nebo
:let @a=getcwd()
nebo
:let @a=system("ls")

a pak už jen jen CTRL-R ap pro vložení z insert módu nebo z normal móud "ap ... a je to tam.

Podtrženo sečteno, je rozdíl nepatrný -- pouze v tom, že při použití expr. registru se nejprve v insert módu (nebo ex módu) stiskne CTRL-R, který vyvolá řádek pro výraz, kam se zapíše a po stisknutí ENTER se rozvinutý výraz vloží na původní místo, odkud byl vyvolán (tj. insert nebo ex mód) -- pod kurzor.
V případě použití normálního registru je jen potřeba navíc napsat :let, přičemž do do ex módu je třeba se přepnout stiskem dvojtečky (před tím asi ještě vystoupit z insert módu ESC). Přičemž CTRL-R ap nebo "ap (z normal módu) se použije až po té.

Tam kde je expression registr k něčemu víc užitečnej jsou až příkazy :map ( také :cmd nebo :apprev). Příkaz @='....', který se umisťuje jen za :map (a další dva uvedené) umožňuje snadno do registru příkaz zapsat a hned obsah registru přehrát. (navíc podporuje multiplikátor (číslo udávající počet opakování zadané před tím)). -- Bez toho by se nám ale taky nežilo špatně ;). Stačilo by :let @a='.....' @a . Takže jen o trochu práce navíc. Nicméně za :map už je těch specialit (v případě syslení výrazu na jeden řádek) většinou dost a tak každé takové zjednodušení se šikne:

nmap Q @='/^#<c-v><cr>I><c-v><esc>:let i+=1 \| echo i<c-v><cr>'<cr>

a s normálním registrem o něco delší a ne tak hezké:

nmap Q let @a='/^#<c-v><cr>I><c-v><esc>:let i+=1 \| echo i<c-v><cr>'<cr> @a

Uvedený namapovaný výraz je extrémně hloupý, jinej mi nenapad :). před řádky začínající # se vloží > a zároveň se inkrementuje proměnná i a zobrazuje v příkazovéme řádku (byl to jen takový test) (je třeba před tím nastavit :let i=1 extra, to jsem neošetřil)

Snad je z toho jasné, že bez registru = a příkazu pro přehrávání záznamu z něj @= a jeho modifikace pro :map ... @='.....'<cr> bychom se také obešli. Je to dobrá pomoc, ale rozhodně ne až tak velká, jak se někde píše. Můžete mi ale někdo přesvědčit o opaku :)... Třeba umí ještě něco...

jen pro zajímavost. Do expr. registru se nechá zapsat i klasicky pomocí příkazu :let také:

:let @==1+1

a pak se ten obsah registru může vložit třeba v insert módu -- CTRL-R "= ENTER (bez zadání výrazu). Tak se vloží hodnota z registru dříve uložená. (jinak kontrolu obsahu registrů prevodeme pomocí :reg, uvádím jen pro úplnost)