Error code E0401

Inner items do not inherit the generic parameters from the items they are embedded in.

Erroneous code example:

#![allow(unused)]
fn main() {
fn foo<T>(x: T) {
    fn bar(y: T) { // T is defined in the "outer" function
        // ..
    }
    bar(x);
}
}

Nor will this:

#![allow(unused)]
fn main() {
fn foo<T>(x: T) {
    type MaybeT = Option<T>;
    // ...
}
}

Or this:

#![allow(unused)]
fn main() {
fn foo<T>(x: T) {
    struct Foo {
        x: T,
    }
    // ...
}
}

Items nested inside other items are basically just like top-level items, except that they can only be used from the item they are in.

There are a couple of solutions for this.

If the item is a function, you may use a closure:

#![allow(unused)]
fn main() {
fn foo<T>(x: T) {
    let bar = |y: T| { // explicit type annotation may not be necessary
        // ..
    };
    bar(x);
}
}

For a generic item, you can copy over the parameters:

#![allow(unused)]
fn main() {
fn foo<T>(x: T) {
    fn bar<T>(y: T) {
        // ..
    }
    bar(x);
}
}

#![allow(unused)]
fn main() {
fn foo<T>(x: T) {
    type MaybeT<T> = Option<T>;
}
}

Be sure to copy over any bounds as well:

#![allow(unused)]
fn main() {
fn foo<T: Copy>(x: T) {
    fn bar<T: Copy>(y: T) {
        // ..
    }
    bar(x);
}
}

#![allow(unused)]
fn main() {
fn foo<T: Copy>(x: T) {
    struct Foo<T: Copy> {
        x: T,
    }
}
}

This may require additional type hints in the function body.

In case the item is a function inside an impl, defining a private helper function might be easier:

#![allow(unused)]
fn main() {
struct Foo<T>(T);
impl<T> Foo<T> {
    pub fn foo(&self, x: T) {
        self.bar(x);
    }

    fn bar(&self, y: T) {
        // ..
    }
}
}

For default impls in traits, the private helper solution won’t work, however closures or copying the parameters should still work.