Reevaluate extern mod as syntax for importing crates.

[brson]

It's not that well loved. It doesn't have anything to do with other uses of extern, and lexically it must be written in a different position than other extern things.

[brson]

Nominating.

[catamorphism]

+1. I always feel embarrassed when I have to explain this to someone.

[Kimundi]

The mod part is also confusing, as it doesn't declare a new module, but rather create an import of an external binaries crate root.

For example, this creates two interchangeable paths to the same module tree:

extern mod extra;
mod foo {
    extern mod extra;
}

While this creates two distinct modules:

mod extra;
mod foo {
    mod extra;
}

[catamorphism]

1.0, backcompat

[brson]

"crate" seems to be the consensus.

[brson]

@huonw can mentor

[huonw]

If someone does want some mentorship, feel free to contact me by commenting here, on IRC (nick: dbaupp) or via email (in my profile).

[flaper87]

I'll work on this one

[thestinger]

I like extern mod, as it works the same way as a mod statement but includes an external module rather than an internal one via source code. I think the term crate is very much insider Rust jargon and won't be as helpful for a newcomer. I don't think this is why people have trouble with Rust's module system.

[eddyb]

Do we really want to add another keyword with just one use case?
And so I'm not completely negative, I see two other ways we can say extern crate without crate being a keyword:

// A procedural macro can expand to an ExternCrate AST node.
extern_crate! extra;
// Similar here, though attributes may not map as well to the AST.
#[extern_crate(extra)];
// These should still work (do we allow visibility on extern mod?):
#[cfg(foo="bar")]
pub extern_crate! foobar;

[sfackler]

Would crate really need to be an extra keyword? Is there any reason that the compiler can't special case a crate ident coming after an extern keyword?

[flaper87]

@sfackler not 100% but I think that in the case of extern mod it is already treated as an ident.

[Kimundi]

For the record, extern mod does not currently work the same as mod:

• Like mod, it adds new definitions to be usable from inside the crate.
• But like use, multiple extern mod statements that refer to the same crate refer to the same definitions, and the items in them can be used interchangeably.

Example:

extern mod extra; 
mod foo { 
    extern mod extra; 
    pub fn bar() { 
        let x: ::extra::arc::Arc<uint> = ::foo::extra::arc::Arc::new(5u); 
        println!("{:?}", x); 
    }
} 
fn main() {
    foo::bar(); 
}

[lilyball]

@sfackler I would like to see context-sensitive keywords as you suggest, but I don't believe Rust currently has any. If we were to start using context-sensitive keywords, I'd also like to see in (from for _ in ..) made context-sensitive.

[flaper87]

@brson What is the final decision here?

[glaebhoerl]

@Kimundi what about changing extern mod to be like mod then, and have each extern mod declaration be considered distinct (even if, under the hood, they may not be)?

(But they also maybe may be, if you're using package IDs or attributes or whatever to bring in e.g. different versions of the same library. Of course you could check "are these extern mods actually referring to the same thing" (and perhaps we already do?), but if they're always distinct then you don't have to care.)

[brson]

@flaper87 let's make crate a full keyword. It can be contextualized later if we agree on it.

[flaper87]

@brson roger that!

[thestinger]

I still don't think adding a crate keyword is a good idea. The extern mod statement should work the same way as mod, but include an external module rather than a file. I don't think the crate terminology is going to be accessible to those who aren't familiar with the language. It's a Rust-specific term unlike module or library.

It would be simple enough to change the mod statement to refer to the same module when a file is included in more than one place in the tree.

[liigo]

+1 for extern crate xxx, xxx here is crate not mod.
2014年2月4日 上午7:04于 "Daniel Micay" notifications@github.com写道：

I still don't think adding a crate keyword is a good idea. The extern modstatement should work the same way as
mod, but include an external module rather than a file. I don't think the
crate terminology is going to be accessible to those who aren't familiar
with the language. It's a Rust-specific term unlike module or library.

It would be simple enough to change the mod statement to refer to the
same module when a file is included in more than one place in the tree.

—
Reply to this email directly or view it on GitHubhttps://github.com//issues/9880#issuecomment-34011635
.

[flaper87]

The patch that introduced the crate keyword landed already. The step left is creating a new snapshot for stage0 and replace all usages of extern mod with extern crate