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
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.puremagic.com/pipermail/digitalmars-d/attachments/20130820/e594044b/attachment-0001.html>