Implementation of traits on functions ignored after function call

[sophiajt]

In this example, I implement a trait on generic functions. One with mutability and one without. When invoked manually, the proper trait gets called. Instead, if I try to peel off the function's unique tag using another function, the traits are no longer visible.

Checked against: rustc 1.8.0-nightly (57c357d 2016-02-16)

trait FooFn {
    fn foo(&self);
}

impl<T: Sized> FooFn for fn(&mut T)-> T {
    fn foo(&self) {
        println!("Generic (with mutable) match!");
    }
}


impl<T: Sized> FooFn for fn(T)->T {
    fn foo(&self) {
        println!("Generic match!");

    }    
}

fn simple_fn(x: i32) -> i32 { 1 }
fn simple_fn2(x: &mut i32) -> i32 { 2 }

fn strip<T, U>(x: fn(T)->U) -> fn(T)->U { x }

fn main() {
    //Works
    &(simple_fn as fn(i32)->i32).foo(); 
    //Also works
    &(simple_fn2 as fn(&mut i32)->i32).foo();

    //Works
    strip(simple_fn).foo();
    //Error: no method named `foo` found for type `fn(&mut i32) -> i32`
    strip(simple_fn2).foo();
}

[arielb1]

This is an unfortunate issue with late-bound regions.

Your impl is for the type for<'a> fn(&'a mut T) -> T, while strip forces T to be concrete, so you have fn(&'α mut T) -> T for some (specific) lifetime α.

I agree that the error message could be better.

[sophiajt]

@arielb1 Assuming I understand what you're saying, it seems like the more specific lifetime still inhabits the space of the more generic lifetimes that the impl covers. If that's true, I'd expect that functionality to still be available, even when it's concrete.

Or are you saying that mechanically the decision of whether the type has the impl available to it has to be made earlier than the nailing down of the lifetime?

[eefriedman]

The issue is fundamentally a type mismatch; there are two different kinds of "generic" lifetime. It tends to be a bit confusing, since the syntax is very similar, and there are implicit conversions in some cases, but the error is legitimate.

To illustrate:

trait FooFn {
    fn foo(&self);
}

impl FooFn for for<'a> fn(&'a mut i32)-> i32 {
    fn foo(&self) {
        println!("Generic (with mutable) match!");
    }
}

impl<'a> FooFn for fn(&'a mut i32)-> i32 {
    fn foo(&self) {
        println!("Generic lifetime match!");
    }
}

impl FooFn for fn(i32)->i32 {
    fn foo(&self) {
        println!("Generic match!");

    }    
}

fn simple_fn(x: i32) -> i32 { 1 }
fn simple_fn2(x: &mut i32) -> i32 { 2 }

fn strip(x: fn(i32)->i32) -> fn(i32)->i32 { x }
fn strip2(x: fn(&mut i32)->i32) -> fn(&mut i32)->i32 { x }
fn strip3<'a>(x: fn(&'a mut i32)->i32) -> fn(&'a mut i32)->i32 { x }
fn strip4(x: fn(&'static mut i32)->i32) -> fn(&'static mut i32)->i32 { x }

fn main() {
    &(simple_fn as fn(i32)->i32).foo(); 
    &(simple_fn2 as fn(&mut i32)->i32).foo();

    strip(simple_fn).foo();
    strip2(simple_fn2).foo();
    strip3(simple_fn2).foo();
    strip4(simple_fn2).foo();
}

[oli-obk]

cc @rust-lang/wg-diagnostics when reporting that a trait is not implemented for a type, we should also search for impls that only differ in lifetimes and explain why/how the lifetimes are different