Rust (+SFML) - How to avoid extra object construction when limited by lifetime parameters?

Question

I'm using rust-sfml (rsfml::graphics) to, at the moment, draw pixels to the screen. (I'm just starting with both Rust and the project.) I'm storing the data in an Image, then copying to a Texture.

This Texture is used to create a Sprite<'s>; herein lies my problem. I need to be able to mutate the Texture, but the type of Sprite<'s> seems to guarantee that I can't do what I want. Since I need to be able to call window.draw(&sprite) every time the window is redrawn, I'm just creating a new Sprite each time.

The preferable alternative would keep the Sprite<'s> in my struct Render along with the Texture. Since 'Sprite' has a lifetime parameter, it becomes struct Render<'s>:

struct Render<'s> {
    texture: Texture,
    sprite: Sprite<'s>,
}

I have a method on Render:

fn blit(&'s mut self) -> ()

which mutates the Render (by editing the Texture). Now, as soon as I try to call blit more than once, I run into this problem:

render.blit();
render.blit();  // error: cannot borrow `render` as mutable more than once at a time

which, I think, happens because the lifetime parameter forces the the Render's lifetime-as-borrowed-by-the-first-blit-call to be equal to the lifetime of the Render instance (the whole main function).

How can I keep my original Sprite and continue to be able to mutate the container? Is it possible?

Here is a stupid-looking and fairly minimal example:

extern crate rsfml;

use rsfml::graphics::Sprite;

fn main() -> () {
    let mut render = Render::new();
    render.blit();
    render.blit();  // error: cannot borrow `render` as mutable more than once at a time
}

struct Render<'s> {
    sprite: Option<Sprite<'s>>,
}

impl<'s> Render<'s> {
    fn new() -> Render { Render { sprite: None } }
    fn blit(&'s mut self) -> () { }
}

(Apologies if the question is not clear. It's difficult to express when I'm not very familiar with the concepts.)

That’s not making sense—if your code really *is* just `render.blit(); render.blit();`, then either neither would work or both would work. Can you post more complete code? — Chris Morgan, Jun 26 '14 at 04:37
Thanks, Chris. I've made a semi-minimal example and attached it at the end. — Kai Ninomiya, Jun 26 '14 at 04:55
FYI, the `-> ()` parts are superfluous, as is the `'s ` in your `blit` call. — Chris Morgan, Jun 26 '14 at 05:32
Eww… the use of `'s ` in your `blit` definition is what’s causing it. It makes the borrow last longer. Of course, now I see it… — Chris Morgan, Jun 26 '14 at 05:34
Well, the `'s` in the blit definition becomes needed (I think...) when I have actual code in there which uses `sprite`. — Kai Ninomiya, Jun 26 '14 at 05:39

score 2 · Accepted Answer · answered Jun 26 '14 at 06:01

When you call blit, there are two lifetimes under consideration; self, you see, is of type &'ρ₀ Render<'ρ₁> for certain lifetimes ρ₀ and ρ₁. In your impl<'s> Render<'s> declaration, you have declared that ρ₁ is 's, and in your &'s mut self you have declared that ρ₀ is 's: thus, the lifetime of the borrow of self is 's, which means that you can only ever have one borrow as it will survive until the destruction of the type—it has been declared as “at least as long as the type being referred to”.

You want to alter this to introduce a new lifetime parameter for the blit function which is permitted to be less than 's; you wish ρ₀ to be minimal, only tied to the return value (as I presume you are actually using 's—if not, you should just omit it and allow the compiler to infer what we’re about to write explicitly). This way, the borrow will only be active while the return value of the function is still in scope (in your trivial example, it’s not used and so you can immediately take another reference).

This, then, is the alteration to the function that needs to be done:

fn blit<'a>(&'a mut self) { }

If you alter this to have a return value and use it, you’ll need to make sure that it is out of scope before you call blit again. That may mean passing it directly to a function, or it may mean introducing a new scope, like this:

{
    let foo = render.blit();
    // … do things with foo … it then gets freed at the end of the block.
}
render.blit();

Thanks! I'm now running into another issue, which I guess was the root of the problem all along: If `blit` calls `self.sprite.set_texture(&self.texture, true)`, I get `error: cannot infer an appropriate lifetime for borrow expression due to conflicting requirements`. Should I edit the question? Make a new one? — Kai Ninomiya, Jun 26 '14 at 06:58
I think you will find that bundling the sprite and texture together like this is something that can’t be expressed. You might like to discuss it in the Rust IRC channel (or probably better still, #rust-gamedev) — Chris Morgan, Jun 26 '14 at 07:11
As it so happens, I'm going to the Rust Game Tech meetup at Mozilla tomorrow; so maybe being exposed to it will make everything clearer. — Kai Ninomiya, Jun 26 '14 at 07:17
@KaiNinomiya: there will be people there to talk to about your problem! — Chris Morgan, Jun 26 '14 at 07:37

Rust (+SFML) - How to avoid extra object construction when limited by lifetime parameters?

1 Answers1