Fix issue 16246 - cannot call iota with 3 [u]bytes or 3 [u]shorts

[andralex]

not much to say

[dlang-bot]

Fix	Bugzilla	Description
✓	16246	cannot call iota with 3 [u]bytes or 3 [u]shorts

[PetarKirov]

pure?

[andralex]

ok

[PetarKirov]

It may be useful to statically assert that i is of the expected type -ushort here and ubyte below.

[schveiguy]

or, just foreach(ushort i; ...)

[andralex]

ok

[schveiguy]

Approved, but see comments for optional improvements.

[schveiguy]

Why this stray comment?

[andralex]

Helps quickly locating the start of the implementation.

[schveiguy]

step cannot be 0 here.

assert(step != 0 && ...)

[schveiguy]

Or, you can just remove that part of the assert.

[andralex]

ok

[schveiguy]

This logic is correct, but hard to follow.

I'm wondering if it would be better to refactor this into three if branches:

if(current < pastLast && step > 0)
{
    this.step = step;
    this.current = current;
    ... // code currently inside the step > 0 branch
    this.pastLast += step; // this could probably be folded into last line
}
else if(current > pastLast && step < 0)
{
    this.step = step;
    this.current = current;
    ... // code currently inside the else branch of the inner if block
    this.pastLast += step;
}
else
{
    ... // step is 0 or current is on wrong side of pastLast
}

[andralex]

It's a a toss seeing that this variant has more duplication. I'll try a variant with early returns.

[schveiguy]

It's a a toss seeing that this variant has more duplication.

True, but not duplication of conditionals that have already been checked :) There is also the inferred logic in your comment (if step > 0, then current must be < lastPast due to how the big if condition is constructed) that becomes clearer when the actual if condition is simplified.

This seems to me like the debate about combining versions and repeating the declarations. One is more DRY, but the other makes it clear which declarations are active for a specific version.

In any case, I'm OK with the code as written as it is correct and not really more confusing than the original, it just was hard to follow.

[schveiguy]

or, just foreach(ushort i; ...)

[andralex]

Had to overhaul things a bit, representing the limit as "last" instead of "past last" because of overflows.

[schveiguy]

Excellent, looks MUCH better and easier to follow the logic! Should be good to merge.

Using last instead of pastLast helps fix the issue where you want to iterate through all ubytes, for instance. I don't think there's a way to actually create such a struct, however :) iota(ubyte(0), 256) will make the thing return uints, and iota(ubyte(0), ubyte(255)) won't go through 255. But given the way the struct is now written, it would be possible to iterate all the way through 255. I'm curious if at some future point, this would be possible (maybe a compile-time config flag?), as it's one of those things that crops up periodically.

[andralex]

Another nice thing to do with iota is have it accept a compile-time step. I.e. the Result structure would be parameterized by the step value. If the static value is zero then it's understood it's dynamic and it's a regular member etc. That way we unify a bunch of code and make it faster.