Change AliasSeq(0, ...) uses of foreach to static foreach

[wilzbach]

I started to have a quick look at introducing more static foreach at Phobos.
Sadly even the naive idea to mark all foreach loops which definitely are at Compile-Time - e.g. with AliasSeq doesn't work:

sed -E "s/foreach(.*)AliasSeq/static foreach\1AliasSeq/" -i **/*.d

or in simpler words with a simplified example from Phobos (most of the uses of foreach + AliasSeq are like this):

import std.stdio, std.meta;
void main(string[] args)
{
    foreach (S; AliasSeq!(string, wstring, dstring))
    {
        auto s = S.stringof;
        writeln(s);
    }
}

https://run.dlang.io/gist/6ae32becc7ffaa1296a1a4752cebc294?compiler=dmd

And now with static foreach this fails due to the symbol being in the outer scope:

import std.stdio, std.meta;
void main(string[] args)
{
    static foreach (S; AliasSeq!(string, wstring, dstring))
    {
        auto s = S.stringof; // Error: declaration foo.main.s is already defined
        writeln(s);
    }
}

FWIW Local Declarations would solve this and FYI @tgehr mentioned that he has a working implementation of __local already.

[dlang-bot]

Thanks for your pull request, @wilzbach!

Bugzilla references

Your PR doesn't reference any Bugzilla issue.

If your PR contains non-trivial changes, please reference a Bugzilla issue or create a manual changelog.

[PetarKirov]

LGTM, apart from some minor suggestions for std.datetime.

[PetarKirov]

Changes to this module are a good candidate for a separate commit.

[PetarKirov]

This assert is not necessary. It was there in the original code only because, the author didn't use foreach (n; staticIota!(0, timeStrings.length)) (e.g. staticIota from std.typecons).

[PetarKirov]

Naming the indexes curr, next (cmp(t[curr], t[next]) == -1) and prev (cmp(t[curr], t[prev]) == 1) respectively would make the code a bit clearer.

[tgehr]

@wilzbach: If you want to replace an existing foreach loop with static foreach, you can use two nested curly braces to introduce a new scope. (__local is useful mostly at declaration scope and for the case where some declarations should be hidden inside a single iteration while others should be visible.)

[MetaLang]

I love how much nicer static foreach makes the mixin-heavy code look.

Also looks like CircleCI doesn't know about the feature yet.

[wilzbach]

Also looks like CircleCI doesn't know about the feature yet.

Yup -> we need to update Dscanner: #5732

[wilzbach]

Also looks like CircleCI doesn't know about the feature yet.

With #5732 finally being merged, the first use of static foreach in Phobos should be able to get in :)

[dnadlinger]

Why is this a static foreach to begin with?

[dnadlinger]

Same here.

[ibuclaw]

If aliasseq is not being used, can the import be removed also? (assuming that it is local import)

[PetarKirov]

The import is local, but it is used for the foreach (X; AliasSeq!(float, double, real)) above.

[MartinNowak]

The fact that static foreach doesn't introduce a new scope with the curly braces is by design.
Though my second usage also ended with this and left me a bit puzzled.
Guess it was intended to be consistent with static if, and also to slightly simplify adding top-level declarations.
Though for the latter a loop body without braces could have been another option.

static foreach (i; 0 .. 3)
    mixin("struct S"~i.to!string~" {}");

Using more than one statement is quite a pain anyhow cause you need to escape any declarations with a unique name (or use __local which seems a bit hacky).

Anyone thought about explicit exporting instead of explicit local @tgehr?

static foreach (i; 0 .. 3)
{
    immutable s = generateCode(i);
    struct S { mixin(code); }
    // just some syntax ideas
    alias scope OuterName=S;
    alias return OuterName=S;
    alias export OuterName=S;
    alias export : OuterName=S, OuterName2=S;
}

[MetaLang]

@MartinNowak is there a reason that you can't just open up another scope? e.g.:

static foreach (i; 0 .. 3)
{
    alias _ = doSomeStuff!i; //Error: multiple definitions by default
}

static foreach (i; 0 .. 3)
{{
    alias _ = doSomeStuff!i; //Okay
}}

[tgehr]

@MartinNowak: Yes, the goal was to have the same behaviour for static foreach and static if. (I did think about having it the other way.) Being explicit about exporting does have some advantages, but apart from inconsistency with static if it also has the drawback that people need to remember how to do it even if all declarations should be visible, which is probably a common case.

Note that __local is not in the language now (exactly because the syntax looks hacky), so if you have a good proposal for syntax for that feature, we can perhaps get it into the language in a way that is satisfying to you.

However, if you want to use static foreach as just an unrolled loop at statement scope, probably it is better to use the suggestion of @MetaLang .

Another idea I had was to allow enum and alias on regular foreach loop variables, such that they force expansion:

foreach(enum i; 0 .. 3)
{
    alias _ = doSomeStuff!i; //Okay
}

This is IMHO more natural if the goal is to unroll a loop at statement scope.

[MartinNowak]

Note that __local is not in the language now (exactly because the syntax looks hacky), so if you have a good proposal for syntax for that feature, we can perhaps get it into the language in a way that is satisfying to you.

Let's see what uses and hindrances for static foreach really come up, we might not even need this in the end.
Sth. like alias scope = bla; could be an alternative syntax for that __local thing.

Another idea I had was to allow enum and alias on regular foreach loop variables, such that they force expansion:

foreach(enum i; 0 .. 3)
{
alias _ = doSomeStuff!i; //Okay
}

This is IMHO more natural if the goal is to unroll a loop at statement scope.

Would be interesting, though as we can already do this with staticIota and/or AliasSeq, it's not too important. Being able to easily unroll a range w/o template recursion would be nice though.

[wilzbach]

Converted the static foreach in std.math to a normal foreach as suggested.