E0401 - Error codes index
Description: Book listing all Rust error codes

## Keyboard shortcuts

Press `←` or `→` to navigate between chapters

Press `S` or `/` to search in the book

Press `?` to show this help

Press `Esc` to hide this help

# 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.