How to call a closure in a method - rust

Question

I try to call a closure from a method do_something implemented for structure A. I read some posts about this, but I'm a bit lost now. Here is a simplified version:
// A simple structure
struct A<F> {
f: F,
}
// Implements new and do_something
impl<F> A<F> where F: Fn() {
fn new(f: F) -> A<F> {
A { f: f }
}
fn do_something(&self) {
self.f() // Error is here.
}
}
fn main() {
let a = A::new( || println!("Test") );
a.do_something()
}
It displays this error:
error: no method named f found for type &A<F> in the current scope
I thought closures were called just like this, but it seems I missed something. I tried to replace self.f() with self.f.call() (random test without really understanding), but it says two thing:
error: this function takes 1 parameter but 0 parameters were supplied
error: explicit use of unboxed closure method call is experimental [E0174]
I'm not sure about the first error, but I think I will not use this feature now if it's experimental.
Is there a way to call a closure in a method?

Answer 1

Wrap the member name in parenthesis:
fn do_something(&self) {
(self.f)()
}
If I recall correctly, the underlying cause has to do with precedence when parsing the code. self.f() looks for a method titled f, and will fail because it doesn't exist. (self.f)() causes it to be parsed differently, specifically looking for a member variable.

Answer 2

The second error is a problem here, unboxed closures are a pain to handle. You need tocould box the closure (place it behind a pointer), because closures can have all sorts of weird sizes.
EDIT: As Shepmaster pointed out, this partially incorrect. I will extend the old answer below because it might help when dealing with closures and passing them around.
(Also, call is experimental, and not necessary in this case, so let's do it without that)
struct A<F> {
f: Box<F>,
}
Now that it's stored in a Box (heap-allocated memory, but you could use other types of indirection when necessary), you should also initialize the structure properly:
fn new(f: F) -> A<F> {
A {
f: Box::new(f)
}
}
Finally, you will be able to call it, right?
fn do_something(&self) {
self.f() // Rust being silly
}
But the Rust compiler is still wanting to call a method here instead of our closure-field. So we explicitly dereference the box:
fn do_something(&self) {
(*self.f)() // Explain our intentions to the confused compiler
}
And now, it works! But do we need the indirection here? I thought so, but it seems like not (thanks Shep)! You see, the A struct is already generic, so it should have a size suitable for any single F type. Thus, we do not need the indirection, and can use the old definition:
struct A<F> {
f: F,
}
But now we've at least got a hint of what's happening here, and do_something can be reduced to
fn do_something(&self) {
(self.f)() // Explicitly access a struct member, then call it
}
So it seems it's just a syntactical limitation of the Rust compiler regarding the call syntax.