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?
