Use of undeclared type or module `std` when used in a separate module

by

By default, the compiler inserts extern crate std; at the beginning of the crate root (the crate root is the file that you pass to rustc). This statement has the effect of adding the name std to the crate’s root namespace and associating it with a module that contains the public contents of the std crate.

However, in child modules, std is not automatically added in the module’s namespace. This is why the compiler cannot resolve std (or anything that starts with std::) in a module.

There are many ways to fix this. First, you can add use std; in a module to make the name std refer, within that module, to the root std. Note that in use statements, the path is treated as absolute (or “relative to the crate’s root namespace”), whereas everywhere else, paths are treated as relative to the current namespace (be it a module, a function, etc.).

pub mod a {
    use std;

    #[test]
    pub fn test() {
        println!("{:?}", std::fs::remove_file("Somefilehere"));
    }
}

You can also use a use statement to import more specific items. For example, you can write use std::fs::remove_file;. This lets you avoid having to type the whole path to remove_file and just use the name remove_file directly within that module:

pub mod a {
    use std::fs::remove_file;

    #[test]
    pub fn test() {
        println!("{:?}", remove_file("Somefilehere")));
    }
}

Finally, you can avoid using use altogether by prefixing the path with :: to ask the compiler to resolve the path from the crate’s root namespace (i.e. turning the path into an absolute path).

pub mod a {
    #[test]
    pub fn test() {
        println!("{:?}", ::std::fs::remove_file("Somefilehere"));
    }
}

The recommended practice is to import types (structs, enums, etc.) directly (e.g. use std::rc::Rc;, then use the path Rc), but to use functions through an import of their parent module (e.g. use std::io::fs;, then use the path fs::remove_file).

pub mod a {
    use std::fs;

    #[test]
    pub fn test() {
        println!("{:?}", fs::remove_file("Somefilehere"));
    }
}

Side note: You can also write self:: at the beginning of a path to make it relative to the current module. This is more often used in use statements, since other paths are already relative (though they are relative to the current namespace, whereas self:: is always relative to the containing module).

Nowadays, std is directly accessible from everywhere, so the code you showed is compiling as you would expect.

Furthermore, extern crate is no longer needed in Rust edition 2018. Adding a dependency to Cargo.toml makes the crate name directly available as a top-level identifier.

More Related Contents:

  1. Why “explicit lifetime bound required” for Box in struct?
  2. Return local String as a slice (&str)
  3. What is the difference between iter and into_iter?
  4. How does for syntax differ from a regular lifetime bound?
  5. How to get a reference to a concrete type from a trait object?
  6. How do I return a reference to something inside a RefCell without breaking encapsulation?
  7. Conditionally iterate over one of several possible iterators
  8. Why is this match pattern unreachable when using non-literal patterns?
  9. Is there any way to create a type alias for multiple traits?
  10. What’s an idiomatic way to print an iterator separated by spaces in Rust?
  11. What are move semantics in Rust?
  12. println! error: expected a literal / format argument must be a string literal
  13. How do I return an instance of a trait from a method?
  14. “borrowed value does not live long enough” seems to blame the wrong thing
  15. Weird behaviour when using read_line in a loop
  16. Is it possible to make a type only movable and not copyable?
  17. How to use struct self in member method closure
  18. How do I call a function through a member variable?
  19. Why are Rust executables so huge?
  20. How do you pass a Rust function as a parameter?
  21. How do I implement a trait with a generic method?
  22. How do I use conditional compilation with `cfg` and Cargo?
  23. When I can use either Cell or RefCell, which should I choose?
  24. How to implement `serde::Serialize` for a boxed trait object?
  25. Can I take a byte array and deserialize it into a struct?
  26. How do I create a Rust callback function to pass to a FFI function?
  27. Why does a lazy-static value claim to not implement a trait that it clearly implements?
  28. How do I convert a usize to a u32 using TryFrom?
  29. Borrow pointer errors recursively traversing tree [duplicate]
  30. How can I borrow from a HashMap to read and write at the same time?

Leave a Comment