www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - code folding

reply Inquie <Inquie data1.com> writes:
Does D have any nice way to specify a block for cold folding? I 
have a very large set of structs and I'd like to be able to code 
fold them all at once and together.

I have been using

static if(true)
{
     ... junk
}

but the static if is uninformative since that is the only line 
that is shown when folded. A comment helps but still kinda ugly.

C# has #regions and hopefully D has something as useful.
Mar 13
next sibling parent reply Jonathan M Davis via Digitalmars-d-learn writes:
On Monday, March 13, 2017 17:29:41 Inquie via Digitalmars-d-learn wrote:
 Does D have any nice way to specify a block for cold folding? I
 have a very large set of structs and I'd like to be able to code
 fold them all at once and together.

 I have been using

 static if(true)
 {
      ... junk
 }

 but the static if is uninformative since that is the only line
 that is shown when folded. A comment helps but still kinda ugly.

 C# has #regions and hopefully D has something as useful.
Code-folding is an IDE thing, not a language thing. So, it's not the sort of thing that would normally be built into a language. If Microsoft did it with C#, it's only because they assumed that everyone would use Visual Studio, but I would guess that #region actually does more than just enable code folding. However, since I've done relatively little with C#, I don't know. So, how code folding works is going to depend entirely on whatever IDE or code editor you're using. If you told us which IDE you were using, maybe someone here could give you some tips, but it's going to be specific to your IDE. Normally, I think that folks just code fold based on braces if they're doing fode folding, but I don't know. I've certainly never heard of anyone adding anything to a source file just to enable code folding. - Jonathan M Davis
Mar 13
parent reply Inquie <Inquie data1.com> writes:
On Monday, 13 March 2017 at 18:26:22 UTC, Jonathan M Davis wrote:
 On Monday, March 13, 2017 17:29:41 Inquie via 
 Digitalmars-d-learn wrote:
 Does D have any nice way to specify a block for cold folding? 
 I have a very large set of structs and I'd like to be able to 
 code fold them all at once and together.

 I have been using

 static if(true)
 {
      ... junk
 }

 but the static if is uninformative since that is the only line 
 that is shown when folded. A comment helps but still kinda 
 ugly.

 C# has #regions and hopefully D has something as useful.
Code-folding is an IDE thing, not a language thing. So, it's not the sort of thing that would normally be built into a language. If Microsoft did it with C#, it's only because they assumed that everyone would use Visual Studio, but I would guess that #region actually does more than just enable code folding. However, since I've done relatively little with C#, I don't know. So, how code folding works is going to depend entirely on whatever IDE or code editor you're using. If you told us which IDE you were using, maybe someone here could give you some tips, but it's going to be specific to your IDE. Normally, I think that folks just code fold based on braces if they're doing fode folding, but I don't know. I've certainly never heard of anyone adding anything to a source file just to enable code folding. - Jonathan M Davis
This is wrong. It is a language feature. #region lets you specify a block of code that you can expand or collapse when using the outlining feature of the Visual Studio Code Editor. In longer code files, it is convenient to be able to collapse or hide one or more regions so that you can focus on the part of the file that you are currently working on. The following example shows how to define a region: Obviously it is useful for the IDE, but if it was not a language feature then the code would not compile(as it's not a comment). I use visual studio and if it was an IDE feature then I could insert #regions in it and it would compile. This would, of course, break anyone else code that doesn't use an IDE that supports it... hence it has to be a language feature(or some type of meta comment thing, which it is not in this case). Just because you have never heard of it doesn't mean much... it is anecdotal... before the year 0BC no one ever heard of computers... or antibiotics, or spacecraft, or transistors, or just about anything we have to day.
Mar 13
next sibling parent bachmeier <no spam.net> writes:
On Monday, 13 March 2017 at 19:51:59 UTC, Inquie wrote:

 This is wrong. It is a language feature.

 #region lets you specify a block of code that you can expand or 
 collapse when using the outlining feature of the Visual Studio 
 Code Editor. In longer code files, it is convenient to be able 
 to collapse or hide one or more regions so that you can focus 
 on the part of the file that you are currently working on. The 
 following example shows how to define a region:

 Obviously it is useful for the IDE, but if it was not a 
 language feature then the code would not compile(as it's not a 
 comment).
