Conteneur hétérogène pour D

Question

Est-ce que D prend en charge des conteneurs hétérogènes (c'est-à-dire un groupement contenant différents types)?

Je connais les tuples, mais la limitation de ne pas être "retour-able" des fonctions tue juste le but que j'ai en tête.

Answer 1

Je suppose que vous utilisez D2 parce que je ne sais pas à propos de D1.

En std.typecons il y a tuple et Tuple qui vous permettent d'utiliser ces « non remboursable » compilation alias tuples fois que vous mentionnez pour créer des valeurs d'exécution.

import std.typecons, std.stdio; 

Tuple!(int, string, int[]) f() { 
    return tuple(5, "xyz", [3, 4, 5]); 
} 

void main() { 
    auto x = f(); 
    writefln("%s is %s", x[1], x[0]); 
    //indices have to be copile-time constants 
} 

Utilisez tuple(v1, v2) comme la valeur et Tuple!(T1, T2) comme son type.

Si vous voulez vraiment une liste de choses que vous ne connaissez pas le type au moment de la compilation, importez std.variant puis Variant[] comme une liste de ces choses.

Answer 2

variante [] et variantArray() ferait le travail, voici quelques exemples

module test; 

import std.variant, std.stdio; 

Variant[] f() { 
    return variantArray(5, "xyz", [3, 4, 5]); 
} 

void main() { 
    auto x = f(); 

    writeln(x); // [5, xyz, [3, 4, 5]] 

    writefln("%s is %s", x[1], x[0]); // xyz is 5 

    x ~= Variant(890); 

    string s = "abc"; 
    x ~= Variant(s); 

    class C {}; 
    x ~= Variant(new C()); 

    x ~= Variant(new int[2]); 
    x[$-1][0] = 5; 

    foreach (e; x) { 
     write(e, " "); // 5 xyz [3, 4, 5] 890 abc test.main.C [5, 0] 
    } 

    f2(x); 

    Variant[] a = variantArray("23", 23); 
    Variant[] b = new Variant[3]; 
    Variant[] c = [Variant(12), Variant("a")]; 
} 

void f2(Variant[] va) { 
    writeln(typeid(va)); // std.variant.VariantN!(maxSize).VariantN[] 
} 

Answer 3

Je vais ajouter ce souci d'exhaustivité.

Je viens d'apprendre à propos de boxArray (dans std.boxer), cela pourrait aussi être une solution.