Unpacking syntax

[Timon Gehr]

These are my ideas for how to support unpacking any tuple-like type into 
multiple components.


Synopsis:

```d
import std.typecons: t=tuple, T=Tuple;

void main(){
     // unpack declarations
     auto (a, (b, c)) = t(1, t(2, "3"));
     assert(t(a, b, c) == t(1, 2, "3"));

     import std.stdio, std.string, std.conv;
     auto (u, v) = readln().strip.split.to!(T!(int,int));

     // can unpack in foreach
     foreach(i, (x, y); [t(1, 2), t(3, 4)]) {
         assert(x==2*i+1 && y==2*i+2);
     }

     // works with storage classes
     auto arr = [t(1, 2), t(3, 4)];
     foreach((ref x, y); arr) {
         x = 2*y;
     }
     foreach(const (x, y); arr) {
         static assert(is(typeof(x) == const(int)));
         static assert(is(typeof(y) == const(int)));
         assert(x == 2*y);
     }

     // works with opApply
     static struct Iota2d{
         int start,end;
         int opApply(scope int delegate(T!(int,int)) dg){
             foreach(i; start .. end) {
                 foreach(j; start ..end) {
                     if(auto r = dg(t(i,j)))
                         return r;
                 }
             }
             return 0;
         }
     }
     bool[4][4] visited;
     foreach((x, y); Iota2d(0,4)){
         visited[x][y] = true;
     }
     import std.algorithm;
     assert(visited[].all!((ref x)=>x[].all));

     // works with ranges
     import std.range;
     foreach(i, (j, k); enumerate(arr)) {
         writeln(i," ",j," ",k); // "0 4 2\n1 8 4\n"
     }

     // can unpack in lambda parameter list
     [t(1, 2), t(2, 3)].map!( ((a, b)) => a+b ).each!writeln; // "3\n5\n"

     // works with storage classes
     arr.each!( ((ref x, y)){ x = 3*y; });
     assert(arr.all!( (const (x, y)) => x == 3*y));
}
```

The code above works with my implementation, which can be found at:
https://github.com/tgehr/dmd/tree/unpacking


An unpacking declaration works if the right-hand side is an expression 
sequence or has `alias this` to an expression sequence. The number of 
elements has to match exactly.

Each variable without explicitly declared type that is unpacked to needs 
to have at least one storage class.

```d
auto (a, b) = t(1, 2); // ok
(auto a, auto b) = t(1, 2); // ok

(a, auto b) = t(1, 2); // error
(auto a, b) = t(1, 2); // error
```

This is less confusing and would allow this syntax to be used for mixed 
variable declaration and reassignment in the future.


Types can be declared explicitly, or inferred, independently for each 
variable:
```d
(int a, (string b, auto c)) = t(1, t("2", 3.0f));
```

Note that it is _not_ possible to declare a type for the whole unpacking 
explicitly:

```d
Tuple!(int, int) (a, b) = t(1, 2); // error
```

Storage classes can be applied to all unpacked variables independently.

```d
(auto a, const b, immutable c) = t(1, 2, 3);
```

Unpacking works with all variants of the `foreach` statement. (See 
synopsis for some examples, `foreach((x, y); a .. b)` can work too if 
`a` and `b` happen to be tuple-like types.) Here, storage classes are 
not required, consistent with how `foreach` works without unpacking.


Unpacking works in the parameter list of a function literal:

```d
int function(Tuple!(int, int)) f = ((x, y)) => x + y;

auto summands = t(1, 2);
writeln(f(summands))); // "3\n"
```

Unpacking does not work in the parameter list of a function that is not 
a literal. The reason for this is that there is no canonical type for 
the corresponding parameter:

```d
auto foo((int a, int b), int c){} // error
```

This restriction can be lifted at some point if we add built-in tuple types.


In `foreach` statements and in function literal parameters, the `ref` 
storage class can be applied to individual variables within an 
unpacking. They will cause the entire structure to be passed by `ref`, 
but non-`ref` unpacked variables will be initialized by value. (See 
synopsis for some examples.)

The `lazy` storage class is not supported for unpacked parameters, as 
that does not seem to make sense.



Limitations:

- The `auto ref` storage class is not currently supported on unpacking 
declarations.

- Applying the `out` storage class to individual variables within an 
unpacking is not currently supported.


I think this is a decent minimum viable product in terms of unpacking.



Future work:
- Move semantics for unpacking. (Currently it will do too many copies.)

- Do we want some way to define a manual unpacking without `alias this`?

- Do we want to be able to directly unpack static arrays and array 
slices of the correct length?

- `auto ref` support.

- `out` parameters in unpackings, e.g. `((in x, out y)){ y=x; }`

- Do we want a way to partially unpack? E.g., `auto (x, y, ...) = t(1, 
2, 3, 4);`
- Wildcards. E.g., `auto (_, x) = t;`

- General tuple syntax. (WIP at: 
https://github.com/tgehr/dmd/tree/tuple-syntax )