Exploding structs

8

Personally we want the following features to be unified and defined under a single RFC:

  1. "Splatting" (array/tuple concatenation)

    [..: [1, 2], ..: [3, 4]] == [1, 2, 3, 4] // (also for b"foo", consts, and variables)
(..: (1, 2), ..: (3, 4)) == (1, 2, 3, 4) // (not for b"foo" as that's not a tuple, but consts and variables)
// not for str because that's !Sized

    these would just be sugar for [a[0], a[1], b[0], b[1]] and (a.0, a.1, b.0, b.1). (sorta. see Pre-RFC: Array expansion syntax for details.)

  2. Subslice subpatterns

    if let [..: [1, 2], rest @ ..] = array // (also for b"foo" and consts, but not variables)
// not for tuples because we currently don't support subslice patterns for tuples anyway (since they don't work with ref/ref mut)

    these are hard to explain but they were originally part of the subslice pattern RFC. it got taken out due to issues with ranges, but there are no issues with ranges with this alternative syntax. this is the big thing that we want, especially as it relates to b"foo" and consts. it would make writing parsers in rust, especially recursive descent parsers with no lexer, significantly easier and more ergonomic. the current alternative is to break the b"foo"'s into b'f', b'o', b'o', which makes grepping and maintenance harder.

    also note that being able to pull array consts into slice patterns might lead to implementation difficulties, but is critical for the success of the feature.

  3. Current FRU syntax would be deprecated in favor of ..: for consistency with the previous 2 features.

It might make sense not to go "all in" and have full-on exploding structs. Rust devs do tend to be conservative about these things. But, exploding structs are simply a further extension of these features from our wishlist. Maybe something to put into a "future work" section of an RFC.