I have found the documentation for each in std.algorithm a bit terse. It seemed like it was an eager version of map, but it seems to be a bit more limited than that.

In particular, the documentation says that if you can mutate the value in place, then you can call each on it. The first thing I noticed is that this works easiest (beyond in place operators) when you're using a void function and taking the input you want to change as ref. This is what I did in the foo and bar functions below. However, it's not the same thing as just applying the function. In the baz function, I mutate the value and then return a different value. Using baz with each doesn't change the value by 2, only by 1.

What really confused me is that I can't use a lambda with each in a similar way as map. I think this is because the lambdas I'm using really aren't void functions. The part after the => is basically a return statement, so I'm not really mutating anything in place. Is there any way to do this with lambdas or are void functions required?

Is there a way to write a void lambda that would work with each?

import std.range : iota;
import std.algorithm : each;
import std.array : array;

void foo(ref int x)
{
	x += 1;
}

void bar(ref int x)
{
	x *= x;
}

int baz(ref int x)
{
	x += 1;
	return x + 1;
}

void main()
{
	auto x = iota(3).array;
	
	x.each!((ref a) => a++);
	assert(x == [1, 2, 3]); //What you would expect
	
	x.each!((ref a) => foo(a));
	assert(x == [2, 3, 4]); //What you would expect
	
	x.each!((ref a) => bar(a));
	assert(x == [4, 9, 16]); //What you would expect
	
	x.each!((ref a) => baz(a));
	assert(x == [5, 10, 17]); //What I would expect after thinking about it for a while
							
	x.each!((ref a) => a + 1);
	assert(x == [5, 10, 17]); //Not what I would expect
	
	x.each!((ref a) => a * a);
	assert(x == [5, 10, 17]); //Not what I would expect
}

On Monday, 20 July 2015 at 14:40:59 UTC, jmh530 wrote:
>
> Is there a way to write a void lambda that would work with each?
>

Ugh, I hate that I can't edit posts. I meant to delete this line.

On Monday, 20 July 2015 at 14:40:59 UTC, jmh530 wrote:
> I have found the documentation for each in std.algorithm a bit terse. It seemed like it was an eager version of map, but it seems to be a bit more limited than that.
>
> In particular, the documentation says that if you can mutate the value in place, then you can call each on it. The first thing I noticed is that this works easiest (beyond in place operators) when you're using a void function and taking the input you want to change as ref. This is what I did in the foo and bar functions below. However, it's not the same thing as just applying the function. In the baz function, I mutate the value and then return a different value. Using baz with each doesn't change the value by 2, only by 1.
>
> What really confused me is that I can't use a lambda with each in a similar way as map. I think this is because the lambdas I'm using really aren't void functions. The part after the => is basically a return statement, so I'm not really mutating anything in place. Is there any way to do this with lambdas or are void functions required?
>
> Is there a way to write a void lambda that would work with each?
>
> import std.range : iota;
> import std.algorithm : each;
> import std.array : array;
>
> void foo(ref int x)
> {
> 	x += 1;
> }
>
> void bar(ref int x)
> {
> 	x *= x;
> }
>
> int baz(ref int x)
> {
> 	x += 1;
> 	return x + 1;
> }
>
> void main()
> {
> 	auto x = iota(3).array;
> 	
> 	x.each!((ref a) => a++);
> 	assert(x == [1, 2, 3]); //What you would expect
> 	
> 	x.each!((ref a) => foo(a));
> 	assert(x == [2, 3, 4]); //What you would expect
> 	
> 	x.each!((ref a) => bar(a));
> 	assert(x == [4, 9, 16]); //What you would expect
> 	
> 	x.each!((ref a) => baz(a));
> 	assert(x == [5, 10, 17]); //What I would expect after thinking about it for a while
> 							
> 	x.each!((ref a) => a + 1);
> 	assert(x == [5, 10, 17]); //Not what I would expect
> 	
> 	x.each!((ref a) => a * a);
> 	assert(x == [5, 10, 17]); //Not what I would expect
> }

