Allow borrowing an Enum variant as a plain tuple (Feat. Req.)

[bluss]

Allow borrowing an enum variant as a tuple of the same types, so that you can use methods already defined on a tuple with those types.

enum Pair<A,B> {
  Nothing,
  Two(A, B),
}

let p: Pair<A, B>;
match p {
   Two(a, b) => (a, b).iter_bytes()
}

This would allow dispatching methods without cloning the Enum variant.

Dispatching tuple methods allow enum impls to re-use functions that are already generically defined over tuples for all type combinations (for example IterBytes).

In a way, it's a simple way to manually do the work of the deriving directive, by reusing the tuple implementation.

[jdm]

Can you use tuple@Two(a, b) => tuple.iter_bytes()?

[bluss]

jdm, no. For the purposes of this example, Pair does not implement the trait we want to use. IterBytes is a convenient example because that trait exists in std. Of course for this particular trait we have an alternative -> deriving, but I think the tuple borrow would be generally useful.

[Aatch]

I'm not sure what you're asking here, if it's to allow something like the pattern Variant(a,b,c) => (a,b,c).foo() to not copy a, b or c, that isn't possible since it would involve some very surprising behaviour and would not play well with pretty much every other feature of Rust. It would also force the compiler to look for such patterns, something that would be so fragile it would make the feature useless.

If you're asking to treat Variant(a,b,c).foo() as a call to (a,b,c).foo(), then that isn't possible because methods are resolved based on the type.

I'm going to close this as I cannot think of a realistic use case where you wouldn't just use a tuple anyway.

[bluss]

it's not about pattern matching, but allowing to borrow a variant as a pointer to a similar tuple type. It could be a function.