trying to make sense of the below:


// ---
module test;

import std;

void main()
{
    auto rnd = Random(unpredictableSeed);

    int howManyTimes = 5;

    // ok - using 'e =>' makes sense
    writeln(howManyTimes.iota.map!(e => rnd.dice(0.6, 1.4)).format!"%(%s,%)");

    // ok - though using 'howManyTimes =>' doesn't make much sense??
    writeln(howManyTimes.iota.map!(howManyTimes => rnd.dice(0.6, 1.4)).format!"%(%s,%)");

    // NOT ok - using '5 =>' - but isn't this effectively the same as above line?
    //writeln(howManyTimes.iota.map!(5 => rnd.dice(0.6, 1.4)).format!"%(%s,%)");
}

// ---

On Saturday, 22 January 2022 at 19:32:07 UTC, forkit wrote:
> trying to make sense of the below:
>
>
> // ---
> module test;
>
> import std;
>
> void main()
> {
>     auto rnd = Random(unpredictableSeed);
>
>     int howManyTimes = 5;
>
>     // ok - using 'e =>' makes sense
>     writeln(howManyTimes.iota.map!(e => rnd.dice(0.6, 1.4)).format!"%(%s,%)");
>
>     // ok - though using 'howManyTimes =>' doesn't make much sense??
>     writeln(howManyTimes.iota.map!(howManyTimes => rnd.dice(0.6, 1.4)).format!"%(%s,%)");
>
>     // NOT ok - using '5 =>' - but isn't this effectively the same as above line?
>     //writeln(howManyTimes.iota.map!(5 => rnd.dice(0.6, 1.4)).format!"%(%s,%)");
> }
>
> // ---

No, it's not the same. 'Tis not really a "map question", looks more like a question about

https://dlang.org/spec/expression.html#function_literals (see #10).

In the second case, you're defining a lambda with single parameter named `howManyTimes`, which is not at all related to your local variable of the same name. Third case is invalid, as you're effectively trying to do this:

auto func(T)(T 5) { return rnd.dice(0.6, 1.4); }

Which, of course, doesn't make any sense, does it? :)

Given your use case (call a function N times), I think `generate` would be more appropriate here:

```d
import std.random;
import std.stdio;
import std.range : generate, take;

void main()
{
    auto rnd = Random(unpredictableSeed);
    int howManyTimes = 5;
    generate!(() => rnd.dice(0.6, 1.4)).take(howManyTimes).writeln;
}

```

On 1/22/22 11:32, forkit wrote:
> trying to make sense of the below:

The generate() solution shown by Stanislav Blinov is suitable here.

>      auto rnd = Random(unpredictableSeed);

Somebody else mentioned this before but none of the programs we've seen so far seemed to need a special random number generator. So, the default one, which is already randomized, would suffice. Just drop the line above.

>      // ok - using 'e =>' makes sense
>      writeln(howManyTimes.iota.map!(e => rnd.dice(0.6,
> 1.4)).format!"%(%s,%)");

When there is a syntactic need for a variable but that variable is not used, the idiomatic way of naming that variable is '_':

    howManyTimes.iota.map!(_ => dice(0.6, 1.4))

(Note: I did not write rnd.dice.)

Ali

On Saturday, 22 January 2022 at 19:55:43 UTC, Stanislav Blinov wrote:
>

thanks for the explanation. That really helped :-)

writeln( generate!(() => dice(0.6, 1.4)).take(howManyTimes) );
[1, 1, 1, 1, 0]

(or after reading Ali's response - getting rid of rnd, and using _ )

writeln( howManyTimes.iota.map!(_ => dice(0.6, 1.4)) );
[1, 0, 1, 1, 1]

They produce exactly the same thing, so I guess it comes down to personal choice now.

On Saturday, 22 January 2022 at 23:54:27 UTC, forkit wrote:
> On Saturday, 22 January 2022 at 19:55:43 UTC, Stanislav Blinov wrote:
>>
>
> thanks for the explanation. That really helped :-)
>
> writeln( generate!(() => dice(0.6, 1.4)).take(howManyTimes) );
> [1, 1, 1, 1, 0]
>
> (or after reading Ali's response - getting rid of rnd, and using _ )
>
> writeln( howManyTimes.iota.map!(_ => dice(0.6, 1.4)) );
> [1, 0, 1, 1, 1]
>
> They produce exactly the same thing, so I guess it comes down to personal choice now.

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.