Tuple type inconsistency

Again, your example involves a feature called tuple shuffling. It is not unintended behavior, but it is undocumented, and it is an active topic of discussion with regards to whether it should exist in the future.

OP's example does not involve that feature. It is not unintended behavior, it is documented (and has even gone through Evolution), and it is not an active topic of discussion except here as a question about usage.

This isn't the Evolution forum, and there's no need to turn every topic about tuples into a debate about how it should be designed into the future.

1 Like

Without being aware of the undocumented feature of tuple shuffling (let alone it's possible deprecation), my example certainly looks like it is clearly related to that of the OP, so my mentioning of it and your explanation helped the OP, me and other readers of this thread to get a more complete answer to the original question.

I think every Swift user and compiler dev should be concerned about the currently (not future) intended behavior not being documented.

As seen above (and in almost every tuple related thread), it's not only me who is confused.

After years of bumping into and reporting what often turns out to be tuple related bugs, no indication of things getting better / less confused, and no clear acknowledgement from the core team that the currently intended design need to be clearly documented, I've made it a habit of pointing this out.

That said, I will stop if you and a couple of other people more experienced than me tell me to. But I will also not report any more bugs unless I'm able to refer to said documentation.

Look, I'm glad you're so passionate about the topic. There's a time and place for discussing problems, which are very much real, and I for one hope you stay passionate about that.

In this specific instance, a complete and correct answer to the OP's question exists based on existing, documented, intentional, non-buggy behavior. We don't need a manifesto about the history and direction of language and compiler design, nor does the OP need to bash against every sharp edge that remains in the language and walk away with the erroneous impression that nothing is documented and everything is up for grabs about tuples.