How can I replicate Vim's code folding?

Question

Code folding in Emacs

Sometimes I want to fold a block of text. In Vim you have easy folding without fuzz. Without to add any special characters like "markers" or specific regex like {{{. I would like to select a region and fold it, without messing with the structure.

When looking around, it seems there were already questions about code folding in Emacs. Someone said that there was "no perfect solution". For example, I created a clip of simple codefolding in Vim:

Vim plain folding

+ Fairly simple, select a region and fold it.
+ It's persistent. When you kill the buffer/close Vim. And reopen the file, the folds are still there.
+ You get a highlight bar, to easily see what's folded.

There are many other folding configurations for Vim. I'm happy with Emacs, but this is one thing that I miss. Other alternatives that I tried, for example HideShow:

HideShow

Evil's alternative with hide-show minor mode. I found it unusable:

- I'm not able to select a region and folding it. It folds on code blocks.

- There's no higlihgting bar or something, to attend you it's folded. You could easily miss it.

- It's not persistent. If you reopen the file, the folds are gone.

There is another package, Fold this:

Fold this

- It's a pretty alternative. However, it mess with the indentation, because the text under the fold gets placed next to the fold... (?).

- It's able to just visually select the region and fold it. But it breaks the indendation, so the overview gets messed up. Not very handy.

- There is no higlihgting bar or something, to attend you it's folded. You could easily miss it.

What's the issue?

I would like to replicate how Vim does folding. But when I searched around, it seems it's very hard to do that in Emacs. So I wonder if there something in emacs or its architecture that makes it difficult to replicate this? What are the limits?

Answer 1

Try out vimish-fold.

Features

• batteries included: activate minor mode, bind a couple of commands and everything will just work;

• it works on regions you select;

• it's persistent: when you close file your folds don't disappear;

• in addition to being persistent, it scales well, you can work on hundreds of files with lots of folds without adverse effects;

• it's obvious which parts of text are folded;

• it doesn't break indentation or something;

• it can refold just unfolded folds (oh, my);

• for fans of avy package: you can use avy to fold text with minimal number of key strokes!

Usage

Create binding for some of/all these functions:

• vimish-fold — basic folding of selected region;

• vimish-fold-unfold — you don't really need to bind this, just use C-g when point is placed on header representing folded text;

• vimish-fold-unfold-all — nevertheless this may be useful;

• vimish-fold-refold — yes, you can fold it back;

• vimish-fold-avy — use avy to fold your text!

You can turn vimish-fold-mode selectively for modes where you want to have persistent folding, or simply activate it everywhere:

(vimish-fold-global-mode 1)

Answer 2

I like and use vimish-fold with evil-vimish-fold (and avy):

  ;; Optional use of avy
  (use-package avy
    :bind ("C-c J" . avy-goto-line)
    :commands avy-goto-line
    :init
    (setq-default
     ;; the unpredictability of this (when enabled) makes it a poor default
     avy-single-candidate-jump nil
     avy-background nil 
     avy-keys '(?a ?s ?d ?f ?g ?h ?j ?k ?l)
     avy-style 'at-full))

  ;; This does the heavy lifting
  (use-package vimish-fold
    :after evil)

  ;; This gives us evil integration, i.e., key bindings
  (use-package evil-vimish-fold
    :after evil vimish-fold
    :init
    (setq evil-vimish-fold-target-modes '(prog-mode markdown-mode conf-mode text-mode))
    :config
    (evil-vimish-fold-mode 1))

If you use package.el to get your packages then you can add an

:ensure

form to the use-package form.

Adjust the evil-vimish-fold-target-modes to include any that you wish to use folding in. Note that prog-mode is the parent mode of most programming modes, so it is sort of a catch all.

Note that this will give you many of the usual vim folding key bindings. Here are some that I use often:

z f Create a fold after first highlighting a region (or use a prefix count like vim).

z o Open existing fold at point.

z d Delete an existing fold.

z R Open all folds in the buffer.

z c Close existing fold at point.

z j Next fold.

z k Previous fold.

Etc.

As Mark Karpov, the creator of vimish-fold, mentioned in his answer, you can use M-x vimish-fold-avy which will fold everything between point and the location you choose via the avy interface that it presents.

An example of using a count prefix would be:

4 z f f

to create a fold from point to 4 lines down.

Answer 3

I wrote foldout.el years ago, so if your file can be “outlined” then it can be folded without needing additional markers.