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);
}
