"Functionally equivalent" to, not identical to. I'm talking about the module system. You could literally replace any instance of:

    mod mod_name;

With:

    #include "path/to/mod_name"

and then run it through the C preprocessor and it'd work exactly the same.

The discussion was held on IRC.

This is absolutely not true. Rust has no textual substitution like the C preprocessor does, and includes a module system, which has namespacing.

I put together a small demonstration for you:

https://github.com/SirCmpwn/rust-poc

That is one, very, very tiny aspect of the C preprocessor.

And https://github.com/SirCmpwn/rust-poc/blob/master/includes.rs... is significant: the code included from another file is under a namespace, and isn't going to clash like randomly throwing #includes around will, and you don't need to worry about things like double inclusion...

In other words, I think this is a very superficial comparison, and I'm not even sure why it upsets you so. Rust won't be a perfect language for everyone, and that's okay.

Well, you could move the mod { } to the included file to accomplish the same result (like the `namespace` keyword in C#), but that'd break the example I'm trying to give. I don't really want to rehash this argument on Hacker News, I'm just providing context. There are numerous flaws in the module system that derive from this basic point.

I'm not really a C guy, but isn't #include about using a module in the current scope? Because Rust's mod is for project structure definition.

#include in C is just textual substitution of the contents of the specified file in place of the #include statement, there is not a concept of namespace in C.

I can't really effectively explain how all of this works without providing a lot of background on systems languages in general, especially background on how linking works. Sorry.