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.
Mar 13 2017
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.




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

but I would guess that #region actually does more than just enable code


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 2017
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.




 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 

 assumed that everyone would use Visual Studio, but I would 
 guess that #region actually does more than just enable code 

 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 2017
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 2017
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.




 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

 assumed that everyone would use Visual Studio, but I would
 guess that #region actually does more than just enable code

 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
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.


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

language and the primary editor.

- Jonathan M Davis
Mar 13 2017
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
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 2017
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
 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 2017
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



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 2017
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 2017
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



 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.




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 

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 2017
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.


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.


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 2017
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 2017
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 2017
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 2017
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 2017
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.


"

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 2017
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 2017
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 2017
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 2017
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 2017
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 2017
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.




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 2017
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.




 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 2017
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 2017
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.




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 2017