From my understanding of the feature, it does the same as // region ... code to be folded ... // endregion An IDE can then read those comments and allow code folding. It might meet some definition of a language feature, but it is nothing more than a comment.
 I use visual studio and if it was an IDE feature then I could 
 insert #regions in it and it would compile. This would, of 
 course, break anyone else code that doesn't use an IDE that 
 supports it... hence it has to be a language feature(or some 
 type of meta comment thing, which it is not in this case).
I don't understand how it would break your code.
Mar 13
prev sibling parent Jonathan M Davis via Digitalmars-d-learn writes:
On Monday, March 13, 2017 19:51:59 Inquie via Digitalmars-d-learn wrote:
 On Monday, 13 March 2017 at 18:26:22 UTC, Jonathan M Davis wrote:
 On Monday, March 13, 2017 17:29:41 Inquie via

 Digitalmars-d-learn wrote:
 Does D have any nice way to specify a block for cold folding?
 I have a very large set of structs and I'd like to be able to
 code fold them all at once and together.

 I have been using

 static if(true)
 {

      ... junk

 }

 but the static if is uninformative since that is the only line
 that is shown when folded. A comment helps but still kinda
 ugly.

 C# has #regions and hopefully D has something as useful.
Code-folding is an IDE thing, not a language thing. So, it's not the sort of thing that would normally be built into a language. If Microsoft did it with C#, it's only because they assumed that everyone would use Visual Studio, but I would guess that #region actually does more than just enable code folding. However, since I've done relatively little with C#, I don't know. So, how code folding works is going to depend entirely on whatever IDE or code editor you're using. If you told us which IDE you were using, maybe someone here could give you some tips, but it's going to be specific to your IDE. Normally, I think that folks just code fold based on braces if they're doing fode folding, but I don't know. I've certainly never heard of anyone adding anything to a source file just to enable code folding. - Jonathan M Davis
This is wrong. It is a language feature.
I mean that the code folding itself is not a language feature. It's something that the IDE does. The compiler doesn't care one whit about code folding. If #region in C# is there to tell the IDE that the programmer wants that to be foldable, and that's all it does, then the language has a feature to help inform IDEs about how the program wants the code to be foldable. It's still not the language or compiler that does the code folding. And as I said, if C# has something like this, it's because Microsoft assumed that you were going to be using Visual Studio, which they control. Languages don't normally have any features that have anything to do with code editors, because they don't normally assume anything about the editor that you're using. C++ doesn't have anything like it (though it looks like Microsoft added a non-standard extension for it). Neither does Java, python, ruby, javascript, or PHP - just to name a few. There may be _some_ other language out there that does, but it's simply not the sort of thing that most languages do, because they're not usually written with specific editors in mind. Microsoft with C# is the oddball here, because they control both the language and the primary editor. - Jonathan M Davis
Mar 13
prev sibling next sibling parent reply XavierAP <n3minis-git yahoo.es> writes:
On Monday, 13 March 2017 at 17:29:41 UTC, Inquie wrote:
 I have been using

 static if(true)
 {
     ... junk
 }
Indeed #region is part of the C# specification, even if it has no effect on the code. (The specification does not say anything about folding/collapsing, just about "marking sections of code", although I guess most IDEs supporting it will follow the example of MS's reference implementation.) Short answer, D does not have this, as far as I know. I don't really think it's good substitute practice to insert meaningless static if(true)... Even if you're really used to that feature, and even if you're right that it does the job and doesn't change the generated code. Unfortunately you can't get this folding easily (I'm sure some Vim wizard would come up with something). Instead if you want to mark regions of code, that's what comments are for. You can't get the folding you want unfortunately (outside of naturally existing bracket pairs) but you can use your editor to search forward and backward in the file for whatever text, e.g. //region: foo//
Mar 13
parent reply Inquie <Inquie data1.com> writes:
On Monday, 13 March 2017 at 21:17:31 UTC, XavierAP wrote:
 On Monday, 13 March 2017 at 17:29:41 UTC, Inquie wrote:
 I have been using

 static if(true)
 {
     ... junk
 }
