On Sunday, 23 January 2022 at 09:38:57 UTC, Siarhei Siamashka
wrote:
On Sunday, 23 January 2022 at 09:08:46 UTC, Stanislav Blinov
wrote:
Using `iota` here incurs additional computation and argument
copies that are actually never used, i.e. wasted work. So I'd
say go with `generate`, as that seems the intent.
Isn't this normally a compiler's job to eliminate all unused
computations and copies?
It is the programmer's job long before it is the compiler's. It
can do wonders on your "minimal" code but it's not its job to
read your mind.
```D
auto foobar1(size_t n)
{
return n.iota.map!(_ => 123).array;
}
auto foobar2(size_t n)
{
return generate!(() => 123).take(n).array;
}
```
LDC with "-O -release" command line options generates pretty
much identical code for foobar1 and foobar2 (I'm only showing
the main loop, but the rest is also the same):
```
20: 48 39 c8 cmp %rcx,%rax
23: 74 18 je 3d
<_D2zz7foobar1FNaNbNfmZAi+0x3d>
25: c7 04 8a 7b 00 00 00 movl $0x7b,(%rdx,%rcx,4)
2c: 48 83 c1 01 add $0x1,%rcx
30: 48 39 cb cmp %rcx,%rbx
33: 75 eb jne 20
<_D2zz7foobar1FNaNbNfmZAi+0x20>
```
```
20: 48 39 c8 cmp %rcx,%rax
23: 74 18 je 3d
<_D2zz7foobar2FNaNbNfmZAi+0x3d>
25: c7 04 8a 7b 00 00 00 movl $0x7b,(%rdx,%rcx,4)
2c: 48 83 c1 01 add $0x1,%rcx
30: 48 39 cb cmp %rcx,%rbx
33: 75 eb jne 20
<_D2zz7foobar2FNaNbNfmZAi+0x20>
```
Do you have a better example to demonstrate `generate`'s
superiority?
Try actual work instead of returning a literal :) Like e.g.
calling dice(50, 50).
One thing to note though - `generate` will always eagerly call
its function at least once. Which of course should also be
considered in choosing the desired implementation. I.e. if your
`n` comes from user and is allowed to be 0, then `generate`
becomes an inferior choice.
