Thank you, this clears thing to me.

I currently has all stuff wrapped in Variants because it is structure parsed from xml (or json), and it could be for example map of Something[string], where Something could be string or array or another map, and also this all nested few levels deep. I'm new to D and maybe there is better solution exists how to represent such structure ?


On Tuesday, 10 December 2013 at 18:40:48 UTC, Philippe Sigaud wrote:
void main()
{
Variant[] lols = [ Variant(["hello": Variant(1)]), Variant(["bye":
Variant(true)])  ];
auto vtypes = map!(to!Variant[string])(lols); // <--- line 11

    string[] filetypes = map!(to!string)(vtypes).array();
    writeln(filetypes);
}

Gives me:
main.d(11) Error: to!(VariantN!(24u)) is used as a type

As bearophile said, to!Variant[string]... is read as
to!(Variant)[string], which is not what you want. When a template argument is more than one token long (Variant[string] has 4 tokens),
enclose it in parenthesis.

But here it will not help you, as I think the conversion you ask is impossible: how could a Variant be transformed into a Variant[string]? By definition of Variant, the compiler cannot know what is inside. The first element of lol could be an a float wrapped into a Variant, for example, and then how could it be transformed into Variant[string]?

Do you really need to enclose everything in Variants? Types are your
friends, you know :)

An array of Variant[string] would be far easier to work with:

import std.stdio;
import std.algorithm;
import std.range;
import std.array;
import std.conv;
import std.variant;

void main()
{
    // See the type of lols
Variant[string][] lols = [ ["hello": Variant(1)], ["bye": Variant(true)] ];

    string[] filetypes = map!(to!string)(lols).array();
    writeln(filetypes);
}

Reply via email to