Communities

Writing
Writing
Codidact Meta
Codidact Meta
The Great Outdoors
The Great Outdoors
Photography & Video
Photography & Video
Scientific Speculation
Scientific Speculation
Cooking
Cooking
Electrical Engineering
Electrical Engineering
Judaism
Judaism
Languages & Linguistics
Languages & Linguistics
Software Development
Software Development
Mathematics
Mathematics
Christianity
Christianity
Code Golf
Code Golf
Music
Music
Physics
Physics
Linux Systems
Linux Systems
Power Users
Power Users

Dashboard
Notifications
Mark all as read
Q&A

updating a function within a struct

+4
−0

What I want: An object that contains a function that I can update after creation.

I created a struct that contains a parameter b and a function(closure?) named Internal_Fn.

struct MyThing {
    b: f32,
    Internal_Fn: Box<dyn Fn(f32) -> f32>,
}

To allow me to update Internal_Fn, I add the update_Fn method to MyThing.

impl MyThing {
    fn update_Fn(&mut self, delta_b: f32) {
        let new_b = self.b + delta_b;
        self.b = new_b;
        self.Internal_Fn = Box::new(|x: f32| ((1.0 + new_b).powf(x) - 1.0) / new_b);
    }
}

I get a compiler error

9  |         self.Internal_Fn = Box::new(|x: f32| ((1.0 + new_b).powf(x) - 1.0) / new_b);
   |        --------------------------^^^^^-------------------------
   |                            |        |                |
   |                            |        |                borrowed value does not live long enough
   |                            |        value captured here
   |                            cast requires that `new_b` is borrowed for `'static`
10 |     }
   |     - `new_b` dropped here while still borrowed

If I understand correctly, the problem is that the parameter that I set in my new Internal_Fn (i.e. new_b) is dropped once the update_Fn is finished but Internal_Fn is supposed to live on. Is that correct?

How do I do this? I don't just want to hard code the shape of the function and only update the parameter b. I want to be able to also provide entirely differently shaped functions.

Why does this post require moderator attention?
You might want to add some details to your flag.
Why should this post be closed?

0 comment threads

1 answer

+4
−0

You are correct in your analysis (though I would not call new_b a "parameter" but a captured variable).

What you want is for the closure (anonymous function) to take responsibility for new_b and not just borrow it temporarily. In other words, you want move semantics and not a borrow.

As mentioned in Rust by Example, closures borrow their captured variables by default. If you would instead like to move them, you simply need to put move before the parameter list of the closure. (See the bottom of the linked section.) That is:

impl MyThing {
    fn update_Fn(&mut self, delta_b: f32) {
        let new_b = self.b + delta_b;
        self.b = new_b;
        self.Internal_Fn = Box::new(move |x: f32| ((1.0 + new_b).powf(x) - 1.0) / new_b);
    }
}
Why does this post require moderator attention?
You might want to add some details to your flag.

0 comment threads

Sign up to answer this question »