Convenience syntax for module imports

[ghost]

Rendered view

[zr40]

This syntax would make it less obvious that the module itself is being imported. Importing the module itself would be done inside the list of imported items, making it look just like any other imported item.

[ghost]

Syntax highlighting for the self keyword would make it look a bit different from all the other items listed. And the guarantee that it must be listed as the first item makes it easier to find it if it's there.

[dhardy]

I like it. At the moment I have this rather clunky include pattern in one module:

use std::io;
use std::io::{IoResult,BufferedReader};
use std::io::fs::{File};

How about going further and allowing the following?

use std::io::{self, fs::File, IoResult,BufferedReader};

[gsingh93]

I like it. I think @dhardy's idea is going a bit too far though.

[mcpherrinm]

The example @dhardy posted of using a path like fs::File inside { } in a use statement seems fairly unobjectionable, but is otherwise fairly seperate from what is proposed here.

I'm in favour of both, though.

[emberian]

This can be delayed until after 1.0, but this is an important ergonomic issue IMO. I have also wanted what @dhardy proposes.

[nikomatsakis]

+1 I've been wanting to suggest this for a long time.

[thehydroimpulse]

+1

[bjadamson]

+1 for sure!

[ftxqxd]

+1

Extending on @dhardy’s idea:

use core::{
    self,
    slice::{self, Items},
    fmt::{
        Show,
        Formatter,
        FormatError,
    },
    iter::{Iterator, FlatMap},
    mem::*,
};

Hmm. Maybe that’s going a bit too far, but it’s not actually too aesthetically displeasing, and it displays the imports as a tree in such a way that it actually is possibly easier to read. It also removes a lot of code duplication.

[ghost]

That import tree reminded me of the file system, and then it occurred to me that the mod.rs files could have also been named self.rs.

[ftxqxd]

@tommit Or, module imports could use mod:

use core::{
    mod,
    slice::{mod, Items},
    fmt::{
        Show,
        Formatter,
        FormatError,
    },
    iter::{Iterator, FlatMap},
    mem::*,
};
use mod::foobar;

[ghost]

@P1start Do you mean that the module-scope self (that refers to the encompassing module) would be then also renamed to mod?

[ftxqxd]

@tommit Yes—to be honest, I still prefer using self for everything, but using mod instead of self could make the import tree better represent a file system.

[ghost]

Well, I made a proposal to rename mod.rs files to self.rs: RFC #128

[alexchandel]

@P1start The module hierarchy is decoupled from the actual filesystem layout by design.

The syntax proposed in here is very convenient, but I think renaming mod.rs to self.rs might be a poor choice.

[nrc]

This was discussed in the meeting today (https://github.com/rust-lang/meeting-minutes/blob/master/weekly-meetings/2014-07-15.md) and we decided to accept this RFC. However, we prefer using mod to using self since self is heavily overloaded already, can be bound as an identifier as well as a keyword, and would have different meanings in a use item depending on if it occurred at the start of the path or in braces at the end of the path.

Modified PR coming up

[alexcrichton]

Closing in favor of #168 (updated by @nick29581)