Compiler Explorer

Source code

// For indirection
pub trait With {
    type F;
}

impl With for i32 {
    type F = fn(&str);
}

// A function item to coerce
fn f(_: &str) {}

fn main() {
    // Direct ascription works
    let _: fn(&str) = f;
    let _: <i32 as With>::F = f;

// Trait projection on generic fn or associated fn of generic type works
    fn g<T: With>(_: <T as With>::F) {}
    g::<i32>(f);
    pub struct S<T>(T);
    impl<T: With> S<T> { pub fn h(_: <T as With>::F) {} }
    S::<i32>::h(f);

// Bracket types work
    pub struct N<T: With> { f: <T as With>::F, }
    let _: N<i32> = N { f };

// Actual tuples and aliases of tuples work
    let _: TupleVia<i32> = (f,);
    type TupleVia<T> = (<T as With>::F,);
    let _: (<i32 as With>::F,) = (f,);

// Direct type in variant works
    pub enum E1 { Var(fn(&str)) }
    let _ = E1::Var(f);

// Bracket variants work
    pub enum E2<T: With> { Var { f: <T as With>::F }, }
    let _: E2<i32> = E2::Var { f };

// Tuple constructor fails
    let _: V<i32> = V(f);
    pub struct V<T: With>(<T as With>::F);

// Trait projection in variant fails
    pub enum E3<T: With> { Var(<T as With>::F), }
    let _: E3<i32> = E3::Var(f);
}