Sorry I cannot reply to each thread comments quickly, so I discharge my opinions at once.
---- D's built-in tuple can contain following entities: - Type int, long, array types, AA types, user-defined types, etc - Expressions interger, string literal, etc - Symbol user-defined types, templates, template instances, etc Note that: an user-defined type would be treated as both Type and Symbol. template Test() {} alias X = std.typetuple.TypeTuple!( int, long, char[], int[int], const Object, // Types 1, "str", [1,2,3], // Expressions (literal values) object.Object, Test, Test!(), // Symbols ); If all of the elements in a built-in tuple are Type, today it is normally called "Type Tuple". If all of the elements in a built-in tuple are Expressions, today it is normally called "Expression Tuple". Note that: today we cannot create a built-in tuple without using TemplateTupleParameter. TemplateTupleParameter cannot take expressions non-literal expressions, therefore most of current built-in tuples would contains only literal values as the Expressions. ---- std.typecons.Tuple is an artifact of built-in tuple + alias this. struct Tuple(T...) { T expand; // 'expand' is a built-in tuple of // the implicitly defined fields that // typed T[0], T[1], ... T[$-1]. // In spec, this is called "TupleDeclaration". alias expand this; // forward indexing/slicing operators to // the TupleDeclaration 'expand' } Tuple!(int, string) t; t[]; // t.expand[] t[0..$]; // t.expand[0..$] t[1]; // t.expand[1] So, std.typecons.Tuple _is not special_. You can define another Tuple struct in the same way. We should not define new syntax for the library utility std.typecons.Tuple. If you want to return multiple values from a function, you must always wrap them by std.typecons.Tuple, or other used-defined types. You cannot directly return built-in tuple from a function. (Built-in tuple return is mostly equivalent with multiple-value-return issue. However it would be mostly impossible that defining calling conversion scheme for that in portable) ---- The combination of built-in tuple and alias this would be one of the case of built-in tuple of non-literal Expressions. For example, `t.expand[1]` is equivalent with the dot expression `t.__field_1` which cannot be taken by TemplateTupleParameter. Therefore, `t.expand` would be the built-in tuple of the two dot expressions `t.__field_0` and `t.__field_1`. Therefore, calling built-in tuple "Alias Tuple" would not be correct so built-in tuple can contain expressions that cannot be aliased. ---- My opinions agains various syntax proposals: #(1, "str") --> The character '#' is already used for the start of "Special Token Sequences" http://dlang.org/lex.html#Special Token Sequence It is recognized in lexing phase, so adding semantic meaning to the '#' character would be a contradict of D's principle. Quote from http://dlang.org/lex.html "The lexical analysis is independent of the syntax parsing and the semantic analysis." Kenji Hara