• thingsiplay@beehaw.org
    link
    fedilink
    arrow-up
    8
    ·
    12 days ago

    I don’t think folding code parts is a default feature that everyone needs. Vim has folding already and I never use it. To me it is kind of pointless. If the code is messy, then you probably should split it up into several files. There is also a better way to me, through listing jump points on the side (such as function definitions). But its good to have extensions to provide that functionality if you rely on.

    The second option is clearly superior

    No, the first option is clearly superior. I don’t like collapsed code, its hiding stuff and doesn’t help in anything to me. Its better to see the entire context. The same list of function definitions can be displayed in a more useful jump list on the side (in my opinion).

    But maybe its a question of implementation. I would like to see advancements in this field, to see if it is more useful than the current features we have to fold methods and functions.

  • Carighan Maconar@lemmy.world
    link
    fedilink
    arrow-up
    8
    ·
    edit-2
    13 days ago

    I read this and I kept thinking at first “There’s no way I haven’t seen this in IntelliJ bef…”… oh. Of course that’s the one positive example. 😅

    Two thumbs up Jetbrains. And yeah, I think all IDEs for all languages should allow this as a modified view type. Maybe even bidirectional for special cases.

  • nous@programming.dev
    link
    fedilink
    English
    arrow-up
    7
    ·
    12 days ago

    Honestly I think function folders is the wrong solution here. I see two different modes of exploring the code here - a high level over view of what is available and a detailed look at the actual code. Code folding to switch between these two modes is not, I think, the best way to do this. Just the easiest thing to replicate in most editors.

    A better solution would be a separate view for these - maybe a side bar or overlay that you can popup when you want to navigate the code.

    Rust docs has this - a summary of the methods and other symbols on the side with full descriptions in the main view.

    Helix has a nice symbol picker which with some tweaks could be a much nicer way to do this:

    If it did not strip so much info from the symbols it would basically show the collapsed view along side the code with the ability to search and jump to the code you are interested in. I want to see more refinement on features like this and not just have code folding which I tend to find more annoying and limiting - having to constantly collapse and expand sections when what I really want is to jump around the code base.

  • Bear@lemmynsfw.com
    link
    fedilink
    English
    arrow-up
    9
    arrow-down
    2
    ·
    13 days ago

    No. The most basic task is just reading. I’d rather look at the full text by default because it’s easier to scroll and read than have to keep clicking and playing hide and seek. And it’s too easy to miss a very important part because everything looks the same and is equally hidden.

    • Eager Eagle@lemmy.world
      link
      fedilink
      English
      arrow-up
      3
      ·
      edit-2
      12 days ago

      Also, folding encourages 1000+ line files and several indentation levels, like in their example.

  • Kache@lemm.ee
    link
    fedilink
    arrow-up
    4
    arrow-down
    1
    ·
    edit-2
    12 days ago

    IMO folding to hide is about equivalent to moving all contents to another file/private function:

    def bad_function(args):
        return _hide_elsewhere(args)
    

    i.e. does nothing. Real solution to pyramids of doom is to fix the code.

  • zygo_histo_morpheus@programming.dev
    link
    fedilink
    arrow-up
    2
    ·
    12 days ago

    Vim sort of already has this feature via set foldmethod=syntax. This doesn’t work exactly like the author suggests but you can also use set foldmethod=expr and then set foldexpr to a more complicated expression to only get nested function/method bodies, via tree sitter for example if you’re on neovim.