combobulate

My Combobulate page has suggested package versions but note I have not yet confirmed 100% compatibility with every single Emacs 31.1 major mode yet, though all tests for Combobulate do pass in 31 github.com/mickeynp/combobulate

This is one of the things Combobulate [0] tries to solve by using the output of tree-sitter. Simple breadcrumbs are easy enough to do (your cursor has a clear parental lineage) but much harder to do if you want to retain semantic things, or do interesting things with (say) sibling nodes. You can see the treeview it generates in the GIFs in the link below [0] https://github.com/mickeynp/combobulate

As always emacs has it already https://github.com/mickeynp/combobulate

I am an S-exp enjoyer, and more for practical reasons than aesthetic ones—I really like the editor tooling that's possible with S-expressions. So I will absolutely choose a Lisp or a lisp if given the option, even at some level of inconvenience when it comes to the maturity of the language itself. I will always write Hy[0] rather than Python, for example. [0] https://hylang.org (I am aware of Combobulate[1] for Emacs folks, of which I'm sadly not one.) [1] https://GitHub.com/mickeynp/combobulate

The one I know about is Combobulate[1], it uses treesitter but without voice control. [1] https://github.com/mickeynp/combobulate

i’m also entirely sure you could do this “properly” with tree sitter and some small fiddling edit: by way of https://github.com/mickeynp/combobulate/issues/27, it's been done: https://github.com/emacs-tree-sitter/ts-fold

Impressive! The grammar.json file is just a little bit too underspecced to automate some things. Not to mention it's self-referential. How did you deal with extras and other 'specialisms' that are secretly hidden away in the C-level scanner and so on? I ask because I wrote Combobulate [1], a structured editing and movement tool for Emacs using TS. 1: https://github.com/mickeynp/combobulate

Since this project ended, we've have had quite a lot nice development in this front. Biggest highlight maybe is Combobulate for emacs, providing treesitter powered editing. Neovim also has treesitter and some plugins[2] to work with it. My editor of choice, Helix, also has treesitter based commands built-in[3]. All of these afaik have been released after sapling While it now seems like this mode of using TS/structured editing to extend traditional editors will be the dominant way, I think it still might be useful to keep thinking what an editor that embraces structured editing could look like. [1] https://github.com/mickeynp/combobulate [2] https://github.com/nvim-treesitter/nvim-treesitter/wiki/Extr... [3] https://docs.helix-editor.com/usage.html#navigating-using-tr...

LSP I can probably understand, mostly for performance reasons. Native json parsing and native compilation goes a long way, but clients written in elisp seems susceptible to edge cases where it's not performant enough because UI and IO runs in same thread in Emacs. Not insurmountable even without multithreading, some newer clients that uses better IPC or the dynamic module system are not constrained by Elisp requirement and seems to be doing fine in terms of performance. The dynamic module system is generally a win for pragmatism over ideology, and it has been around for 7 years already. You can't do everything, like say extending core graphics of Emacs, but you can do a lot in any language of your choice if you feel constrained by Elisp. Tree-Sitter feature is built on top of that so it's not clear to me why do you think Emacs can't do be

Eh, I've been looking and haven't found anything for other editors that actually tries to use TreeSitter for anything beyond highlighting. The Emacs structural editing packages are still very WIP but at least they exist. (And also some have been based on the out of tree implementation that's been around for a while now) Example: https://github.com/mickeynp/combobulate

combobulate (alpha quality as of 10/22): source code outline/cliff notes. from github README.rst "Emacs package that provides a standardized framework for manipulating and navigating your source code using tree sitter's concrete syntax tree " -> https://github.com/mickeynp/combobulate https://www.spacemacs.org/ with https://github.com/emacs-tree-sitter/elisp-tree-sitter then write a iterator/loop query for language(s) editing per https://tree-sitter.github.io/tree-sitter/syntax-highlightin... tad less installation heavy (sorta) but also makes use of tree-sitter syntax queries : https://www.lunarvim.org (neovim with treesitter syntax) blockman usage examples: https://www.youtube.com/channel/UC5539gDeAdWqeXcczWuhnBA Alternative examples / takes (per user interface): ### embedding a block of source code in a document: ** carrotsearch.ge

I don't know what this fork brings to table, but you could try tree-sitter today with your vanilla Emacs using a package[1] that works via dynamic module. Personally I am more interested in getting structural selection and navigation reliably working for any language. There is also a package named combobulate[2] to help with that. [1] https://emacs-tree-sitter.github.io/ [2] https://github.com/mickeynp/combobulate