Hi everybody!
I've been lurking this forum for quite some time, attracted by
the power and elegance of D. Although I'm not a programmer by
profession, I often happen to develop programs for scientific
data evaluation at work and I've always being intrigued with
programming languages since I was a teenager. A lot of time has
passed since the last time I looked at D, and now I'm really
impressed with the amount of progress that has been done.
However, I don't understand why some feature that would be so
desirable are still not implemented and, although there are
already a lot of posts about them, little to no progress is done
at implementing them. One of these is using tuples to return
multiple values from functions. I'd like to share with you my
thoughts and opinions about how tuples might work and be useful
in D. I hope you find this contribution useful, and you will let
me understand where the problems are otherwise. I also apologize
for the length of my post if it doesn't really contain anything
new.
At the time being we have two kinds of tuples in D and a lot of
confusion about them. The first one is the Tuple object in Phobos
(std.typecons.Tuple), which I'm going to call "Record" for the
rest of the post to avoid confusion. They are pretty similar to
Python's tuples, except that they are not immutable and have
named items (admittedly a useful addition).
By introducing Records, you were probably trying to achieve the
following two points:
1) Provide a way to group values together, as if they were
anonymous struct's. Unfortunately, Records are not compatible
with ordinary struct's despite all their similarities. And I'm
also not totally convinced they are that useful, except when
dealing with point 2. They just confuse novices about whether
they should be using Records or struct's, just like they can't
choose between tuples and lists in Python.
2) Provide a mechanism for functions to return multiple values.
It may be noted that functions in D can already return multiple
values through out/ref arguments, but most people agree that
returning multiple values would be a neater solution (I also do).
This mechanism doesn't work yet because of the lack of compiler
support. I don't understand, however, why Records should be a
better candidate to implement this feature than TypeTuples (more
about that later).
Before going on, let me open a parenthesis about how returning
multiple values works in Python. Suppose that the function "func"
returns two values. The following saves the two values in the
variables a and b.
(a, b) = func()
The parentheses around the tuple are not necessary, but I include
them anyway for clarity. I'd like you to notice that this syntax
is treated specially in Python. Python's tuples are immutable so
you can't assign values to them.
c = (0, 1)
c[0] = 2 # error: tuple object does not support item assignment
c = (2, 3) # this changes the reference c so that it points to a
different tuple
d = (a, b)
d = func() # this doesn't assign the return values to a and b!
(a, b) = func() # this does, but it's obviously a special case
Ok, enough for Python, let's go on with D.
The second kind of tuple is the in-built construct used in
templates to group template arguments (std.typetuple.TypeTuple).
Let's call it AliasTuple for the rest of the post, since
TypeTuple is really a misnomer (as others before me have already
pointed out: they can contain more than just types).
It must be noted that AliasTuples are not containers. They may be
considered a kind of compile-time container, but definitely not a
run-time container. With this, I mean that they don't copy their
content in a structured form in a determined region of memory at
runtime, like arrays, linked-lists and Records do. This implies,
for example, that we can't take their address or make an array of
them. AliasTuples are just collections of aliases, they don't
contain actual data. So they are not "just another struct-like
container in the language", like Records are.
We may debate about how many defects AliasTuples have but, I
guess, we all agree that they are an extremely useful construct
for D's templates. Without them, templates in D would certainly
be much more difficult to use and they would lose much of their
power. Therefore, I hope nobody really intends to scrap them. If
they have deficiencies (for instance, they can't actually be used
to return multiple values from functions), I think we should
improve them so that they cover all the useful use cases.
It is my opinion that AliasTuples are much more appropriate to
manage multiple return values than Records. However, for that to
be possible, we must solve some of their weaknesses. One of them
is that there isn't a concise literal expression yet. Let's
suppose that we can create a tuple like this:
@(1, 2, float) // equivalent to TypeTuple!(1, 2, float)
Of course it would be preferable to have just the parentheses
without the @. Unfortunately, it would clash with the normal
parentheses and the comma expression. In Python it works that
way, but single-valued tuples are awkwardly defined as (1,).
Bearophile suggested for syntax (|1, 2|) (although that was for
Records), which I happen to like even less than @(1, 2). Maybe
someone will come out with a better syntax later on.
Since an AliasTuple contains just aliases, assigning a value to
an item of the AliasTuple is actually equivalent to assign the
value to the "thing" the alias points to. The following would be
valid D code (it already works if you replace @() with
TypeTuple!()).
int a;
alias @(1, 2, float, a) b; // defines b to be the given tuple
b[3] = 3; // assigns 3 to the variable a
The following snipped, instead, doesn't work yet but I think it
should be made to work:
int a=1, b=2;
@(a, b) = @(b, a); // should swap values between a and b
writeln(a, b); // outputs "22" but should output "21"
Let's suppose it is possible to define a function that returns an
AliasTuple. The following might be a possible syntax. If the
return type of a function is an AliasTuple of only types, then
the function should returns an AliasTuple of values with those
types.
@(int, int) func() {
return @(4, 5);
}
int x, y;
@(x, y) = func();
Note that the last line is not a special case as it is in Python.
It naturally works that way because an AliasTuple is a collection
of aliases and not a container. There should not be any
implementation problem in this feature, because it would be just
syntax sugar for:
int func(out int z) {
z = 5;
return 4;
}
int x, y;
x = func(y);
What do you think of it?