Indeed #region is part of the C# specification, even if it has no effect on the code. (The specification does not say anything about folding/collapsing, just about "marking sections of code", although I guess most IDEs supporting it will follow the example of MS's reference implementation.) Short answer, D does not have this, as far as I know. I don't really think it's good substitute practice to insert meaningless static if(true)... Even if you're really used to that feature, and even if you're right that it does the job and doesn't change the generated code. Unfortunately you can't get this folding easily (I'm sure some Vim wizard would come up with something). Instead if you want to mark regions of code, that's what comments are for. You can't get the folding you want unfortunately (outside of naturally existing bracket pairs) but you can use your editor to search forward and backward in the file for whatever text, e.g. //region: foo//
That's not the point. The point is that the IDE I use(VS, which is the most common IDE on windows), requires an actual block to fold. Folding is useful so it is not an irrelevant issue. Even notepad++ can fold blocks if it can determine what a block, so this isn't an "IDE" specific thing nor an "IDE" specific feature. When one had a shit load of types in a single file, it is nice to be able to fold them. It is also nice to be able to group them in some way(hence the question) and fold the group so that large chunks of the file can be visibly reduced. One can say that it is a useless feature because D doesn't have it... or one could say that D is useless because it doesn't have it. A nice balance is simply to say "It is a useful feature that has proven it's worth and it is time that D implements something like it". As D becomes more mainstream, these features will be requested. D should learn from other language/compilers just as other languages/compilers have learned from it. (it's a two a way street) If D supported such simple stuff hacks would not be required to do the simple things.
Mar 13
parent reply Vladimir Panteleev <thecybershadow.lists gmail.com> writes:
On Monday, 13 March 2017 at 21:33:56 UTC, Inquie wrote:
 One can say that it is a useless feature because D doesn't have 
 it... or one could say that D is useless because it doesn't 
 have it. A nice balance is simply to say "It is a useful 
 feature that has proven it's worth and it is time that D 
 implements something like it". As D becomes more mainstream, 
 these features will be requested. D should learn from other 
 language/compilers just as other languages/compilers have 
 learned from it. (it's a two a way street)
FYI: The "you must implement my feature request or D will never succeed" attitude is rather common and never helpful. Not to mention that such an argument would be demonstrably false: every popular language without the feature you want has apparently succeeded despite not having said feature.
 When one had a shit load of types in a single file, it is nice 
 to be able to fold them. It is also nice to be able to group 
 them in some way(hence the question) and fold the group so that 
 large chunks of the file can be visibly reduced.
If you have enough declarations in one file that they call for code folding, it may be better to move them to a separate module. Public imports and aliases allow doing this without breaking any code. If you would like a way to achieve code folding without involving language constructs, I think the starting point would be your IDE/editor's D plugin vendor. Once implemented in one editor, the syntax could be implemented in others and be informally standardized. I don't think that it would make sense to introduce it into the language syntax proper. The #region syntax in C# makes sense for C# because, as already mentioned, the language vendor is also the main IDE vendor; but also because C#, like Java, requires a lot more boilerplate - writing programs in C# is much more tedious without an IDE than with. This is not the case of D, which was designed to solve problems that would otherwise require boilerplate code in the language itself. Generally speaking, I would recommend to simply avoid code folding altogether: https://blog.codinghorror.com/the-problem-with-code-folding/
Mar 13
next sibling parent XavierAP <n3minis-git yahoo.es> writes:
On Tuesday, 14 March 2017 at 00:38:12 UTC, Vladimir Panteleev 
wrote:
 If you have enough declarations in one file that they call for 
 code folding, it may be better to move them to a separate 
 module. Public imports and aliases allow doing this without 
 breaking any code.

 [...]

 Generally speaking, I would recommend to simply avoid code 
 folding altogether:

 https://blog.codinghorror.com/the-problem-with-code-folding/
Indeed good point: http://stackoverflow.com/questions/475675/when-is-a-function-too-long
Mar 13
prev sibling next sibling parent reply Inquie <Inquie data1.com> writes:
On Tuesday, 14 March 2017 at 00:38:12 UTC, Vladimir Panteleev 
wrote:
 On Monday, 13 March 2017 at 21:33:56 UTC, Inquie wrote:
 One can say that it is a useless feature because D doesn't 
 have it... or one could say that D is useless because it 
 doesn't have it. A nice balance is simply to say "It is a 
 useful feature that has proven it's worth and it is time that 
 D implements something like it". As D becomes more mainstream, 
 these features will be requested. D should learn from other 
 language/compilers just as other languages/compilers have 
 learned from it. (it's a two a way street)
FYI: The "you must implement my feature request or D will never succeed" attitude is rather common and never helpful. Not to mention that such an argument would be demonstrably false: every popular language without the feature you want has apparently succeeded despite not having said feature.
I never said that. I said those were the extremes and you decided to pick the extreme that you disagreed with. I'd like you to take a moment and instead of arguing against the feature that you obviously do not like and try to argue for it. I know it will be hard and you won't be able to come up with anything, but try anyways...
 When one had a shit load of types in a single file, it is nice 
 to be able to fold them. It is also nice to be able to group 
 them in some way(hence the question) and fold the group so 
 that large chunks of the file can be visibly reduced.
If you have enough declarations in one file that they call for code folding, it may be better to move them to a separate module. Public imports and aliases allow doing this without breaking any code.
Maybe, maybe not... proves nothing as it is just your preference.
 If you would like a way to achieve code folding without 
 involving language constructs, I think the starting point would 
 be your IDE/editor's D plugin vendor. Once implemented in one 
 editor, the syntax could be implemented in others and be 
 informally standardized.
That would be fine and dandy, but that is just kicking the can down the road to someone else. You should argue on the validity of the issue itself and not on
 I don't think that it would make sense to introduce it into the 
 language syntax proper. The #region syntax in C# makes sense 
 for C# because, as already mentioned, the language vendor is 
 also the main IDE vendor; but also because C#, like Java, 
 requires a lot more boilerplate - writing programs in C# is 
 much more tedious without an IDE than with. This is not the 
 case of D, which was designed to solve problems that would 
 otherwise require boilerplate code in the language itself.
This is not logical. When the designers of C# were creating it, in no way did they say "Well, since C#'s IDE will be our IDE we will add this feature", and if they weren't they wouldn't have added it. They added it because they thought it was a useful thing in general. People don't create compilers based on what the IDE can or can not do.
 Generally speaking, I would recommend to simply avoid code 
 folding altogether:

 https://blog.codinghorror.com/the-problem-with-code-folding/
Anecdotal. One guys view is not proof of anything. Sometimes it is not feasible to split things. The baby shouldn't be thrown out with the bath water. Obviously the designers of C# thought it was important and useful enough and anyone can hunt for a counter example of someone not liking something. If you start with the conclusion that something is wrong or bad(or even right or good) and simply simply opinions as proof, you do not prove anything. You should argue on the merits of the feature itself and not your own person opinions, desires, and wishes.
Mar 14
parent Inquie <Inquie data1.com> writes:
Just for fun:

1. Folding directives are glorified comments. #region has zero 
meaning to the compiler; it's a hint to the editor to allow code 
folding. It doesn't do any namespacing or scoping. Why, exactly, 
are we writing code to accommodate the editor? It boggles my mind 
that we'd add significant lines of code to our project that do 
nothing but offer organizational hints to the editor. Even 
traditional comments are a better value for your keystroke, 
because they can be more expressive. And folding is certainly no 
substitute at all for bona-fide refactoring.

BS. I use regions in C# to separate disparate code. I like to 
know how my code functions and the structure of code relative to 
itself. It helps conceptually understand the code better.

2. Folding is used to sweep code under the rug. Got a bunch of 
boring boilerplate code that makes your eyes water? A slew of 
ugly, gnarly code that nobody in their right mind wants to look 
at? Hide it in a region and fold that sucker into oblivion! 
Problem solved, right? Hardly. Your project is now full of crappy 
code that you can't see. That's worse. Much worse! Code that 
hides from you is code that will rot in the most putrescent and 
painful way possible. Your code should be front and center at all 
times -- exposed to as many programmers' eyes, and as much 
healing light, as possible.

No matter what color language you use to object to something 
doesn't mean it is more true. I guess this guy doesn't realize 
that you can unfold the code.

3. Folding is used to mask excessive length. The presence of 
folded code can lull developers into a false sense of what clean 
code looks like. Under the cover of folding, you can end up 
writing long, horrible spaghetti code blocks. If the code needs 
the crutch of folding to look organized, it's bad code.

Well duh, that is one of the benefits of it.

I'll state it again. I use regions in C# to separate disparate 
code. I like to know how my code functions and the structure of 
code relative to itself. It helps conceptually understand the 
code better.



4. Folding can hide deficiencies in your editor. The presence of 
so-called "standard" boilerplate regions like "Public 
Constructors" and "Public Properties" and "Events" is not a 
feature. It's a bug. The editor should automatically offer to 
fold up these common structural blocks for you! I'm continually 
amazed that programmers spend time doing this scutwork when they 
could be writing useful code. Or at least demanding a smarter 
code editor.

This guy obviously doesn't know what a bug is so how could we 
trust his "expertise"? But which is it? the language or the 
stupid IDE? I'm confused?


This guy probably never used #regions to learn how to use them 
properly and has such a pathetic uptight life that all he can do 
is bitch about other peoples poor code practices. That is no 
proof of anything. Instead of bitching, like most people, why 
didn't he write a constructive article about how to use #regions 
properly?

Anyone can write a blog these days.... kinda sad actually. ;/



I guess you will then state that he is an amazing programmer 
because of SO and that we should all bow down to his wisdom? 
yeah, right....
Mar 14
prev sibling parent reply bachmeier <no spam.net> writes:
On Tuesday, 14 March 2017 at 00:38:12 UTC, Vladimir Panteleev 
wrote:

 FYI: The "you must implement my feature request or D will never 
 succeed" attitude is rather common and never helpful. Not to 
 mention that such an argument would be demonstrably false: 
 every popular language without the feature you want has 
 apparently succeeded despite not having said feature.
This is a little different, however, in the sense that there is no reason to add a feature to the language to do what is requested. If you use Emacs, you can get the same thing in any language using comments: https://www.emacswiki.org/emacs/FoldingMode This is an issue for the IDE, not for the language, and changing the language would not have any effect on IDE support for code folding.
Mar 14
parent reply Inquie <Inquie data1.com> writes:
On Tuesday, 14 March 2017 at 15:18:00 UTC, bachmeier wrote:
 On Tuesday, 14 March 2017 at 00:38:12 UTC, Vladimir Panteleev 
 wrote:

 FYI: The "you must implement my feature request or D will 
 never succeed" attitude is rather common and never helpful. 
 Not to mention that such an argument would be demonstrably 
 false: every popular language without the feature you want has 
 apparently succeeded despite not having said feature.
This is a little different, however, in the sense that there is no reason to add a feature to the language to do what is requested. If you use Emacs, you can get the same thing in any language using comments: https://www.emacswiki.org/emacs/FoldingMode
and I agree that having an such a feature(for #region) would better be handled by comments(assuming it, itself, can be commented out easily). But either way, we do not have the capabilities with D in the first place. I do not use Emacs but the Visual D, which I assume is the sponsored IDE for D.
 This is an issue for the IDE, not for the language, and 
 changing the language would not have any effect on IDE support 
 for code folding.
Remember, it is not just about code folding(which seems to be the common misconception). The cold folding is a sort of byproduct of struct defining language features... of which, D has very little of. Version, is a good one for certain things, but useless here for code structure itself. My original statement was if D had the ability to do proper code folding rather than resorting to hacks and it has been derailed in to an language vs ide battle. So, with all the bloviating, all I have arrived at is that my original hack is still the only way to get the cold folding I wanted(the original use case I had in mind, even though I'd rather have proper code structuring support in general). Generally when even a hint of a suggestion of a language addition is created, the worms come out to party...
Mar 14
parent reply Mike Parker <aldacron gmail.com> writes:
On Tuesday, 14 March 2017 at 15:44:27 UTC, Inquie wrote:

 So, with all the bloviating, all I have arrived at is that my 
 original hack is still the only way to get the cold folding I 
 wanted(the original use case I had in mind, even though I'd 
 rather have proper code structuring support in general). 
 Generally when even a hint of a suggestion of a language 
 addition is created, the worms come out to party...
If it's something you feel strongly about, then the way to go about it is to put together a DIP. There was a time when you could open a forum post about a new feature and eventually see it added, but those days are long gone (for good reason). If any new feature is going to have any hope of getting in these days, then it needs someone to champion it through the DIP process.
Mar 14
next sibling parent bachmeier <no spam.net> writes:
On Tuesday, 14 March 2017 at 16:29:15 UTC, Mike Parker wrote:

 If it's something you feel strongly about, then the way to go 
 about it is to put together a DIP. There was a time when you 
 could open a forum post about a new feature and eventually see 
 it added, but those days are long gone (for good reason). If 
 any new feature is going to have any hope of getting in these 
 days, then it needs someone to champion it through the DIP 
 process.
In addition, not that it won't get very far without a demonstration of how this (a) can't be done using comments, and (b) can't be handled at the IDE level. I have to admit that I do not understand at this point why a change to the language is needed. On the other hand, if this does provide value, I'd expect it to be one of the easiest possible additions to push through, because it won't break anyone's code.
Mar 14
prev sibling parent reply Inquie <Inquie data1.com> writes:
On Tuesday, 14 March 2017 at 16:29:15 UTC, Mike Parker wrote:
 On Tuesday, 14 March 2017 at 15:44:27 UTC, Inquie wrote:

 So, with all the bloviating, all I have arrived at is that my 
 original hack is still the only way to get the cold folding I 
 wanted(the original use case I had in mind, even though I'd 
 rather have proper code structuring support in general). 
 Generally when even a hint of a suggestion of a language 
 addition is created, the worms come out to party...
If it's something you feel strongly about, then the way to go about it is to put together a DIP. There was a time when you could open a forum post about a new feature and eventually see it added, but those days are long gone (for good reason). If any new feature is going to have any hope of getting in these days, then it needs someone to champion it through the DIP process.
It's not that I feel strongly about, I simply would like the best useable solution. Like usually what happens, my original post was taken completely out of context: "Does D have any nice way to specify a block for cold folding? I have a very large set of structs and I'd like to be able to code fold them all at once and together. I have been using static if(true) { ... junk } but the static if is uninformative since that is the only line that is shown when folded. A comment helps but still kinda ugly. C# has #regions and hopefully D has something as useful. " No where do I mention anything about a language change. I asked if D had something useful and better than my hack. What it seems to stir up is a bunch of people that have a fear based reaction, which I can only hypothesize why. Usually it involves someone trying to state absolutely why what I am doing is wrong or bad and all they offer is anecdotal evidence and their opinions. None of which are helpful or useful. I would wager that more than 50% of D users have this mentality, and given that, it is highly unlikely that I could push for such changes. I'd get more done and have more use by forking D and adding my own features for my own personal use. What perplexes me is why so many have such a disdain for any change that ultimately doesn't effect them much. If, say the "#regions" feature was implement, or some variant, and they are right and it is useless then chances of them ever encountering such code is slim... and code they do encounter would generally not a a problem(light use). Yet, those that do use it(in house), which, if it is so bad, according to them, should be rare, would benefit from it, at least in their own mind. You know, there is something called "Survival of the fittest" and if an idea is truly bad then it will die out. Many people don't even want to give any idea a chance to go through that process... fear of it being successful? Fear they might have to learn something new? Fear it might require them to adapt their understanding of how things work? Fear of it being a waste of time? Fear of it causing a nuclear meltdown? When it will affect them almost nil, and they rail against it, it is some deep seeded fear from something... Unless they can give nearly absolute mathematical proof why it is invalid/wrong. Anyways, my hack is good enough for me. If they ever see any of my code, they might rather have allowed something a bit more syntactically pleasing and so they can blame themselves(which they won't). Of course, we could always depreciate "static if (true)" to prevent that possibility! Maybe that is the real solution?
Mar 14
next sibling parent flamencofantasy <flamencofantasy gmail.com> writes:
On Tuesday, 14 March 2017 at 16:58:21 UTC, Inquie wrote:
 On Tuesday, 14 March 2017 at 16:29:15 UTC, Mike Parker wrote:
 [...]
It's not that I feel strongly about, I simply would like the best useable solution. Like usually what happens, my original post was taken completely out of context: [...]
static if(true) // region blah { junk... } when folded; static if (true) // #region blah{...} does that solve your problem?
Mar 14
prev sibling parent reply Entity325` <lonewolf325 gmail.com> writes:
FYI,
static if(true)//comments are great for adding some context to 
your code.
{
    //stuff
}
and
{//let's toss a comment on the scope declaration!
    //stuff
}
are functionally equivalent in my IDE. Both will fold down to only the top {(good), and both create a scope outside of which no declarations inside them are visible(potentially undesirable side-effects). If you need to sequester your code, you really should just toss it into a library and import it from there(no side-effects).
Mar 17
parent Entity325` <lonewolf325 gmail.com> writes:
On Saturday, 18 March 2017 at 05:00:48 UTC, Entity325` wrote:
 and both create a scope outside of which no declarations inside 
 them are visible(potentially undesirable side-effects).
Oh. Static ifs don't do that. Disregard, I'm wrong.
Mar 17
prev sibling next sibling parent reply Adam D. Ruppe <destructionator gmail.com> writes:
On Monday, 13 March 2017 at 17:29:41 UTC, Inquie wrote:
 Does D have any nice way to specify a block for cold folding?
I personally sometimes use // some description { // } since my editor does a really good job matching {}, even in comments so it is convenient to jump anywhere, and i can search the description text to get back to it from anywhere. I can fold it too but i personally prefer just jumping it than actually folding it.
Mar 14
parent Inquie <Inquie data1.com> writes:
On Tuesday, 14 March 2017 at 17:07:57 UTC, Adam D. Ruppe wrote:
 On Monday, 13 March 2017 at 17:29:41 UTC, Inquie wrote:
 Does D have any nice way to specify a block for cold folding?
I personally sometimes use // some description { // } since my editor does a really good job matching {}, even in comments so it is convenient to jump anywhere, and i can search the description text to get back to it from anywhere. I can fold it too but i personally prefer just jumping it than actually folding it.
Yeah, that would be better, unfortunately VS/VD doesn't do this.
Mar 14
prev sibling next sibling parent reply =?UTF-8?Q?Ali_=c3=87ehreli?= <acehreli yahoo.com> writes:
On 03/13/2017 10:29 AM, Inquie wrote:
 Does D have any nice way to specify a block for cold folding? I have a
 very large set of structs and I'd like to be able to code fold them all
 at once and together.

 I have been using

 static if(true)
 {
     ... junk
 }

 but the static if is uninformative since that is the only line that is
 shown when folded. A comment helps but still kinda ugly.

 C# has #regions and hopefully D has something as useful.
There is version: version (all) { // ... } You can define your own version identifiers as well: version = some_descriptive_name; version (some_descriptive_name) { // ... } Ali
Mar 14
parent reply Inquie <Inquie data1.com> writes:
On Tuesday, 14 March 2017 at 20:56:02 UTC, Ali Çehreli wrote:
 On 03/13/2017 10:29 AM, Inquie wrote:
 Does D have any nice way to specify a block for cold folding? 
 I have a
 very large set of structs and I'd like to be able to code fold 
 them all
 at once and together.

 I have been using

 static if(true)
 {
     ... junk
 }

 but the static if is uninformative since that is the only line 
 that is
 shown when folded. A comment helps but still kinda ugly.

 C# has #regions and hopefully D has something as useful.
There is version: version (all) { // ... } You can define your own version identifiers as well: version = some_descriptive_name; version (some_descriptive_name) { // ... } Ali
Oh, that might be better. I thought of versions but I didn't want to have to define anything... didn't know about all.
Mar 14
parent =?UTF-8?Q?Ali_=c3=87ehreli?= <acehreli yahoo.com> writes:
On 03/14/2017 02:48 PM, Inquie wrote:

 version (all) {
     // ...
 }

 You can define your own version identifiers as well:

 version = some_descriptive_name;

 version (some_descriptive_name) {
     // ...
 }

 Ali
Oh, that might be better. I thought of versions but I didn't want to have to define anything... didn't know about all.
I remembered reading about it here: ;) http://ddili.org/ders/d.en/cond_comp.html#ix_cond_comp.all,%20version which includes a link to the very long list of pre-defined version identifiers here: http://dlang.org/spec/version.html#predefined-versions Ali
Mar 14
prev sibling parent Basile B. <b2.temp gmx.com> writes:
On Monday, 13 March 2017 at 17:29:41 UTC, Inquie wrote:
 Does D have any nice way to specify a block for cold folding? I 
 have a very large set of structs and I'd like to be able to 
 code fold them all at once and together.

 I have been using

 static if(true)
 {
     ... junk
 }

 but the static if is uninformative since that is the only line 
 that is shown when folded. A comment helps but still kinda ugly.

 C# has #regions and hopefully D has something as useful.
In Coedit I added regions to the highlighter. //---+ //---- http://imgur.com/a/hIUTV. A comment that ends with ---+ start a region. Comment that ends with ---- ends a region, if any.
Mar 18