Tuple/TypeTuple etc.

[Dicebot]

On Saturday, 17 August 2013 at 11:43:09 UTC, John Colvin wrote:
> On Saturday, 17 August 2013 at 01:01:10 UTC, Dicebot wrote:
>> Currently it is not the case. typeof(tuple(1,2)) is 
>> Tuple!(int,int), not TypeTuple!(int, int). But 
>> typeof(TypeTuple(1,2)) is TypeTyple!(int, int) :)
>
> Whu?
>
> There is no such type as TypeTuple!(int, int), it is completely 
> aliased away to a builtin tuple.

Yeah but there is no syntax for them so I am using TypeTuple for 
unambiguity. pragma(msg) will print (int, int) for it.

> Also, printing out types is actually rather misleading, as it 
> chooses when to use or not use tuple() in annoying ways e.g. 
> TypeTuple!(int, string) is (int, string) but TypeTuple!(int, 3) 
> is tuple(int, 3)   Either they are both tuples, or neither is.

They are two types of built-in tuples - pure type tuples and 
expression/mixed tuples. typeof expression tuple is type tuple. 
Those have same syntax but slightly different semantics.

> To the best of my knowledge, there is only this:
>
> 1) collections of items, called tuples. They can contain pretty 
> much anything you want, as long it's available at compile-time.
> They are ***not types***. If and only if a tuple contains only 
> types, the tuple itself is a type. This is often referred to as 
> a type-tuple. In current D, tuples of all varieties are created 
> by variadic template parameters.*

All true but last statement. They are not "created" anywhere, 
this is simply most convenient way to capture built-in tuple in a 
form usable by user code.

> 2) instantiations of type-tuples. These are a collection of 
> runtime values, individually accessible by indexing or foreach 
> iteration. std.typecons.Tuple is a wrapper around one of these 
> providing some extra functionality.

As far as I can observe, instantiations of type tuples are 
expression tuples. And std.typecons.Tuple is completely different 
beast, it simply a template struct.

See example:

import std.typetuple;
import std.typecons;
import std.stdio;

void main()
{
	alias TT = TypeTuple!(int, string);
	enum ET = TypeTuple!(2, "2");
	TT twoVars; twoVars[0] = 2; twoVars[1] = "2";
	writeln(typeid(typeof(twoVars)));
	writeln(twoVars);
	writeln(typeid(typeof(ET)));
	writeln(ET);
	auto different = tuple(2, "2");
	writeln(typeid(typeof(different)));
	writeln(different);
	writeln(__traits(allMembers, typeof(different)));
}

------------------------

(int,immutable(char)[])
22
(int,immutable(char)[])
22
std.typecons.Tuple!(int, string).Tuple
Tuple!(int, string)(2, "2")
parseSpecsFieldSpecfieldSpecsextractTypeextractNameinjectNamedFieldssliceSpecsexpandSpecisCompatibleTuplesTypesexpand_0_1fieldat__ctoropEqualsopCmpopAssign_workaround4424slicelengthtoString_expand_field_0_expand_field_1

http://dpaste.dzfl.pl/b98d8537