# Help with Ranges

Steven Schveighoffer schveiguy at gmail.com
Mon Jul 27 18:15:26 UTC 2020

```On 7/27/20 1:10 PM, Charles wrote:

> Still, I'm confused since, as
> far as I know, map wraps its source, i.e. the array in this case, which
> is sortable. It seems to me the only reason I can't sort MapResult is
> because it doesn't have the proper interface.

Let's talk about a concrete example, so you can see why:

int[] arr = [21, 83, 45, 60];

auto m = arr.map!(a => a % 10);

Sort is going to look at m as a random-access range of integers. But the
integer you get from m[2] for instance is going to be 5. So you can
compare e.g. m[2] and m[3] (5 and 0), but how do you *WRITE* back to the
original array? All you have as an interface is non-writable 5 and 0,
not the original array members 45 and 60. In other words, if you swapped
5 and 0, map can't do the inverse transform here (and even if it could,
0 and 5 map to millions of possible original values).

What it seems like you are possibly interested in doing is to sort the
original array based on a transformation. But in your original post you
said "doSomething is some predicate that does a lot of processing on
each element", so I assumed, e.g. something like this is not valid for

arr.sort!((a, b) => doSomething(a) < doSomething(b))

as it would be very expensive assuming doSomething is expensive.

You can use H.S. Teoh's suggestion and use schwartzSort (in fact, it
does something almost exactly the same as what I wrote, except it sorts
the original elements).

However, for something like a % 10, I'd much rather just do it without
allocating another array.

So it really depends on what your requirements are, which you haven't
fully identified.

-Steve
```