convenient construction syntax for anonymous structs

[nikomatsakis]

This is somewhat orthogonal, but it'd be nice to be able to "construct" an instance of a trait that has all of methods defined. This would enable modeling OO-like hierarchies quite conveniently, particularly when combined with specialization.

A rough idea (using dyn to clarify trait objects):

trait Widget {
    let bounds: Rectangle;

    fn draw(&self, cx: &mut GraphicsCx);
}

trait Button: Widget {
    let text: String;
}

impl Button {
    fn new(bounds: Rectangle, text: String) -> Rc<dyn Button> {
        Rc::new(Button { bounds, text })
    }

    // Above is equivalent to:
    fn new(bounds: Rectangle, text: String) -> Rc<dyn Button> {
        struct Dummy { bounds: Rectangle, text: String }
        impl Widget for Dummy {
            let bounds = self.bounds;
        }
        impl Button for Dummy {
            let text = self.text;
        }
        Rc::new(Dummy { bounds, text })
    }
}

default impl<T: Widget> Button for T {
    fn draw(&self,  cx: &mut GraphicsCx) {
        cx.box(self.bounds);
        cx.write(self.bounds, self.text); // or whatever
    }
}

More precise rules:

• The sugar-y syntax would be available only for traits where all methods have defaults
• It effectively returns a impl Button, with one field per (non-defaulted) let member

[burdges]

I like this. It's worth considering how this interacts with structural records, if they were to make a come back.

[burdges]

As an aside, there are interesting uses for nameable structural _sub_records of a struct of another structural records, like avoiding the verbosity of the builder pattern. If we have pub struct Foo { a: A, b: B, c: C, d: D } then Foo::{b,c} could be a name for the structural record { b: B, c: C } type, so you could write

impl Foo {
    fn new_partial(..) -> Foo::{b,c} { .. {b,c} }
    pub fn new(..) -> Foo {
        ...
        Foo { a, d, ...newpartial(..) }
    }
}

Is Foo::{b,c} a good name for a type though? Other names might be Foo {b,c} or struct Foo {b,c}. And the choices might interact with this. And the Foo { a, b ..Subrecord } syntax interacts with various ides in the RFC of course.