AliasTuples, rather than Records, to return multiple values

[Dario Schiavon]

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?