Implementing Fn<Args, R> for multiple Args results in confusing error

[tomjakubowski]

It may be that overloaded calls aren't meant to be abused this way; even if that's the case I think the error message (at least the second one) could be improved:

#![feature(unboxed_closures)]

use std::ops::Fn;

struct Foo;

impl Fn<(isize, isize), ()> for Foo {
    extern "rust-call" fn call(&self, args: (isize, isize)) {
        println!("{:?}", args);
    }
}

impl Fn<(isize, isize, isize), ()> for Foo {
    extern "rust-call" fn call(&self, args: (isize, isize, isize)) {
        println!("{:?}", args);
    }
}


fn main() {
    let foo = Foo;
    foo(1, 1);
}

<anon>:22:5: 22:14 error: the type of this value must be known in this context
<anon>:22     foo(1, 1);
              ^~~~~~~~~
<anon>:22:5: 22:14 error: cannot use call notation; the first type parameter for the function trait is neither a tuple nor unit [E0059]
<anon>:22     foo(1, 1);
              ^~~~~~~~~

edit: updated source for rust changes on 2014-12-03
edit: another update 2015-01-20

[tomjakubowski]

I should note the same happens for overloading on the return type:

#![feature(unboxed_closures)]
use std::ops::Fn;
struct Foo;

impl Fn(i32, i32) for Foo {
    extern "rust-call" fn call(&self, args: (i32, i32)) {
        println!("{:?}", args);
    }
}

impl Fn(i32, i32) -> i32 for Foo {
    extern "rust-call" fn call(&self, args: (i32, i32)) -> i32 {
        println!("{:?}", args);
        0
    }
}

fn main() {
    let foo = Foo;
    let x: i32 = foo(1, 1);
}

[steveklabnik]

Triage: same error today. Here's the updated code:

#![feature(unboxed_closures)]

use std::ops::Fn;

struct Foo;

impl Fn<(isize, isize)> for Foo {
    extern "rust-call" fn call(&self, args: (isize, isize)) -> Self::Output {
        println!("{:?}", args);
    }
}

impl FnMut<(isize, isize)> for Foo {
    extern "rust-call" fn call_mut(&mut self, args: (isize, isize)) -> Self::Output {
        println!("{:?}", args);
    }
}

impl FnOnce<(isize, isize)> for Foo {
    type Output = ();
    extern "rust-call" fn call_once(self, args: (isize, isize)) -> Self::Output {
        println!("{:?}", args);
    }
}

impl Fn<(isize, isize, isize)> for Foo {
    extern "rust-call" fn call(&self, args: (isize, isize, isize)) -> Self::Output {
        println!("{:?}", args);
    }
}

impl FnMut<(isize, isize, isize)> for Foo {
    extern "rust-call" fn call_mut(&mut self, args: (isize, isize, isize)) -> Self::Output {
        println!("{:?}", args);
    }
}
impl FnOnce<(isize, isize, isize)> for Foo {
    type Output = ();
    extern "rust-call" fn call_once(self, args: (isize, isize, isize)) -> Self::Output {
        println!("{:?}", args);
    }
}

fn main() {
    let foo = Foo;
    foo(1, 1);
}

[cyplo]

Still same error on rustc 1.21.0-nightly (469a6f9 2017-08-22)

[alexreg]

Is this still occurring?

[cyplo]

Looking at the link provided by Steve - it seems it's still failing on the nightly on playground (https://play.rust-lang.org/?gist=fe78a973c074edba7b422252bdf40bf1&version=nightly)
The error messages are slightly but not largely different now.

[alexreg]

I agree, the error message is still pretty confusing. Ideally, the error would be at the point of defining the second impl Fn<...> for the same type.