www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Any way to expand a tuple?

reply Andrej Mitrovic <andrej.mitrovich gmail.com> writes:
import std.typetuple;
import std.typecons;

struct Foo
{
    void test(int x, double y) { }

    void opOpAssign(string op, T...)(T t)
        if (op == "~")
    {
        test(t);
    }
}

void main()
{
    Foo foo;
    foo.opOpAssign!"~"(4, 5.0);  // ok
    foo ~= tuple(4, 5.0);  // fail
}

If I understand this correctly in the first call T becomes a D
language tuple, while in the second one it's a phobos library tuple. I
really hate this distinction and would love these two to be merged so
the second call could compile.

Is it possible to expand the phobos tuple in the call to test()? I can
use the isTuple template in a `static if` to figure out if it needs
expansion, so all that's left is to actually expand the phobos tuple.
Sep 24 2011
next sibling parent "Daniel Murphy" <yebblies nospamgmail.com> writes:
"Andrej Mitrovic" <andrej.mitrovich gmail.com> wrote in message 
news:mailman.142.1316903007.26225.digitalmars-d-learn puremagic.com...
 Is it possible to expand the phobos tuple in the call to test()? I can
 use the isTuple template in a `static if` to figure out if it needs
 expansion, so all that's left is to actually expand the phobos tuple.

Yes, use the Tuple's .expand property.
Sep 24 2011
prev sibling parent Lutger Blijdestijn <lutger.blijdestijn gmail.com> writes:
Andrej Mitrovic wrote:

 import std.typetuple;
 import std.typecons;
 
 struct Foo
 {
     void test(int x, double y) { }
 
     void opOpAssign(string op, T...)(T t)
         if (op == "~")
     {
         test(t);
     }
 }
 
 void main()
 {
     Foo foo;
     foo.opOpAssign!"~"(4, 5.0);  // ok
     foo ~= tuple(4, 5.0);  // fail
 }
 
 If I understand this correctly in the first call T becomes a D
 language tuple, while in the second one it's a phobos library tuple. I
 really hate this distinction and would love these two to be merged so
 the second call could compile.

.expand on Tuple and generally .tupleof does the trick. Language tuples are quite different and more general than typecons Tuple. If tuples would automatically expand, this would not be possible: import std.typetuple; import std.typecons; import std.stdio; struct Foo { void test(Tuple!(int, int), double y) { writeln("overload a"); } void test(int, int, double y) { writeln("overload b"); } void opOpAssign(string op, T...)(T t) if (op == "~") { test(t); } } void main() { Foo foo; foo.opOpAssign!"~"(tuple(4, 2), 5.0);// overload a foo.opOpAssign!"~"(tuple(4, 2).tupleof, 5.0);// overload b }
Sep 25 2011