On Monday, 5 February 2024 at 21:21:33 UTC, TTK Ciar wrote:
My mnemonic: "put" is "tup" backwards, and undoes what tuple
does.
Very clever mnemonic TTK Ciar! :) After reviewing the various
solutions, the one I seem to gravitate towards is based on the
one you presented, well, at least for now until a direct
implementation is implemented (crossing my fingers!). I really
appreciate everyone's help! :-)
```d
import std.stdio;
import std.meta; // AliasSeq!
import std.typecons : tuple;
void main() {
// Create a tuple
auto myTuple = tuple(10, "hello", [1, 2]);
auto myTuple1 = tuple(42, "bye", [3, 4]);
// Declare some variables to unpack into
int myInt, myInt1;
string myString, myString1;
int[] myArray, myArray1;
// Use AliasSeq to unpack the tuple
AliasSeq!(myInt1, myString1, myArray1) = myTuple1;
// Now the variables contain the tuple contents
writeln(myInt1); // 42
writeln(myString1); // "bye"
writeln(myArray1); // [3, 4]
// using an alias to make more descriptive & possibly shorter
alias unpack = AliasSeq;
unpack!(myInt, myString, myArray) = myTuple;
// Now the variables contain the tuple contents
writeln(myInt); // 10
writeln(myString); // "hello"
writeln(myArray); // [1, 2]
// Can also unpack directly:
writeln(myTuple[0]); // 10
}
```
I really didn't know AliasSeq!, so I had Claude2 explain it to
me. Perhaps the explanation below will help other newbies:
---
The `AliasSeq!(myInt, myString, myArray) = myTuple;` line is
using AliasSeq to unpack the tuple into the individual variables.
Here is what happens in more detail:
1. AliasSeq takes a list of symbols as template arguments - in
this case the variables we declared before (myInt, myString,
myArray)
2. It generates aliases to match each tuple element to the
variables passed in.
So the first alias will refer to myTuple[0], the second to
myTuple[1], etc.
3. The assignment then takes the value on the right (myTuple) and
copies each tuple element over to the variable the alias refers
to.
So for example, something like this is generated internally:
```d
__alias1 = myTuple[0]; // alias for first element
__alias2 = myTuple[1]; // alias for second element
// Assign aliases to variables
myInt = __alias1;
myString = __alias2;
myArray = __alias3;
```
The key thing AliasSeq does behind the scenes is generate those
positional aliases to each tuple element, and match them up to
the variables we want to unpack into.
The assignment then copies the tuple elements over using the
aliases.
