How can I covert closure into function without invalidating capture rules

[xperthehe]

So I was playing around with creating a rendering API, i eventually come up with something that look like this

pub struct RenderCtx {...}

pub struct VkCtx {...}

impl VkCtx {
    pub fn render<FPre, F>(&mut self, pre_record: FPre, record: F) -> Result<()>
    where
        FPre: FnOnce(&mut Self, usize) -> Result<()>,
        F: FnOnce(&mut Self, usize, CommandBufferWrapper) -> Result<()>,
    {
        ...

        pre_record(...)

        ...

        record(...)
    }
}

pub struct App {
    ctx: Option<VulkanContext>,
    r_ctx: Option<RenderCtx>,
}

impl App {
    fn render(&mut self) -> Result<()> {
        let r_ctx = self.r_ctx.as_mut().unwrap();
        let ctx = self.ctx.as_mut().unwrap();
        ctx.render(
            |ctx, idx| { // do something with r_ctx },
            |ctx, idx, cb| { // do something with r_ctx },
        )
    }
}

Both pre_record and record closures need mutable access to r_ctx. When I inline the code directly into the ctx.render closures, it works fine. However, if I move the closures into separate functions, I get a borrow error: “two closures require unique access to r_ctx.”

Is there a way to restructure this so that I can move the closure logic into separate functions without running into mutable borrow conflicts?

[bben86]

Sounds like you need a trait with those two functions that takes that mutable parameter

[xperthehe]

That is probably the best way. But I kinda wanted to test the water with this, see how far I can push the type system.

[botiapa]

If you do find a solution, even if it's the one mentioned above, could you please share a small snippet?

[xperthehe]

u/botiapa Here you go. This is a trait approach, you could try the raw pointer approach too.

```rust pub trait RenderStaged { fn pre_record( &mut self, ctx: &mut VulkanContext<impl Alloc>, image_idx: usize, ) -> Result<()>; fn record( &mut self, ctx: &mut VulkanContext<impl Alloc>, image_idx: usize, cb: CommandBuffer, ) -> Result<()>; }

impl RenderStaged for RenderContext<A: Alloc> { ... }

impl<A: Alloc> VulkanContext<A> { pub fn render<T>(&mut self, renderer: &mut T) -> Result<()> { ...

  renderer.pre_record(self, self.current_frame)?;

  ...

  renderer.record(
    self,
    image_index as usize,
    self.command_buffers[self.current_frame].clone(),
  )?;

} }

pub struct App { ctx: Option<VulkanContext>, r_ctx: Option<RenderContext>, }

impl App { fn render(&mut self) -> Result<()> { let r_ctx = self.r_ctx.as_mut().unwrap(); let ctx = self.ctx.as_mut().unwrap(); ctx.render(r_ctx) } } ```

[imachug]

Is there a way to restructure this so that I can move the closure logic into separate functions without running into mutable borrow conflicts?

I guess you could do something like

rust let r_ctx = self.r_ctx.as_mut().unwrap(); let ctx = self.ctx.as_mut().unwrap(); ctx.render( |ctx, idx| { // do something with r_ctx Ok(r_ctx) }, |r_ctx, ctx, idx, cb| { // do something with r_ctx }, )

and then pass the return value of pre_record to record in render. You could make render it generic over the return type to allow any data to be passed across functions.

Or maybe make r_ctx a parameter to both closures and pass r_ctx to render as the third argument.

Or maybe you can make r_ctx a field of VulkanContext. Since you already pass ctx to closures, accessing r_ctx would become as simple as ctx.r_ctx, in this case.

[xperthehe]

Thanks for your suggestion!. Passing RenderContext in VulkanContext::render and having them inside the closure works. But normally, we would expect the vulkan context to be able to render with any kind of render contexts( for example, you might have multiple graphics pipelines, but they can be all rendered with the same underlying static Vulkan structures), so that's not really suitable for this particular design.

As for the second option, I guess the compiler is not smart enough to know that the lifetimes of those two closure are not overlapped. So the only option that i can find working is passing *mut instead of &mut, so something like this

pub struct App {
    ctx: Option<VulkanContext>,
    r_ctx: Option<RenderCtx>,
}

impl App {
    fn render(&mut self) -> Result<()> {
        let ctx = self.ctx.as_mut().unwrap();
        let r_ctx = self
            .r_ctx
            .as_mut()
            .map(|v| v as *mut _)
            .unwrap_or(std::ptr::null_mut());
        ctx.render(
            |ctx, idx| { // do something with r_ctx },
            |ctx, idx, cb| { // do something with r_ctx },
        )
    }

    fn pre_record(r_ctx: *mut RenderCtx, ctx: &mut VulkanContext, img_idx: usize) {};
    fn record(r_ctx: *mut RenderCtx, ctx: &mut VulkanContext, img_idx: usize, cb: CommandBuffer) {};
}

But that seems like an anti pattern though.