Re: Variadic functions: How to pass another variadic function the variadic args?

[Ali Çehreli]

On 08/03/2013 09:05 AM, monarch_dodra wrote:

> On Saturday, 3 August 2013 at 15:10:20 UTC, Ali Çehreli wrote:
>> On 08/03/2013 07:58 AM, bearophile wrote:
>>
>> > Gabi:
>> >
>> >>   //HOW TO pass F1(..) the args we were called with ?
>> >
>> >
>> > import std.stdio;
>> >
>> > void f1(Args...)(Args args) {
>> >      foreach (arg; args)
>> >          arg.writeln;
>>
>> Would you expect the following two lines behave the same?
>>
>>     writeln(args);
>>     writefln("%s", args);
>
> I wouldn't.
>
>> Apparently not:
>>
>> 10hello1.5
>> 10
>>
>> Why?
>
> writeln simply prints all the args it receives, then a line break.
>
> writefln, on the other end, only prints its single "fmt" arg. The rest
> of the args are only used as they are referenced in fmt. Your code
> basically boils down to:
>
> writefln("%s", 10, "hello", 1.5);
> => 10
Does args have a type that makes it a single entity? If so, the two 
should behave the same. For example, the output is the same tuples and 
slices:

import std.stdio;
import std.typecons;

void foo(Args...)(Args args)
{
    // Both outputs are the same:
    writeln(tuple(1, "abc", 1.5));
    writefln("%s", tuple(1, "abc", 1.5));

    // Both outputs are the same:
    writeln([ 1, 2, 3 ]);
    writefln("%s", [ 1, 2, 3 ]);

    // Unfortunately, not here:
    writeln(args);
    writefln("%s", args);

    // Let's see why that may be...

    // Prints "(int, string, double)"
    writeln(Args.stringof);
}

void main()
{
    foo(10, "hello", 1.5);
}

According to the last line in foo(), args is three types together. Is 
that a TypeTuple I wonder... Yes, it is a TypeTuple:

import typetuple;

// ...

    // Passes
    static assert(
        is (Args == typeof(TypeTuple!(int.init, string.init, 
double.init))));

Now I see... Since writefln is also a variadic function, it naturally 
peels off the TypeTuple one %s at a time.

It is silly of me to stumble on this :) but I learned that there exists 
one type that is printed differently by the following two lines:

    writeln(a);
    writefln("%s", a);

Can you think of any other type of 'a' that would be different? (Modulo 
formatting like square brackets around slices, commas between elements, 
etc.)

Ali