using keyword

[jmafc]

It appears that the using keyword is only allowed at function or block scope, but not at file or global scope. For example, you can declare using std::println; after the opening brace of a function and then use println() multiple times within that function. However, if you have a file with several functions each possibly manipulating string instances, you cannot (in pure-cpp2) declare using std::string; at file scope. If you do, you get an error pure-cpp2 switch disables Cpp1 syntax, which is not exactly the case, if you can use it within a function.
Was there any particular rationale for disallowing using at file scope?

[pratikrath126]

Hey @jmafc, that's an interesting observation! Cpp2's design often prioritizes locality and avoiding global namespace pollution, so restricting to block scope might be a deliberate choice to encourage more explicit declarations or to simplify the parsing of file-level dependencies. It definitely keeps the global scope cleaner, though I can see how it adds a bit of boilerplate for common types like . Curious to hear @hsutter's take on whether this is a permanent constraint or just a current implementation limit!

[jmafc]

BTW, another small detail that I discovered that doesn't appear to be documented: you cannot declare multiple items in a using statement, e.g., using std::print, std::println; will cause error: expected ; at end of using-statement (at ',').

[hsutter]

Right, similarly ordinary declarations are one at a time (e.g., there's no equivalent to int a = 1, b = 2; in Cpp2, you would write a: int = 1; b: int = 2;.

[jmafc]

Yes, @hsutter I was actually going to point out earlier with an almost identical example to yours, that it makes sense to have single variable declarations because it's easier to forget initializations or to add a second variable that perhaps should be of a different type, plus the parsing becomes harder or not as clean when you have deal with a list of possibly initialized items. But in the case of using there doesn't seem to be an equivalent rationale.

[hsutter]

I just haven't had a use case for implementing it yet.

Note that Cpp2 aims to be order-independent, so writing it at non-local scope would be the same as writing it at the top of the file, and so supporting it would have to consider its possible effect on included header files.

[jmafc]

its possible effect on included header files.

I'm not sure I follow. Two somewhat related questions:

1. Is pure Cpp2 ultimately going to support the preprocessor, in particular #include or, only allow import <module> statements?
2. If Cpp2 will continue to allow #include for compatibility with and migration from Cpp1, it seems it cannot be completely order-independent. That is, although cppfront may allow using foo::_ anywhere in the file, it is not unreasonable to expect the using after an #include "foo.h",