Error message with unboxed closures

Question

This small FizzBuzz program using unboxed closures gives a rather mysterious error message.

fn fizzbuzz<F: Fn(i64) -> bool>(n: i64, f: F, fs: &str, b: F, bs: &str) {
    for i in range(1i64, n+1) {
        match (f(i), b(i)) {
            (true, true) => println!("{:3}: {}{}", i, fs, bs),
            (true, _)    => println!("{:3}: {}", i, fs),
            (_, true)    => println!("{:3}: {}", i, bs),
            _            => (),
        }
    }
}

fn main() {
    fizzbuzz(30,
             |&: i: i64| { i % 3 == 0 }, "fizz",
             |&: j: i64| { j % 5 == 0 }, "buzz");
}

Error message:

<anon>:15:14: 15:40 error: mismatched types: expected `closure[<anon>:14:14: 14:40]`, found `closure[<anon>:15:14: 15:40]` (expected closure, found a different closure)
<anon>:15              |&: j: i64| { j % 5 == 0 }, "buzz");
                   ^~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to previous error

Could someone describe the error please? Thanks.

Answer 1

This piece of code demonstrates the essence of the problem:

fn show_both<S: Show>(x: S, y: S) {
    println!("{} {}", x, y);
}

You can only call it with both arguments of the same type, i.e. this is allowed:

let x: i32 = 10;
let y: i32 = 20;
show_both(x, y);

But this is not:

let x: i32 = 10;
let y: f64 = 20.0;
show_both(x, y);

This is fairly natural: you specified that both of the parameters must be of the same type, even though this type can be arbitrary as long as it implements Show.

You have essentially the same thing in your code:

fn fizzbuzz<F: Fn(i64) -> bool>(n: i64, f: F, fs: &str, b: F, bs: &str)

You declared that both f and b must have the same type. However, for each unboxed closure the compiler generates a different type - this is quite natural as well, given that different closures can capture different variables.

You need to specify different type parameters in order to be able to pass different closures:

fn fizzbuzz<F1, F2>(n: i64, f: F1, fs: &str, b: F2, bs: &str)
    where F1: Fn(i64) -> bool,
          F2: Fn(i64) -> bool

Answer 2

Each unboxed closure definition creates a completely different type. This makes each of the closures defined in main a different type. Your fizzbuz function, on the other hand, requires each of the closures passed to it to be the same type, F. If you change fizzbuzz's signature to:

fn fizzbuzz<F: Fn(i64) -> bool, G: Fn(i64) -> bool>(n: i64, f: F, fs: &str, b: G, bs: &str)

your code will typecheck.

Basically, the <F: Fn(i64) -> bool> syntax doesn't create a wildcard for types that implement the trait parameter (Fn(i64) -> bool), but declares a single type which must satisfy the trait parameter and be the same type everywhere it is used. Unboxed closure definitions must be different types both because the may wrap different environments but also because they dispatch to different functions (that is, each has a different body). As a result, fizzbuzz needs two different type parameters to accommodate the two closure types.