Obsah
3. Vyhledávání a nahrazování s ohledem na strukturu kódu
4. Ukázka vyhledávání a nahrazování
5. Vyhledání všech výskytů symbolu s vytvořením multikurzoru
6. Ukázka multikurzorů se všemi výskyty symbolu
9. Registry textového editoru Helix
16. Nejčastější editační příkazy, které se liší
17. Pohyb po editovaném dokumentu
19. Operace typu „najdi a nahraď“
1. Fuzzy výběry a vyhledávání
První velmi důležitou a užitečnou vlastností textového editoru Helix, s níž se dnes seznámíme, je podpora pro takzvané fuzzy vyhledávání v seznamu všech identifikátorů získaných ze zdrojového kódu s využitím tree-sitteru a LSP. Slovo fuzzy znamená, že se výběr všech symbolů bude postupně zužovat tak, aby obsahoval jen symboly, jejichž znaky zapsal uživatel do vstupního vyhledávacího políčka. Mezi specifikovanými znaky může být libovolné množství jiných znaků, což je velmi užitečné (mj. i proto, že přepisem či vynecháním jednoho znaku se výběr nemusí nijak ovlivnit).
Fyzzy výběr se spouští klávesovou zkratkou Space+s a na následujícím obrázku je patrné, jaké identifikátory se vyberou po zápisu sekvence znaků „env“:
Obrázek 1: Identifikátory jsou seřazeny pravděpodobně na základě Levenshteinovy vzdálenosti.
2. Ukázky fuzzy výběrů
Podobně jako v předchozím článku si i dnes jednotlivé možnosti textového editoru Helix ukážeme na sérii screenshotů. V této kapitole se budeme zabývat výše popsaným fuzzy vyhledáváním.
Obrázek 2: Zdrojový kód (v tomto případě naprogramovaný v jazyku Go), jenž je otevřený v editoru Helix. LSP pro Go bylo inicializováno automaticky po startu editoru.
Obrázek 3: Po stisku mezerníku se objeví toto menu s nabídkou dalších příkazů. Mezi těmito příkazy lze najít i příkaz s – Open Symbol Picker.
Obrázek 4: Dialog zobrazený po stisku klávesové zkratky Space+s. Ihned (i u velkých projektů) se zobrazí dostupné symboly, tj. konstanty, proměnné, funkce a typy.
Obrázek 5: A takto se chová fuzzy vyhledávání při výběru všech symbolů obsahujících znaky „err“ (nikoli nutně přímo za sebou).
Obrázek 6: Zde je funkce fuzzy vyhledávání zřejmá – vyhledávané znaky skutečně nemusí být umístěný přímo za sebou (ovšem větší vzdálenost posune daný výskyt níže v seznamu).
Obrázek 7: Na větší ploše terminálu uvidíme ještě jednu užitečnou vlastnost textového editoru Helix – náhled na vybíraný symbol (zde konkrétně na funkci printConfig).
Obrázek 8: Pracuje se korektně i se strukturami, rozhraními a metodami.
3. Vyhledávání a nahrazování s ohledem na strukturu kódu
V klasickém Vimu je vyhledávání a nahrazování realizováno příkazem :s (substitute). Jedná se o velmi mocný příkaz, protože vyhledávaný vzor se zapisuje jako regulární výraz a text, kterým se má vzor nahradit, může používat (očíslované) skupiny definované v regulárním výrazu. Substitute je jednou z mocných zbraní Vimu, ale má několik „ale“ – nedokáže rozpoznat syntaktické kategorie daného programovacího jazyka a ani nerozpozná kontext, v němž k vyhledávání a náhradám dochází. To například znamená, že pokud budeme chtít přejmenovat parametr cfg na config, může dojít k situaci, že se v jiné části kódu přejmenuje funkce s tímto jménem, třída pojmenovaná stejně atd. atd.
Obrázek 9: Klasické chování omnicompletion ve Vimu lze rozšířit pomocí LSP. Povšimněte si dynamické nápovědy v horním okně.
Aby byla funkce hledat+nahradit rozumně použitelná i v případě zdrojových kódů, je nutné, aby editor kódu „porozuměl“. To je v současnosti řešeno pomocí LSP, tj. samotný language server tuto funkcionalitu nabízí. Funkce LSP je pochopitelně možné volat i z Vimu, což je problematika, kterou jsme se zabývali v článku Použití Language Server Protocolu v textovém editoru Vim. V případě Helixu je integrace s LSP servery ještě užší, protože je postačuje mít nainstalovány a žádná další konfigurace není zapotřebí. A jak se vlastně v Helixu přejmenování symbolu provádí? Je to snadné – použije se klávesová zkratka Space+r, kde r znamená rename.
Obrázek 10: Klasické chování omnicompletion ve Vimu. Povšimněte si dynamické nápovědy v horním okně.
4. Ukázka vyhledávání a nahrazování
Opět se podívejme na realizaci vyhledávání a nahrazování symbolů (identifikátorů) v textovém editoru Helix:
Obrázek 11: Původní zdrojový kód. Kurzor je umístěn na symbolu readClusterList.
Obrázek 12: Po stisku klávesy Space se opět objeví kontextové menu.
Obrázek 13: Stiskem klávesy r se zapne příkaz rename. Nové jméno symbolu se zapisuje do spodního řádku (zde je již zapsáno).
Obrázek 14: Všechny relevantní výskyty symbolu/identifikátoru jsou modifikovány.
Obrázek 15: Jiný zdrojový kód. Povšimněte si, že se ve dvou funkcích nachází stejný symbol/identifikátor mockStorage.
Obrázek 16: Operací rename jsme přejmenovali všechny výskyty druhého symbolu, což jsou řádky 211 a 214. Ostatní symboly, i když se stejným jménem, nebyly změněny (což je přesně to, co vyžadujeme v praxi).
5. Vyhledání všech výskytů symbolu s vytvořením multikurzoru
S fuzzy výběry, s nimiž jsme se seznámili v úvodní kapitole, souvisí i další funkce nabízená textovým editorem Helix. Jedná se o možnost výběru všech výskytů nějakého symbolu (resp. přesněji řečeno identifikátoru) s tím, že se z těchto výběrů vytvoří takzvaný multikurzor. To znamená, že navazující operace, typicky operace insert, append či change bude probíhat na mnoha místech v editovaném dokumentu současně, pochopitelně s okamžitou vizuální zpětnou vazbou k uživateli. Tato funkce se vyvolá klávesovou zkratkou Space+h, přičemž se opět předpokládá, že kurzor se bude nacházet na symbolu, jehož výskyty budeme chtít v editovaném dokumentu vybrat.
theme = "pop-dark" [editor] mouse = false [editor.cursor-shape] #insert = "block" #normal = "block" #select = "block" [keys.normal] ins = "insert_mode" esc = ["collapse_selection", "keep_primary_selection"] [keys.insert] ins = "normal_mode"
6. Ukázka multikurzorů se všemi výskyty symbolu
Opět se podívejme na způsob použití příkazu Space+h, a to konkrétně na části zdrojového kódu naprogramovaného v jazyce Go:
Obrázek 17: Původní zdrojový text, přičemž kurzor je umístěn na identifikátoru currentGroups (je jedno, na kterém místě).
Obrázek 18: Po stisku klávesové zkratky Space+h se zvýrazní všechny výskyty identifikátoru ve zdrojovém textu a navíc se vytvoří i multikurzory (to naznačují změněné barvy čísel řádků na levém sloupci).
Obrázek 19: Příkaz c – change – nám umožní změnit jméno identifikátoru paralelně na všech zvýrazněných místech.
Obrázek 20: Můžeme ovšem použít například i příkaz a – append – či i – insert.
7. Jump points
Textový editor Helix nabízí uživatelům několik příkazů umožňujících skok na definici datového typu, definici funkce/metody, parametru funkce/metody atd. Pravděpodobně nejpoužívanějším příkazem z této kategorie je snadno zapamatovatelný příkaz gd neboli goto definition, který dokáže přesunout kurzor na definici symbolu. Skok se přitom provede i do jiného souboru nebo dokonce do zdrojového kódu systémové knihovny. Jak se ovšem vrátíme zpět? Helix k tomuto účelu nabízí uživatelům dvojici příkazů Ctrl+o a Ctrl+i, přičemž příkazem Ctrl+o se vracíme zpět v historii (tedy vlastně k původnímu kódu, odkud jsme skoky začali) a stiskem Ctrl+i naopak kupředu. Navíc je možné příkazem Space-j otevřít seznam všech tzv. jump pointů, tedy neviditelných značek v souborech, na které je možné provést zpětný či dopředný skok. A poslední důležitou klávesovou zkratkou je Ctrl+s, která uloží aktuální pozici kurzoru a/nebo výběru do jump listu.
Obrázek 21: Kontextové menu vedlejšího režimu goto.
8. Ukázka použití jump pointů
Opět si ukažme praktické použití jump pointů. Jedná se o velmi intuitivní operace, jak ostatně uvidíme na sérii screenshotů:
Obrázek 22: Původní zdrojový kód. Kurzor je umístěn na identifikátoru funkce printHelp.
Obrázek 23: Stiskem klávesové zkratky gd se přesuneme na definici této funkce a současně se interně zaznamená nový jump point.
Obrázek 24: Přesunem na identifikátor funkce fmt.Printf a novým stiskem gd se přesuneme na definici systémové funkce Printf.
Obrázek 25: Klávesou Ctrl+o se vrátíme zpět v historii a další klávesovou zkratkou Space-j si zobrazíme seznam všech jump pointů. Povšimněte si, že na pravé straně se zobrazuje (a to ihned) náhled textu u tohoto jump pointu.
Obrázek 26: Dtto jako na předchozím obrázku, pouze se přesuneme na jiný jump point.
Obrázek 27: Nabídka jump pointů ve skutečnosti není jen obyčejným menu, protože i zde lze realizovat fuzzy výběry, podobně jako i na dalších místech Helixu. To oceníme při analýze složitějších projektů.
9. Registry textového editoru Helix
Dalším užitečným a velmi často používaným nástrojem nabízeným textovým editorem Helix jsou takzvané registry (což je myšlenka převzatá z Vimu, ostatně jako u mnoha dalších věcí). Jedná se o proměnné Helixu pojmenované jedním znakem, které v první řadě slouží pro kopii či přenos editovaných textů pomocí příkazů c (change), d (delete), y (yank) a p (paste), což vlastně znamená, že registry lze využít ve funkci pojmenovaných schránek (clipboard). Druhou funkcí, které registry v tomto textovém editoru mají, je úschova maker, která se zaznamenávají příkazem Q a vyvolávají se (spouští se) příkazem @ (pozor – chovají se jinak, než ve Vimu).
Obrázek 28: Výpis všech aktuálně definovaných registrů tak, jak je tato operace realizována ve Vimu. Povšimněte si, že některé registry ve skutečnosti obsahují makra – jedná se například o registry a, m, q a s.
Pro práci s registry se používá klávesová zkratka ", po které musí následovat jméno registru a až z popř. jméno speciálního registru zmíněného v desáté kapitole. Výběr registru může být součástí prováděné operace (například kopie výběru do zvoleného registru) nebo může operaci předcházet (vložení textu ze zvoleného registru na aktuální pozici kurzoru). Všechny typické příklady použití registrů si pochopitelně ukážeme v navazující kapitole.
10. Ukázky operací s registry
Operace s registry (resp. přesněji řečeno s registrem, který není výchozí) je prakticky stejná, jako je tomu ve Vimu – před vlastní prováděnou operací je pouze nutné klávesou " vybrat příslušný registr. Například lze provést výběr registru před operacemi d (delete), y (yank), p (paste after) a P (paste before). Velmi užitečný je i příkaz R (replace), který nahradí aktuálně vybraný text textem z registru – opět se zde tedy ukazuje, že výběry mají v Helixu velký význam (mnohem větší, než ve Vimu).
Obrázek 29: Výběr tří řádků klávesovou zkratkou 3× nebo xxx.
Obrázek 30: Po stisku klávesy " se zobrazí obsazené registry (tento seznam je zatím prázdný).
Obrázek 31: Stiskem kláves ay se výběr zkopíruje do registru a, což je ostatně zapsáno na stavovém řádku (Vim tuto operaci provede tiše).
Obrázek 32: Provedení jiného výběru, tentokráte slova stiskem klávesy w.
Obrázek 33: Po stisku "by se výběr zkopíruje do registru b, což nám Helix opět napíše na stavový řádek.
Obrázek 34: Smazání jednoho slova, slovo se přesune do výchozího registru " (uvozovky).
Obrázek 35: Smazání jednoho slova, slovo se přesune do výchozího registru " (uvozovky).
Obrázek 36: Menu s obsahem všech naplněných registrů.
Obrázek 37: Výběr jiného slova klávesovou zkratkou w.
Obrázek 38: Náhrada vybraného slova za obsah registru " klávesovou zkratkou "R.
Obrázek 39: Náhrada vybraného slova za obsah registru " klávesovou zkratkou "R.
11. Speciální registry
Podobně jako v případě značek, existují registry naplňované uživatelem a registry, jejichž obsah je měněn textovým editorem automaticky při provádění různých operací. Jména a význam všech registrů textového editoru Helix můžete najít v následující tabulce:
| Registr | Význam |
|---|---|
| a-z | registry, které je možné přímo měnit uživatelem |
| A-Z | registry, které je možné přímo měnit uživatelem |
| / | registr obsahující posledně vyhledávaný řetězec (resp. text odpovídající regulárnímu výrazu) |
| : | registr obsahující poslední příkaz, vhodné při vyvolání tohoto příkazu jako makra |
| " | implicitní registr pro operace c, d nebo y |
| _ | bezedná černá díra pro texty |
| Registr | Význam |
|---|---|
| a-z | registry, které je možné přímo měnit uživatelem |
| 0–9 | registry naplňované automaticky příkazy d a y |
| % | registr obsahující jméno právě editovaného souboru |
| : | registr obsahující poslední příkaz, vhodné při vyvolání tohoto příkazu jako makra |
| = | pseudoregistr používaný pro výpočet matematických a „řetězcových“ výrazů |
| * | registr obsahující obsah schránky |
| + | registr obsahující obsah schránky |
| / | registr obsahující posledně vyhledávaný řetězec (resp. text odpovídající regulárnímu výrazu) |
| " | implicitní registr pro operace c, d, s nebo y |
| – | implicitní registr pro operace, které mění menší část textu, než je jeden textový řádek |
| @ | v Helixu jde o implicitní registr pro záznam makra |
12. Makra
Textový editor Helix umožňuje, podobně jako Vim, záznam a opětovné spouštění maker. Myšlenka i použitá technologie je stejná – editor lze přepnout do režimu, v němž si zapamatuje stisknuté klávesy, přičemž se tyto informace (jména kláves popř. jejich řídicí kódy) uloží do zvoleného registru. Makro uložené v takovém registru je možné „přehrát“ a to libovolněkrát. Právě při práci s makry se do značné míry využijí textové objekty, příkazy pro skoky na určitá logická místa v textu nebo editační a refaktorizační funkce nabízené LSP.
Helix a Vim se od sebe liší především tím, jakým způsobem se provede záznam makra a jeho přehrání. Klávesové zkratky jsou totiž rozdílné, což je ukázáno v další tabulce:
| Operace | Vim | Helix |
|---|---|---|
| záznam makra do výchozího registru | Q | |
| záznam makra do zvoleného registru | q{registr} | "{registr}Q |
| konec záznamu makra | q | Q |
| spuštění makra z registru | @{registr} | "{registr}q |
| spuštění makra z posledního zvoleného | q |
Mohlo by se zdát, že spuštění makra je v Helixu pomalejší, ovšem většinou se makra přehrávají vícekrát a v tomto případě postačuje stisknout klávesu q, což je mnohem rychlejší, než ve Vimu.
13. Ukázka použití maker
Podívejme se nyní na to, jak snadno je možné v textovém editoru Helix používat makra:
Obrázek 40: Záznam makra začíná v tomto dokumentu.
Obrázek 41: Kombinací příkazů I a A je okolo slova vytvořena kostra definice funkce. Vše je zaznamenáno do makra.
Obrázek 42: Kombinací příkazů I a A je okolo slova vytvořena kostra definice funkce. Posléze se operacemi typu goto přesuneme zpět na název funkce. Vše je zaznamenáno do makra.
Obrázek 43: Po ukončení záznamu makra se můžeme podívat, že posloupnost příkazů byla zaznamenána do registru @.
Obrázek 44: Do dokumentu zapíšeme další identifikátor „xyzzy“.
Obrázek 45: Stiskem klávesy q makro vyvoláme a vytvoříme tak kostru nové funkce xyzzy.
14. Registry a makra
Kódy stisknutých kláves se při záznamu makra ukládají do zvoleného registru (viz též devátou kapitolu), přičemž výchozím registrem pro tento účel je registr se jménem @. To ovšem mj. znamená, že si makro můžeme nechat vložit do dokumentu příkazem p resp. přesněji řečeno "{registr}p a podívat se, jak vlastně makro interně vypadá. Z výsledků je patrné, že se nejedná o žádnou magii, protože jsou zde skutečně uloženy jen jména stisknutých kláves:
Obrázek 46: Obsah registru @ příkazem "@p vložíme do editovaného dokumentu (povšimněte si, že jsem při záznamu udělal chybu a musel 2× stisknout Backspace).
Naproti tomu ve Vimu jsou zaznamenány kódy kláves, nikoli jejich jména:
dd<80>2kkkjlllllllllllllllllllllllvlll^[^[kkkkkkjjjjjjjo#defin <80>kbe A^M^[<80>k2kkkkkkkV^[^[jjjjjjjk
15. Od Vimu k Helixu
Jak Vim tak i Helix patří mezi modální textové editory a některé koncepty mají prakticky shodné. Například se jedná o podporu čtyř základních režimů – normálního (normal), příkazového (command), vkládacího (insert) a vizuálního (visual), dokonce i zkratky pro přechody mezi těmito režimy jsou prakticky shodné. Ovšem až na základní klávesové zkratky se tyto textové editory ovládají odlišným způsobem, což poněkud ztěžuje přechod od Vimu k Helixu (nebo naopak) *. V navazujících kapitolách se pokusím vypsat ty vlastnosti Vimu, které se v Helixu buď nevyskytují, nebo se vyvolávají odlišnými způsoby.
16. Nejčastější editační příkazy, které se liší
V další tabulce jsou uvedeny nejčastěji prováděné příkazy, tedy příkazy, které se mnohdy v praxi použijí i několikrát za minutu. Většina rozdílů je způsobena tím, že v Helixu se příkaz většinou skládá z dvojice výběr+operace, kdežto ve Vimu většinou z dvojice operace+posun kurzoru nebo operace+textový objekt:
| Příkaz | Vim | Helix |
|---|---|---|
| smazání slova | dw | wd |
| smazání tří slov | 3dw nebo d3w | v3wd |
| přepis slova | cw | wc nebo ec |
| smazání jednoho znaku | x | d |
| výběr celého řádku | Shift+V | x |
| kopie řádku do registru | yy | xy |
| prohození dvou znaků | xp | dp |
| smazání textu do konce řádku | D | vgld |
17. Pohyb po editovaném dokumentu
Základní příkazy určené pro pohyb po editovaném dokumentu zůstaly v Helixu stejné, jako je tomu v textovém editoru Vim. Ovšem i zde nalezneme několik rozdílů, které si opět shrneme do tabulky (nezmíněné příkazy budou shodné):
| Příkaz | Vim | Helix |
|---|---|---|
| přechod na první řádek | gg | gg (shodné) |
| přechod na poslední řádek | G | ge |
| přechod na začátek řádku | 0 | gh |
| přechod na konec řádku | $ | gl |
| přechod na první nebílý znak | ^ | gs |
| přechod na odpovídající závorku | % | mm |
| přechod na řádek na horním okraji okna | H | gt |
| přechod na řádek uprostřed okna | M | gc |
| přechod na řádek na dolním okraji okna | L | gb |
Obrázek 47: Kontextové menu vedlejšího režimu goto.
Obrázek 48: Mini-menu zobrazené po stisku klávesy m.
18. Záložky vs. jump pointy
V textovém editoru Vim existují takzvané záložky (bookmarks), které se vytváří klávesovou zkratkou m, za kterou následuje jméno záložky, které je jednopísmenné. Skok na záložku se provádí příkazem ` (zpětný apostrof), za nímž opět následuje jméno záložky. Z tohoto pohledu se záložky podobají registrům a mají ještě jednu výhodu (stejně jako registry) – jsou automaticky ukládány do souboru viminfo a „přežijí“ tak restart Vimu. V textovém editoru Helix tento koncept nebyl (kupodivu) zachován. Namísto záložek se zde používají jump pointy, což je téma, kterému jsme se věnovali v sedmé a taktéž v osmé kapitole. Namísto vytvoření záložky příkazem m se vytvoří jump point příkazem Ctrl+s. Poté je již možné mezi jednotlivými body přeskakovat klávesovými zkratkami Ctrl+o a Ctrl+i nebo si otevřít seznam všech bodů příkazem Space+j (se všemi z toho plynoucími výhodami).
19. Operace typu „najdi a nahraď“
Velmi často používanou operací v obou textových editorech, tedy jak ve Vimu, tak i v Helixu, je operace typu „najdi a nahraď“ (což se zkracuje na substitute). Tato operace se ve Vimu provádí odlišně, než v Helixu. Připomeňme si nejprve, jak se tato operace vyvolá ve Vimu. Jedná se o tento příkaz:
:{rozsah}s/{hledaný text}/{nový text}/g{další přepínače}<enter>
Přičemž hledaný text je zadaný formou regulárního výrazu a namísto rozsahu lze zadat znak „%“, který znamená celý dokument. Taktéž je možné přepínačem „c“ specifikovat, že se má každá náhrada potvrzovat, zadat ignorování velikosti písmen atd. Obecně lze říci, že substituje je jedním z nejužitečnějších ale současně i nejsložitějších příkazů Vimu (původně byl do Vi, tedy do předchůdce Vimu, převzat z editoru ed – viz též https://www.gnu.org/software/ed/manual/ed_manual.html#The-_0027s_0027-Command).
V textovém editoru Helix kupodivu tento velmi užitečný příkaz nenalezneme! Namísto toho je ovšem možné použít příkaz s, který vytvoří multikurzory. Nejprve zadáme hledaný text a stiskneme klávesu Enter, což vede k vytvoření multikurzorů. Dále se všechny příkazy budou provádět na vybraných místech paralelně. Tímto příkazem bude c (change) s novým textem:
s{hledaný text}<enter>c{nový text}<esc>
20. Odkazy na Internetu
- Helix: nový modální textový editor inspirovaný Vimem a Kakoune
https://www.root.cz/clanky/helix-novy-modalni-textovy-editor-inspirovany-vimem-a-kakoune/ - Představení Helixu
https://helix-editor.com/ - Helix: A post-modern modal text editor
https://githubplus.com/helix-editor/helix - Helix na GitHubu
https://github.com/helix-editor/helix - Helix: dokumentace
https://docs.helix-editor.com/ - Helix: troubleshooting
https://github.com/helix-editor/helix/wiki/Troubleshooting - Klávesové zkratky Helixu
https://docs.helix-editor.com/keymap.html - How to install the default language servers
https://github.com/helix-editor/helix/wiki/How-to-install-the-default-language-servers - Taking a look at the Helix editor (Nov 5th, 2022)
https://www.youtube.com/watch?v=8L308PdmhMY - Helix – the Rust Powered Development Environment
https://www.youtube.com/watch?v=xHebvTGOdH8 - Python LSP setups for productive coding
https://www.reddit.com/r/HelixEditor/comments/13wpa72/python_lsp_setups_for_productive_coding/ - Helix documentation: Configuration
https://docs.helix-editor.com/configuration.html - Helix documentation: Languages
https://docs.helix-editor.com/master/languages.html - Looking to try Helix. How is support for Python?
https://www.reddit.com/r/HelixEditor/comments/119mhch/looking_to_try_helix_how_is_support_for_python/ - Python LSP Server (GitHub)
https://github.com/python-lsp/python-lsp-server#configuration - (dot file): Helix
https://github.com/gerlacdt/dotfiles/blob/e50ea089dbfd5e71e2cb6c10abfde305bf4a5b6e/helix/.config/helix/languages.toml#L2 - gopls
https://www.getman.io/posts/gopls/ - Kakoune: A Better Code Editor Heavily Inspired by Vim
https://www.tecmint.com/kakoune-better-code-editor-for-linux/ - Kakoune demo
https://vimeo.com/82711574 - 6 Best Vi/Vim-Inspired Code Editors for Linux
https://www.tecmint.com/vi-vim-inspired-code-editors-for-linux/ - Why Kakoune — The quest for a better code editor
https://kakoune.org/why-kakoune/why-kakoune.html - Kakoune design
https://github.com/mawww/kakoune/blob/master/doc/design.asciidoc - Kakoune (modální textový editor)
http://kakoune.org/ - Kakoune: Selections
https://github.com/mawww/kakoune/wiki/Selections - Migrating from Vim
https://github.com/mawww/kakoune/wiki/Migrating-from-Vim - kakoune-vertical-selections
https://github.com/occivink/kakoune-vertical-selection - Langserver.org
https://langserver.org/ - Language Server Protocol
https://microsoft.github.io/language-server-protocol/ - Language Server Protocol Specification
https://microsoft.github.io/language-server-protocol/specification - Implementations Language Servers
https://microsoft.github.io/language-server-protocol/implementors/servers - JSON-RPC 2.0 Specification
https://www.jsonrpc.org/specification - Why You Should Know the Language Server Protocol
https://tomassetti.me/what-is-the-language-server-protocol/ - Language Server Protocol: A Language Server For DOT With Visual Studio Code
https://tomassetti.me/language-server-dot-visual-studio/ - Python Language Server
https://github.com/palantir/python-language-server - Jedi – an awesome autocompletion/static analysis library for Python
https://github.com/davidhalter/jedi - What is lsp
https://www.reddit.com/r/vim/comments/7lnhrt/which_lsp_plugin_should_i_use/ - Evil (Emacs Wiki)
https://www.emacswiki.org/emacs/Evil - Evil (na GitHubu)
https://github.com/emacs-evil/evil - Evil (na stránkách repositáře MELPA)
https://melpa.org/#/evil - Evil Mode: How I Switched From VIM to Emacs
https://blog.jakuba.net/2014/06/23/evil-mode-how-to-switch-from-vim-to-emacs.html - Vrapper aneb spojení možností Vimu a Eclipse
https://mojefedora.cz/vrapper-aneb-spojeni-moznosti-vimu-a-eclipse/ - Vrapper aneb spojení možností Vimu a Eclipse (část 2: vyhledávání a nahrazování textu)
https://mojefedora.cz/vrapper-aneb-spojeni-moznosti-vimu-a-eclipse-cast-2-vyhledavani-a-nahrazovani-textu/ - Emacs/Evil-mode – A basic reference to using evil mode in Emacs
http://www.aakarshnair.com/posts/emacs-evil-mode-cheatsheet - From Vim to Emacs+Evil chaotic migration guide
https://juanjoalvarez.net/es/detail/2014/sep/19/vim-emacsevil-chaotic-migration-guide/ - Introduction to evil-mode {video)
https://www.youtube.com/watch?v=PeVQwYUxYEg - Vim-style keybinding in Emacs/Evil-mode
https://gist.github.com/troyp/6b4c9e1c8670200c04c16036805773d8 - Evil-surround
https://github.com/emacs-evil/evil-surround - Spacemacs
http://spacemacs.org/ - Neovim: literally the future of vim
https://neovim.io/ - AMP – A Vi/Vim Inspired Text Editor for Linux Terminal
https://www.tecmint.com/amp-vi-vim-inspired-text-editor-for-linux/ - Amp: A text editor for your terminal
https://github.com/jmacdonald/amp - Stránky projektu Amp.rs
https://amp.rs/ - Dokumentace k editoru Amp
https://amp.rs/docs/ - Vis: a vi-like editor based on Plan 9's structural regular expressions
https://github.com/martanne/vis - Very opinionated Node.JS VI clone
https://github.com/mikesmullin/nvi - PyVim: Pure Python Vim clone
https://github.com/prompt-toolkit/pyvim - pyvim 2.0.24 na PyPi
https://pypi.org/project/pyvim/ - vim2elvis (1)
https://www.root.cz/clanky/vim2elvis-1/ - vim2elvis (2)
https://www.root.cz/clanky/vim2elvis-2/ - Seriál Textový editor Vim jako IDE
https://www.root.cz/serialy/textovy-editor-vim-jako-ide/ - Obsah Rootu označený nálepkou Vim
https://www.root.cz/n/vim/ - Atom: moderní textový editor
https://www.root.cz/clanky/atom-moderni-textovy-editor/ - Atom: moderní textový editor (dokončení)
https://www.root.cz/clanky/atom-moderni-textovy-editor-dokonceni/ - Why I switched to VIM from Visual Studio Code
https://freshman.tech/from-vscode-to-vim/ - VSCodeVim
https://marketplace.visualstudio.com/items?itemName=vscodevim.vim - VSCodeVim/Vim na GitHubu
https://github.com/VSCodeVim/Vim - How Vim killed Atom and VSCode on my Machine
https://medium.com/@aswinmohanme/how-vim-killed-atom-and-vscode-723a68ad59dc - tree-sitter
https://github.com/tree-sitter/tree-sitter - Introduction: tree-siter
https://tree-sitter.github.io/tree-sitter/ - tree-siter: Queries
https://tree-sitter.github.io/tree-sitter/syntax-highlighting#queries - Textový editor Vim jako IDE
https://www.root.cz/clanky/textovy-editor-vim-jako-ide/ - Textový editor Vim jako IDE (2.část)
https://www.root.cz/clanky/textovy-editor-vim-jako-ide-2-cast/ - Textový editor Vim jako IDE (3.část)
https://www.root.cz/clanky/textovy-editor-vim-jako-ide-3-cast/ - Textový editor Vim jako IDE (4.část)
https://www.root.cz/clanky/textovy-editor-vim-jako-ide-4-cast/ - Textový editor Vim jako IDE (5.část)
https://www.root.cz/clanky/textovy-editor-vim-jako-ide-5-cast/ - A Comprehensive Introduction to Tree-sitter
https://derek.stride.host/posts/comprehensive-introduction-to-tree-sitter - Guide to your first Tree-sitter grammar
https://gist.github.com/Aerijo/df27228d70c633e088b0591b8857eeef - LR parser (Wikipedia)
https://en.wikipedia.org/wiki/LR_parser - GLR Parser (Wikipedia)
https://en.wikipedia.org/wiki/GLR_parser - Helix – Getting Dangerous
https://www.youtube.com/watch?v=i_qsYALaFVo - Helix – Getting More Dangerous (Part 2)
https://www.youtube.com/watch?v=7mTi278jUS8 - Helix – Bridging the IDE gap with CLI tools (Part 3)
https://www.youtube.com/watch?v=Un_vn8U4cEw - Helix Keyboard Shortcuts by HiddenMonkey
https://cheatography.com/hiddenmonkey/cheat-sheets/helix/ - Migrating from Vim to Helix
https://github.com/helix-editor/helix/wiki/Migrating-from-Vim - Migrating from Vim to Kakoune
https://github.com/mawww/kakoune/wiki/Migrating-from-Vim
ČLÁNKY DO MAILU