In some dynamic/scripting languages the basic programming modality is quite
relaxed, this may help the programmer to quickly write a 10 lines long script.
But when they want to write longer programs of 200 or 2000+ lines, some of such
languages offer a "strict mode" that imposes more constraints and helps
avoid/fix bugs.
(Python for example doesn't have a strict mode, it has a single modality,
that's more strict than basic Perl, but less strict than for example Java and
quite less strict than Ada. While for example JavaScript is a mess, its
management of global/local variables is broken.)
The C language isn't very strict. D language is designed to be compatible with
C, and often it just disallows some unsafe things of C.
So "SafeD" modules may also be in strict mode, disallowing some things that are
valid C that can be used in unsafe D modules.
One of the several things that can be mode more strict in D are the retrieval
of variable names in global/local scopes, and class attributes.
For example Ruby forces to prepend class attribute names with @. Most
programmers use some name convention for them, or "this.". Good IDEs give
different colors to class attributes. Replacing programmers conventions with
something standard and compiler-enforced may be positive.
Another possible idea: in strict mode functions must have an annotation that
lists what variables are used from an outer scope, and if they are read,
written or both.
In this example the function "foo" has an input variable "n", returns a tuple
of int and double, and it uses variables "a" and "b" found in an outer scope,
"a" is just read and "b" is read and written (the parentheses around the
multiple output arguments are compulsive, they avoid troubles):
(int,double) foo(in int n) {
outer in int a;
outer inout int b;
double tot = 0.0;
foreach (i, 0 .. n) {
b[i] += a[i];
tot += b[i];
}
return (n, tot);
}
Inside this function if you try to a variable "c" found in an outer scope you
have a compilation error. Outer variables have to be listed before their usage.
Using many global/outer variables is bad programming practice that leads to
messy programs (so generally it's probably better to just add to such "foo"
function "a" and "b" among its input/ref arguments), but if you want to use
them, then it's better to list that they come from outside. This helps for
example when you want to translate some strict D code to another language.
There are other ways to make the language more strict, for example disallowing
some automatic casts, etc. (C# already has some of this, for example float =>
double requires a cast. I don't remember if D2 requires this already).
Bye,
bearophile