On Sunday, 4 November 2012 at 23:51:15 UTC, Faux Amis wrote:
In your last paragraph you are getting to my point in my other post: I think there is nothing wrong with a module scope private var as in D a module is the first encapsulation and adding a wrapper only adds noise.

These are equivalent(from a good-coding pov):
---
module a;

private int i;
---
module b;

// annoying wrapper
//which makes it difficult to have a single b in the program
struct S{
 int i;
}
---

These are also equivalent:
---
module a;

int i;
---
module b;

struct S{
 static int i;
}
---

Like I said, I don't think it's something that should be banned outright, but I've seen many examples of code where someone didn't take the time to be explicit about the dependencies in their code and instead chose to "hide" it like you propose is appropriate. Trust me, as the person who has to maintain and extend their code, **I don't appreciate their laziness**.

If you can, you should avoid such things. Module-scoped variables mitigate the problems, but they don't eliminate them.

Also, bearophile's suggestion to try to make everything "pure" is a good idea. I write as much code as I can using immutable and pure and only relax those restrictions when the cost is far too great to maintain that. When I come back to the code later, I find it significantly easier to figure out for many of the reasons I outlined in my previous post.

---
void bar(ref int b) {
    //code using b
}
---

Is generally better than

---
int b;
void bar() {
    // code using b
}
---

Even if b is only private module scoped. I've outlined the reasons why in my previous post.

On Sunday, 4 November 2012 at 23:58:08 UTC, bearophile wrote:
Generally it's better to minimize the scope of variables.

Quoted for truth.

Heck, I've seen examples of code where instance variables were too liberally applied, like so:

---
struct S {
   int b;
   void bar() {
// b is initialized and used in this scope, but no where else
   }

   // more code where b isn't used
}
---

is worse than:

---
struct S {
   void bar() {
       int b = ...;
       // use b
   }

   // more code
}
---

Now, maybe b used to be used elsewhere, (I can't say for sure...) but sometimes I wonder why people are so willing to let things like that leak out of the scope where it's used... it makes the next person's job much harder for no reason.

Reply via email to