Is there any chance that C3 support tuple?

[hucancode]

Being able to use tuple is very convenient when you don't want to create a full struct to handle return value. For example:
I can return multiple value in a function (I imagine the syntax something like this)

fn (NodeHandle, Matrix4x4f, bool)! my_function() {
    // do some business
}
fn main() {
    (NodeHandle node, Matrix4x4f mat, bool reversed) = my_function()!!;
    node, _, reversed = my_function()!!; // don't need the matrix
}

Without it

fn void! my_function(NodeHandle*,Matrix4x4f*, bool*) {
    // do some business
}
struct MyFunctionResult {
    NodeHandle node;
    Matrix4x4f mat;
    bool reversed;
}
fn MyFunctionResult! my_function2() {
    // do some business
}
fn main() {
    NodeHandle node;
    Matrix4x4f mat;
    bool reversed;
    my_function(&node, &mat, &reserved)!!; // either do this
    MyFunctionResult ret = my_function2()!!; // or this
}

Another use case I find it useful is to quickly define a state. I often use a stack/queue of tuple to DFS or BFS

List{(NodeHandle, Matrix4x4f, bool)} stack;
while(!stack.is_empty()) {
    (NodeHandle node, Matrix4x4f mat, bool reversed) = stack.pop()!!;
    // do some business
    stack.push((node, mat, false));
}

Without it

List{NodeHandle} node_stack;
List{Matrix4x4f} transform_stack;
List{bool} dir_stack;
while(!node_stack.is_empty() && transform_stack.is_empty() && dir_stack.is_empty()) {
    NodeHandle node = node_stack.pop();
    Matrix4x4f mat = transform_stack.pop();
    bool reversed = dir_stack.pop();
    // do some business
    node_stack.push(node);
    transform_stack.push(mat);
    dir_stack.push(false);
}

Imagine when I am in the middle of implementing a DFS, I suddenly need a new state I have to go back up and declare a new List and manage that list, that will add some friction.

[lerno]

Look at #783, essentially there was too little use for it.

[lerno]

fn (NodeHandle, Matrix4x4f, bool)! my_function() {
    // do some business
}
fn main() {
    (NodeHandle node, Matrix4x4f mat, bool reversed) = my_function()!!;
    node, _, reversed = my_function()!!; // don't need the matrix
}

Typical C3 API would be:

fn NodeHandle? my_function(Matrix4x4f* matrix, bool *reversed) my_function() {
    // do some business
}
fn void main() {
    bool reversed;
    NodeHandle node = my_function(&&(Matrix4x4f){}, &reversed)!!;
    // or NodeHandle node = my_function(null, &reversed)!!; depending on implementation
}

[lerno]

List{(NodeHandle, Matrix4x4f, bool)} stack;
while(!stack.is_empty()) {
    (NodeHandle node, Matrix4x4f mat, bool reversed) = stack.pop()!!;
    // do some business
    stack.push((node, mat, false));
}

I don't understand, why would not a struct or a Triple {NodeHandle, Matrix4x4f, bool} work here?

[hucancode]

List{(NodeHandle, Matrix4x4f, bool)} stack;
while(!stack.is_empty()) {
    (NodeHandle node, Matrix4x4f mat, bool reversed) = stack.pop()!!;
    // do some business
    stack.push((node, mat, false));
}

I don't understand, why would not a struct or a Triple {NodeHandle, Matrix4x4f, bool} work here?

Thanks. I didn't know about Triple, this could be a nice candidate.
The point is that I don't want to define a new struct just for that small piece of function. If I were to I would have to name it with a very specific name like SceneGraphStaticMeshTraversalState