Consider, I have the following code:

    auto a = [3, 6, 2, 1, 5, 4, 0];

    auto indicies = iota(3);
    auto ai = indexed(a, indicies);
    ai = indexed(ai, iota(2));

    writeln(ai);

Basically, my idea is to apply indexed to an array several times and have all the intermediaries saved in the same variable. The provided code doesn't compile with an error:

Error: cannot implicitly convert expression `indexed(ai, iota(2))` of type `Indexed!(Indexed!(int[], Result), Result)` to `Indexed!(int[], Result)`

I wonder, if there's a way to "collapse" or "simplify" the Indexed!(Indexed!(int[], Result), Result) type to just Indexed!(int[], Result) ?

On Tuesday, 27 December 2022 at 15:09:11 UTC, Sergei Nosov wrote:

    auto a = [3, 6, 2, 1, 5, 4, 0];

    auto indicies = iota(3);
    auto ai = indexed(a, indicies);
    //ai = indexed(ai, iota(2));

    writeln(ai);

I confuse about comment line that I mark...

SDB@79

On Tuesday, 27 December 2022 at 15:20:24 UTC, Salih Dincer wrote:

    auto a = [3, 6, 2, 1, 5, 4, 0];

    auto indicies = iota(3);
    auto ai = indexed(a, indicies);
    //ai = indexed(ai, iota(2));

    writeln(ai);

Not sure I'll be more helpful, but I'll try to add more details.

I have an array and I use indexed on it. Conceptually, I now have a second array, but it doesn't exist in memory explicitly - only a function to map indicies from "second array" to "first array" is stored; all the values are stored once - in the "first array".

Now, I want to have third array that will do the same trick with the second array. The problem is that the second array is not really an array (but, conceptually, it is an array with random access). If I create a new variable with auto as type - obviously, it works. But can I use the same variable I used to store the "second array"? (In the provided code that doesn't work because of the type mismatch).

On 12/27/22 10:31 AM, Sergei Nosov wrote:

    auto a = [3, 6, 2, 1, 5, 4, 0];

    auto indicies = iota(3);
    auto ai = indexed(a, indicies);
    //ai = indexed(ai, iota(2));

    writeln(ai);

So the short answer is no.

The long of it is that Indexed is using a source range to give it indexes. In order to save it as the same type, you need to resolve the source of the indexes, when indiexed with the new source range, into the same type, which is not something the library can do. It would have to be specialized to recognize it's using iota as the index range, and then transform the iotas into one iota call. Which isn't impossible, but would be something specialized to this problem.

What could be an answer is to have a function that takes 2 iotas, and provides the values as if you were applying the indexes of one to the other, something like:

iota!T translate(T)(iota!T orig, iota!T mapping)
{
   // you write this part
}

Then you can possibly define a function that can convert it properly.

-Steve

On Tuesday, 27 December 2022 at 15:09:11 UTC, Sergei Nosov wrote:

    auto a = [3, 6, 2, 1, 5, 4, 0];

    auto indicies = iota(3);
    auto ai = indexed(a, indicies);
    ai = indexed(ai, iota(2));

    writeln(ai);

Why not use filter(), isn't it important to filter out what's in range?

import std.algorithm;
import std.stdio;
import std.range;

int[] a = [3, 6, 2, 1, 5, 4, 0];
auto indicies = iota(3);
auto ai = a.filter!(e => e >= indicies.front
                      && e <= indicies.back);
ai.writeln; // [2, 1, 0]

SDB@79

On Tuesday, 27 December 2022 at 16:40:31 UTC, Salih Dincer wrote:

import std.algorithm;
import std.stdio;
import std.range;

int[] a = [3, 6, 2, 1, 5, 4, 0];
auto indicies = iota(3);
auto ai = a.filter!(e => e >= indicies.front
                      && e <= indicies.back);
ai.writeln; // [2, 1, 0]

Or?

  indicies.each!((i) => a[i].write(" "));
  writeln(); // 3 6 2

SDB@79

On Tuesday, 27 December 2022 at 15:09:11 UTC, Sergei Nosov wrote:

    auto a = [3, 6, 2, 1, 5, 4, 0];

    auto indicies = iota(3);
    auto ai = indexed(a, indicies);
    ai = indexed(ai, iota(2));

    writeln(ai);

Error: cannot implicitly convert expression `indexed(ai, iota(2))` of type `Indexed!(Indexed!(int[], Result), Result)` to `Indexed!(int[], Result)`

Well, pretty sure this isn't what you meant by "same variable" but since it technically does what you want, I decided to share it: Basically I'm abusing array and this thing might be pretty memory heavy...

import std;

void main()
{

    auto a = [3, 6, 2, 1, 5, 4, 0];

    auto indices = iota(3);
    auto ai = indexed(a, indices).array;
    ai = indexed(ai, iota(2)).array;

    writeln(ai); // [3, 6]
}

On Tuesday, 27 December 2022 at 16:43:49 UTC, Ali Çehreli wrote:

Thanks, everyone!

I guess, this answer is the closest to what I was looking for. Somehow, I missed the range interfaces (and was considering to use Variant or smth). It does seem to answer the original question, albeit with layer(s) of indirection.

  auto indicies = iota(3);
  RandomAccessFinite!int ai = indexed(a, indicies).inputRangeObject;
  ai = indexed(ai, iota(2)).inputRangeObject;

Still, my gut feel is that some compile-time solution is possible - will, probably, tinker with it for a little more.

That does something different.

Yeah, using arrays is another alternative, but as you mention, it uses more memory and makes index evaluation eager (vs lazy).