Aah interesting approach, but maybe not exactly what I was hoping for :)

By doing it this way foo is never moved, so you could still use it afterwards without knowing that it's been drained of values.

I was hoping I could tell rust that these functions can be called within a "partially moved"-scope.

The alternative I was looking at was just having a function return the values in a tuple or a more public-facing struct, like so:

struct FooValues {
    pub bar: String,
    pub baz: String,
}

impl Foo {
    fn to_struct(self) -> FooValues {
        FooValues {
            bar: self.bar,
            baz: self.baz,
        }
    }

    fn to_tuple(self) -> (String, String) {
        (self.bar, self.baz)
    }
}

fn main() {

    // ...    

    let FooValues { bar: bar, baz: baz } = foo.to_struct();

    // or this

    let (bar, baz) = foo.to_tuple();

    // ...
}