questions around mutating range algorithms, const, and return ref

[Ali Çehreli]

On 01/28/2018 02:52 PM, aliak wrote:
 > Hello, I'm trying to write a function called "pull" that, given 2
 > ranges, "pull"s the values from range 2 out of range 1. I'm not sure if
 > I'm doing it correctly though, and I have some questions so any help is
 > appreciated. This is what I have:
 >
 > ref pull(R1, R2)(return ref R1 r1, R2 r2) {
 >      import std.algorithm, std.array, std.range;
 >      int numFound = 0;
 >      auto r = r1.save;
 >      ElementType!R1[] unfoundElements;
 >      foreach (e; r) {
 >          if (!r2.canFind(e)) {
 >              unfoundElements ~= e;
 >          } else {
 >              numFound++;
 >          }
 >      }
 >      moveEmplaceAll(unfoundElements, r1);
 >      r1.popBackN(numFound);
 >      return r1;
 > }
 >
 > So my questions are:
 >
 > 1) So first of all, is there a function like this in phobos that I can
 > use? From what I understand phobos is supposed to be nogc so mutating
 > functions like these are usually in place ones?

I think the following trivial wrapper around std.algorithm.remove() 
should do:

void removeMatching(R, N)(ref R r, N needles) {
     import std.algorithm : remove, canFind;
     r = r.remove!(e => needles.canFind(e));
}

void main() {
     auto arr = [1, 2, 3, 2, 4];
     arr.removeMatching([2, 3]);
     assert(arr == [1, 4]);
}

 > 2) Is there a way to avoid the extra "moveEmplaceAll" call towards the
 > end and still get the same results?

I'm not convinced that unfoundElements is needed at all. :)

 > 3) Is it necessary to always import std.array (or std.range: empty,
 > front) when doing work like this with range algorithms? (otherwise you
 > get no property save when an array is used as a range)

I think importing std.range works as well.

 > 6) It will not work when I pass in a range that has const elements.
 >
 > ie:
 >
 > const(int)[] arr = [1, 2, 3, 4, 5];
 > arr.pull([2, 3]);
 >
 > This I guess makes sense because moveEmplaceAll depends on isInputRange
 > and from my understanding, a const range cannot be one (is that
 > correct?).

Yes but your range is not const, the elements are. So, although 
const(int)[] is a range, it does not have mutable elements.

 > So am I correct in thinking there really is no way around
 > this, or is there some move/cast trickery that I can use maybe?

You don't want to mutate const elements anyway. It would be breaking a 
promise that other parts of the program may be depending on. I would 
return a filtered-out range:

import std.algorithm;

void main() {
     const(int)[] arr = [1, 2, 3, 2, 4];
     auto result = arr.filter!(e => ![2, 3].canFind(e));
     assert(result.equal([1, 4]));
}

If needed, the caller can easily make an array out of the filtered range 
and the element types will still be const(int):

     import std.range;
     auto arr2 = result.array();
     static assert(is(typeof(arr2) == const(int)[]));

 >
 > Cheers,
 > - Ali

Ali