Expected closure, found a different closure

by

It’s always worth taking a look at the full compiler output:

error[E0308]: mismatched types
  --> src/main.rs:39:20
   |
39 |     a.add_b(B::new(|| println!("test2")));
   |                    ^^^^^^^^^^^^^^^^^^^^ expected closure, found a different closure
   |
   = note: expected type `[closure@src/main.rs:38:20: 38:39]`
              found type `[closure@src/main.rs:39:20: 39:40]`
   = note: no two closures, even if identical, have the same type
   = help: consider boxing your closure and/or using it as a trait object

Especially helpful:

  • no two closures, even if identical, have the same type

  • consider boxing your closure and/or using it as a trait object

We can simplify your example further by removing the type B altogether. Then the only task is to save a vector of closures. As the compiler tells us, no two closures have the same type, but Vec is a homogeneous data structure, meaning that every item in it has the same type.

We can work around that restriction by introducing one level of indirection. As the compiler suggests, this can either be done by trait objects or boxing (the latter kind of includes the first one). The corresponding types would look like this:

  • Vec<&Fn()> (reference to trait objects)
  • Vec<Box<Fn()>> (trait object in a box)

In your example you want to own all closures, thus the correct choice is to box all closures, as Box<T> is an owning wrapper while references only borrow stuff.

A fully working example:

struct A {
    b_vec: Vec<B>,
}

impl A {
    fn new() -> A {
        A { b_vec: Vec::new() }
    }

    fn add_b(&mut self, b: B) {
        self.b_vec.push(b);
    }
}

struct B {
    f: Box<Fn()>,
}

impl B {
    fn new<F>(f: F) -> B
    where
        F: Fn() + 'static,
    {
        B { f: Box::new(f) }
    }
}

fn main() {
    let mut a = A::new();
    a.add_b(B::new(|| println!("test")));
    a.add_b(B::new(|| println!("test2")));
}

More Related Contents:

  1. Traits and Rust
  2. Why do try!() and ? not compile when used in a function that doesn’t return Option or Result?
  3. Why does linking lifetimes matter only with mutable references?
  4. Why is adding a lifetime to a trait with the plus operator (Iterator + ‘a) needed?
  5. How do I collect into an array?
  6. Cannot borrow as mutable more than once at a time in one code – but can in another very similar
  7. Is it considered a bad practice to implement Deref for newtypes?
  8. Implementing a trait for multiple types at once
  9. How do I get an owned value out of a `Box`?
  10. How do I borrow a RefCell, find a key, and return a reference to the result? [duplicate]
  11. How can I store a Chars iterator in the same struct as the String it is iterating on?
  12. Converting from Option to Option
  13. How to disable unused code warnings in Rust?
  14. Is there a way other than traits to add methods to a type I don’t own?
  15. How do you use parent module imports in Rust?
  16. Why is the `Sized` bound necessary in this trait?
  17. Is it possible to return either a borrowed or owned type in Rust?
  18. How do I overcome match arms with incompatible types for structs implementing same trait?
  19. Example of how to use Conditional Compilation Macros in Rust
  20. How can I call a raw address from Rust?
  21. Is there a way to perform an index access to an instance of a struct?
  22. How to take ownership of T from Arc?
  23. Is there any trait that specifies numeric functionality?
  24. Why would I use divergent functions?
  25. How to generate statically linked executables?
  26. When is it necessary to circumvent Rust’s borrow checker?
  27. Comparing every element in a vector with the next one
  28. How to repeat a static string at compile time
  29. How to concatenate static strings in Rust
  30. How can I build multiple binaries with Cargo?

Leave a Comment