Rfcs: RFC: Add syntaxic sugar for struct expressions fields from variables of the same name

Created on 24 Sep 2014 · 10Comments · Source: rust-lang/rfcs

Issue by SimonSapin
_Sunday Feb 02, 2014 at 12:29 GMT_

_For earlier discussion, see https://github.com/rust-lang/rust/issues/11990_

_This issue was labelled with: A-parser, B-RFC in the Rust repository_

The general syntax for a struct pattern is:

StructName { field_name: new_variable_name }

But when the desired variable name is the same as the field name, it does not need to be repeated:

let MyStruct { name } = struct_value;
do_something_with(name);

This proposal is to add similar syntax sugar for struct expressions:

let name = …;
let struct_value = MyStruct { name };

… would be the same as:

let name = …;
let struct_value = MyStruct { name: name };

CC: @eddyb

Source

rust-highfive

All 10 comments

This was discussed in https://github.com/rust-lang/meeting-minutes/blob/master/weekly-meetings/2014-02-11.md#binding-in-struct-patterns

There were some concerns about ambiguities in e.g. for x in Foo { x } { }, but the grammar was changed since then (I think?) so that the desugared form of this would not be valid either.

fn main() {
    struct Foo { x: () }
    impl Iterator<()> for Foo {
        fn next(&mut self) -> Option<()> { None }
    }
    let x = ();
    for i in Foo { x: x } { }
}

a.rs:7:21: 7:22 error: expected one of `;`, `}`, found `:`
a.rs:7     for i in Foo { x: x } { }

CC @nick29581

SimonSapin on 7 Nov 2014

Is this still unambiguous with type ascription?

theemathas on 1 Apr 2015

@theemathas: it is still unambiguous; the full form of struct initialisation is defined appropriately so that type ascription works, and the additional, simpler form that this permits cannot have any colons (it’s commas and identifiers only), so there is no interaction with the type ascription feature.

chris-morgan on 4 May 2015

So, this feature was suggested (https://github.com/rust-lang/rust/issues/11990) and then prototyped ( https://github.com/rust-lang/rust/pull/11994 ) back in February 2014

The team collectively declined to adopt the feature for Rust 1.0 : https://github.com/rust-lang/rust/issues/11990#issuecomment-34791865 (again, back in Febuary 2014).

But then in June 2014, we accepted RFC 92, that restricted the use of struct literals to only appear in _certain_ expression positions.

RFC text: https://github.com/rust-lang/rfcs/blob/master/text/0092-struct-grammar.md
RFC PR: https://github.com/rust-lang/rfcs/pull/92 (May 2014)
Implementation: https://github.com/rust-lang/rust/issues/14885 (also June 2014)

I believe that with the restriction specified by RFC 92, we could readily add this feature to the language backwards compatibly; that is, the parsing ambiguity issues are no longer present, I think.

Parsing ambiguity was the primary reason we declined to do this according to https://github.com/rust-lang/meeting-minutes/blob/master/weekly-meetings/2014-02-11.md#binding-in-struct-patterns
There were other more abstract reasons also discussed there (e.g. is such a form "hygienic"), but I think all those points are debatable. In particular, even king of hygiene @dherman said "it's such great sugar that it's hard to avoid"

I'm going to assign this to myself as a reminder to try to draft up a formal RFC for it at some point in the (hopefully near) future.