On 10/7/22 09:35, Andrey Zherikov wrote:
> On Friday, 7 October 2022 at 16:32:07 UTC, Andrey Zherikov wrote:
>> ```d
>> 10.iota.map!(_ => _.isEven ? _*2 : _); // => [0, 1, 4, 3, 8, 5, 12, 7,
>> 16, 9]
>> ```
>
> You can even generalize this:
> ```d
> alias mapSubrange(alias filter, alias transform) = map!(_ => filter(_) ?
> transform(_) : _);
> 10.iota.mapSubrange!(isEven, _ => _*2);
> ```

I was trying something similar where I left .map to the user code:

import std;

bool isEven(T)(T value) {
    return !(value % 2);
}

alias applyIf(alias pred, alias func) = value => (pred(value) ? func(value) : value);

void main() {
    auto result = 10.iota.map!(applyIf!(isEven, a => a * 2));
    assert(result.equal([0, 1, 4, 3, 8, 5, 12, 7, 16, 9]));
}

Ali

On 10/7/22 16:00, FeepingCreature via Digitalmars-d wrote:
> Thoughts?

How about your selector func wraps the elements, similar to Nullable or via SumType, and your modifier func operates on the marked ones during iteration while returning the others as is? Poor man's monads?

On Fri, Oct 07, 2022 at 04:49:33PM +0000, rassoc via Digitalmars-d wrote:
> On 10/7/22 16:00, FeepingCreature via Digitalmars-d wrote:
> > Thoughts?
> 
> How about your selector func wraps the elements, similar to Nullable or via SumType, and your modifier func operates on the marked ones during iteration while returning the others as is? Poor man's monads?

Another way is if you convert .select into a predicate, then:

	auto r = myrange.map!(e => pred(e) ? modify(e) : e);

But that depends on how easy it is to convert .select into a predicate.


T

-- 
If lightning were to ever strike an orchestra, it'd always hit the conductor first.

On Friday, 7 October 2022 at 16:49:33 UTC, rassoc wrote:
> On 10/7/22 16:00, FeepingCreature via Digitalmars-d wrote:
>> Thoughts?
>
> How about your selector func wraps the elements, similar to Nullable or via SumType, and your modifier func operates on the marked ones during iteration while returning the others as is? Poor man's monads?

Y'all are missing the point a bit. :)

The type spec of the selector is "takes a range, returns a subrange." A subrange here being "a range like the original but with some amount of elements missing." Not, specifically, a predicate! That's what makes it interesting! :)