Everything is exactly as I would expect. Lambdas with => are just shorthand that skips the return expression and std.algorithm.each just calls the lambda for each element in x, it doesn't say anything about copying the result back in to x.

x.map!(a => a * a).copy(x);

On Monday, 20 July 2015 at 14:59:21 UTC, John Colvin wrote:
> On Monday, 20 July 2015 at 14:40:59 UTC, jmh530 wrote:
>> [...]
>
> Everything is exactly as I would expect. Lambdas with => are just shorthand that skips the return expression and std.algorithm.each just calls the lambda for each element in x, it doesn't say anything about copying the result back in to x.
>
> x.map!(a => a * a).copy(x);

But the lambda takes a ref parameter...

On Monday, 20 July 2015 at 15:08:16 UTC, Nicholas Wilson wrote:
> But the lambda takes a ref parameter...

Yes, but it never writes to it:

    x.each!((ref a) => a + 1);

Instead, this should work:

    x.each!((ref a) => a = a + 1);

... as a short-hand for:

    x.each!((ref a) { a = a + 1; });

On Monday, 20 July 2015 at 14:40:59 UTC, jmh530 wrote:
> I have found the documentation for each in std.algorithm a bit terse. It seemed like it was an eager version of map, but it seems to be a bit more limited than that.
>
> In particular, the documentation says that if you can mutate the value in place, then you can call each on it. The first thing I noticed is that this works easiest (beyond in place operators) when you're using a void function and taking the input you want to change as ref. This is what I did in the foo and bar functions below. However, it's not the same thing as just applying the function. In the baz function, I mutate the value and then return a different value. Using baz with each doesn't change the value by 2, only by 1.
>
> What really confused me is that I can't use a lambda with each in a similar way as map. I think this is because the lambdas I'm using really aren't void functions. The part after the => is basically a return statement, so I'm not really mutating anything in place. Is there any way to do this with lambdas or are void functions required?

"a += 1" in D is an expression that first mutates a and then returns a. Therefore, you can write this lamda:

(ref a) => a += 1

And it should work fine with `each`. The expanded version that this desugars to is:

int function(ref int a)
{
    return a += 1;
}

On the other hand, however, a + 1 is an expression that does not mutate a. It just returns the value of a with 1 added to it. Therefore, `(ref a) => a + 1` cannot work, as it does not actually modify a.

The best way to think of it is as if the body of your lambda is being executed in a `foreach` loop. If you translate some of your examples, it should become obvious as to what the result is.

x.each!((ref a) => a++)

becomes

foreach (ref a; x)
{
    a++;
}

And, of course, the answer is x == [2, 3, 4].

On Monday, 20 July 2015 at 15:12:28 UTC, Marc Schütz wrote:
> On Monday, 20 July 2015 at 15:08:16 UTC, Nicholas Wilson wrote:
>> But the lambda takes a ref parameter...
>
> Yes, but it never writes to it:
>
>     x.each!((ref a) => a + 1);
>
> Instead, this should work:
>
>     x.each!((ref a) => a = a + 1);
>
> ... as a short-hand for:
>
>     x.each!((ref a) { a = a + 1; });

This works! Thanks.

Also, map is lazy, but each isn't.

On Monday, 20 July 2015 at 14:40:59 UTC, jmh530 wrote:
> I have found the documentation for each in std.algorithm a bit terse. It seemed like it was an eager version of map, but it seems to be a bit more limited than that.

Why are you trying to use `each` in place which belongs to `map`?

On Monday, 20 July 2015 at 21:24:37 UTC, sigod wrote:
> On Monday, 20 July 2015 at 14:40:59 UTC, jmh530 wrote:
>> I have found the documentation for each in std.algorithm a bit terse. It seemed like it was an eager version of map, but it seems to be a bit more limited than that.
>
> Why are you trying to use `each` in place which belongs to `map`?

More just out of my own curiosity of trying to understand how it worked.