I am having a terrible time understanding how to get my use statements right to match the crate I'm wanting to use. I'm also finding it difficult to find and decipher crate-specific documentation that tells me how to implement the functions/methods/traits/etc that I need to access. Now I realize what I just wrote isn't really specific enough for anyone to answer, so I'm going to ask a simpler question and then, hopefully, we can follow up on that to address some of my other confusions. Here goes:
First Question: When looking at examples I see things like: use prelude::*. I was under the impression that the prelude is automatically imported into every Rust program. Why then do I see use prelude::* ? It doesn't make sense to me and seems superfluous.
The preludes you are referring to are different from prelude modules provided by some crates. The former is a build-in feature of Rust, the latter is just a module like any other that is used by crates to make it easier for you to import all the items you need from that crate and start hacking. See also this answer on Stack Overflow.
Thank you. That makes sense and you are right, I am seeing it in the context of a crate-specific prelude. I have started digging into the fltk-rs crate, trying to learn it well enough to use in my applications. Here is a line from an example given in the Fltk Book:
use fltk::{prelude::*, *};
From what you said, the "prelude" word there is specific to the fltk crate. I get that.
This is not specific to modules by the way, but every path/namespace. You can import enum variants or const items and stuff as well. This is done in the real prelude with the variants of Option or Result, for example. This is why you don't have to type let x = Option::None; every time but can just let x = None;. Though this actually has nothing to do with your question I realize while typing...
Good. That's what I thought it meant, but then, in this line I copied above --- use fltk::{prelude::*, *}; --- why do they use both prelude::* and * ? Wouldn't it be sufficient to simply type:
use fltk::*;
That leads me to Question #3. If I include the line above in my program, wouldn't that import everything from the fltk crate and then I wouldn't ever have to worry about anything not being in scope when I want to use it? (I'm pretty sure that doesn't work, but I'd love to know why not.)
use fltk::*; will not import everything from fltk, because * is not recursive. It will only import all visible items from that module, not from every submodule as well:
mod prelude {
pub struct Foo;
pub struct Bar;
pub mod baz {
pub struct Bat;
}
}
use prelude::*;
fn main() {
// Both Foo and Bar are imported
let foo = Foo;
let bar = Bar;
// baz is also imported
let bat = baz::Bat;
// but not Bat from prelude::bat module
let bat = Bat;
}
Ahh...I see. Good example. Very clear. That makes perfect sense.
Question #4: The example I'm currently working from uses this code:
use fltk::{prelude::*, *};
fn main() {
let app = app::App::default();
let mut my_window = window::Window::new(100, 100, 400, 300, "My Window");
my_window.end();
my_window.show();
app.run().unwrap();
}
Since I'm wanting to dig into this crate, it seems smart to look up the window::Window::new() function to make sure I understand all the parameters being passed. I have searched and searched through the documentation and for the life of me I can't find new(). I've encountered the same frustration multiple times, even when looking up functions in the Rust std crate. Is there some convention I'm missing that is making it hard for me to find the info I'm looking for? This has got to be a difficult question to answer, but maybe someone could try? Thanks.
The new function is kind of hidden, I'd use the search function and since there is no explicit DoubleWindow::new(), it can only be a trait method, which is the first hit: DoubleWindow in fltk::window - Rust
Your IDE should be able to give you all the information you need, if not, get a better one. I'm using CLion here, but I think VSCode with rust-analyzer can do the same.
Actually, I'm using Sublime Text, not an IDE. I consulted with my son and he showed me the difference. Pointed me to this one I haven't yet dug into it to see if it will do the searching for me like you demonstrated, but probably will sometime soon. (I'm not too keen on learning a new tool when I'm right in the middle of trying to get started on my project. Still, if it solves this problem with finding the right documentation, it would be worth it.)
{My son is the Web Systems Administrator at a local community college. He doesn't do Rust, but pointed me to it when I described the project I'm starting to work on. He said I could learn Rust and then he could consult with me if he ever decides to learn it. Rust is an awesome language, but I'm blaming him for all the frustrations (like this one) I've been having learning how to use it. :>}
You don't need an actual IDE, any editor with LSP support can integrate with rust-analyzer to provide IDE functionality like goto definition/use/implementation, refactoring assists, et c.
E.g. for using rust-analyzer in Sublime Text, the explanation of how to install it can be found here. I don’t use Sublime Text myself, so I cannot comment on how well that works, how configuration works, what the relevant keyboard shortcuts will be, etc… but in principle rust-analyzer should provide relevant functionality such as helping you with adding a use statement when needed, showing documentation for functions you call, or filling out the basic structure/signatures for a trait implementation, and more.
In case the “inlay hints” (the text hints that will appear in the middle of your code, e.g. for types or function parameter names) are too much for you, it is possible to configure and/or disable those.
This is sort of tangential, but crates often use prelude modules specifically to import traits that are required for the crate's types to work correctly. Without use whatever::prelude::*; you end up needing to import multiple traits to do basic things with the crate.
Since error messages can sometimes be confusing when you try to use a method from a trait that isn't in scope, the prelude makes it much easier to get started.
In fact std even contains some "normal" prelude modules that are totally unrelated to the automatic prelude feature of the language. std::io::prelude being the most prominent example.
