std.variant;
Variant v = [[1], [2], [3]];

writeln(v.type); // int[][]
typeof(v.type); // TypeInfo
assert(v.type == typeid(int[][]);

As demonstrated by the assert statement, .type returns the typeid of the underlying type. How would I obtain the actual type such that:

 auto vb = v.base; // what should I put here to achieve the following:
 typeof(vb); // int[][]
 assert(vb == [[1], [2], [3]]);

--anonymouse

On Saturday, 9 July 2022 at 23:04:20 UTC, anonymouse wrote:

 this(T)(T a)
 in(imported!"std.traits".isDynamic!T)
 {
     data = a; // data is of type Variant
     shape = [a.length, {?, ...}]; // what's the best way to deterine?
 }

import std.variant : Variant;

size_t[] shape(Variant v) {
    import std.variant : VariantException;

    size_t[] s;
    try {
        while (true) {
            Variant elem = v[0];
            s ~= v.length;
            v = elem;
        }
    } catch (VariantException e) {
        return s;
    }
}

unittest {
    assert([3, 1] == [[1], [2], [3]].Variant.shape);
    assert([2, 1] == [[1], [2]].Variant.shape);
    assert([2, 2] == [[1, 0], [2, 0]].Variant.shape);
    assert([2] == [1, 2].Variant.shape);
    assert([] == 2.Variant.shape);

    // irregularity not checked
    assert([2, 2] == [[1, 0], [2]].Variant.shape);
    // arguably should be [2, 0]
    assert([2] == [[], []].Variant.shape);
}

On Sunday, 10 July 2022 at 06:26:37 UTC, jfondren wrote:

import std.variant : Variant;

size_t[] shape(Variant v) {
    import std.variant : VariantException;

    size_t[] s;
    try {
        while (true) {
            Variant elem = v[0];
            s ~= v.length;
            v = elem;
        }
    } catch (VariantException e) {
        return s;
    }
}

Thank you very much.

On Sunday, 10 July 2022 at 18:31:46 UTC, drug007 wrote:

import std.variant : Variant;

size_t[] shape(Variant v) {
    import std.variant : VariantException;

    size_t[] s;
    try {
        while (true) {
            Variant elem = v[0];
            s ~= v.length;
            v = elem;
        }
    } catch (VariantException e) {
        return s;
    }
}

For reference, this is the more correct way:

while (cast(TypeInfo_Array) v.type !is null) {
    Variant elem = v[0];
    // etc.
}

Hard to blame anyone for not coming up with that on their first try, especially since TypeInfo_Array is not even documented--you have to read the source of object.d to find out about it.

On Monday, 11 July 2022 at 03:17:33 UTC, anonymouse wrote:

Oh, sorry. I didn't defend the code in any way because I assumed that the exceptional design would be seen as obviously bad (and that someone else would dig harder in order to find a better solution).

The TypeInfo_Array fix breaks the last assertion of those unit tests, though. This works:

import std.variant : Variant;

size_t[] shape(Variant v) {
    size_t[] s;
    while (cast(TypeInfo_Array) v.type !is null && v.length > 0) {
        Variant elem = v[0];
        s ~= v.length;
        v = elem;
    }
    return s;
}

Although, that last assertion really is debatable. Languages like APL would read it as having a shape of [2, 0]:

import std.variant : Variant;

size_t[] shape(Variant v) {
    size_t[] s;
    while (cast(TypeInfo_Array) v.type !is null) {
        s ~= v.length;
        if (!v.length) break;
        v = v[0];
    }
    return s;
}

unittest {
    assert([3, 1] == [[1], [2], [3]].Variant.shape);
    assert([2, 1] == [[1], [2]].Variant.shape);
    assert([2, 2] == [[1, 0], [2, 0]].Variant.shape);
    assert([2] == [1, 2].Variant.shape);
    assert([] == 2.Variant.shape);
    assert([2, 0] == [[], []].Variant.shape);

    // irregularity not checked
    assert([2, 2] == [[1, 0], [2]].Variant.shape);
}

On Sunday, 10 July 2022 at 19:14:34 UTC, Paul Backus wrote:

while (cast(TypeInfo_Array) v.type !is null) {
    Variant elem = v[0];
    // etc.
}

I honestly cannot say why but I was having a problem using this earlier. After several hours of frustration, I rebooted the computer, went for a run, came back, and tried again. It works!!! Thank you very much.

--anonymouse