On Tuesday, 15 February 2022 at 21:48:29 UTC, bachmeier wrote:
>     writeln(iota(v.length,-1,-1));

This would be like

for(a = v.length; a > cast(size_t) -1, a += -1)


That (cast(size_t) -1) is the same as thing.max, meaning a will never be greater than it.

> Why does the first argument to iota have to be an int, and why isn't there an error message when I pass something else?

Yeah, perhaps when you give it that -1 as the second argument it should see it is signed and throw something.

On Tuesday, 15 February 2022 at 22:02:13 UTC, Adam D Ruppe wrote:
> On Tuesday, 15 February 2022 at 21:48:29 UTC, bachmeier wrote:
>>     writeln(iota(v.length,-1,-1));
>
> This would be like
>
> for(a = v.length; a > cast(size_t) -1, a += -1)
>
>
> That (cast(size_t) -1) is the same as thing.max, meaning a will never be greater than it.
>
>> Why does the first argument to iota have to be an int, and why isn't there an error message when I pass something else?
>
> Yeah, perhaps when you give it that -1 as the second argument it should see it is signed and throw something.

After looking at the documentation and seeing CommonType!(int, uint) is uint, I have to say that iota's behavior doesn't make much sense.

On Tuesday, 15 February 2022 at 22:24:53 UTC, bachmeier wrote:
> On Tuesday, 15 February 2022 at 22:02:13 UTC, Adam D Ruppe wrote:
>> for(a = v.length; a > cast(size_t) -1, a += -1)
>
> After looking at the documentation and seeing CommonType!(int, uint) is uint, I have to say that iota's behavior doesn't make much sense.

Unless it's almost always intended to go up and stay positive?

Not that it can't be modified to take all those cases in, hitting 64bit there's little reason you can't just use long,long for the arguments.

On Wednesday, 16 February 2022 at 02:51:32 UTC, Era Scarecrow wrote:
> On Tuesday, 15 February 2022 at 22:24:53 UTC, bachmeier wrote:
>> On Tuesday, 15 February 2022 at 22:02:13 UTC, Adam D Ruppe wrote:
>>> for(a = v.length; a > cast(size_t) -1, a += -1)
>>
>> After looking at the documentation and seeing CommonType!(int, uint) is uint, I have to say that iota's behavior doesn't make much sense.
>
> Unless it's almost always intended to go up and stay positive?

That may have been the intended use case, but it's poor design to not enforce it. I was using it to iterate through the indexes on an array backwards. You have to set the second argument to -1 to get the last index to be 0.

On a larger scale, it's D's principle that it's okay to throw unsigned types around and leave it to the programmer to hang themself. It's hard to see how anyone could think it makes sense to silently convert -1 to 18446744073709551615 without even a warning.

This compiles:

```
void main() {
    void foo(int x) {}
    void bar(uint x) {}

    bar(-1.to!uint);
}
```

This doesn't:

```
void main() {
    void foo(int x) {}
    void bar(uint x) {}

    foo(-1.to!long);
}
```

On Tuesday, 15 February 2022 at 22:24:53 UTC, bachmeier wrote:
> [snip]
>
> After looking at the documentation and seeing CommonType!(int, uint) is uint, I have to say that iota's behavior doesn't make much sense.

What do you propose as an alternative? What about the narrowest type that fits both int and uint? That would be a long.