RFC: make __xxx__ names officially reserved

[StefanKarpinski]

We've used the name __init__ as a function name with special meaning in modules (function that is automatically called after a module is loaded but before the module is precompiled) and we may introduce __main__ in the future as a function in Main that is automatically called if it exists when a script run as julia script.jl finishes – the purpose being to allow a hypothetical julia-compile script.jl to produce a binary that behaves in the same manner as if you'd run julia script.jl without any changes to script.jl. In general, this points to the notion that we should officially reserve names of the form __xxx__ as having special meaning to the system.

[stevengj]

Seems unnecessary and possibly counter-productive. Did we actually hit any conflicts when we introduced __init__ or __precompile__?

[stevengj]

Grepping for this, I see a number of such identifiers used in packages: __ids__, __rospy__, __sys__, __inits__, __entropyinit__, __sslinit__, __MAXCACHE__, ..., so evidently people find this useful. The use of this kind of name for "internal" identifiers is a commonplace habit from Python (and other languages, including C).

(No one is currently using __main__ as far as I can tell.)

[yuyichao]

Ref #11098 I also think we shouldn't use module level special names as long as it's possible so that it is easy to make use of those features in macros/libraries or moving code between modules.

It might not be too meaningful to allow multiple entry points but I think a interface like @main function my_main() end should work equally well and can also throw errors at compile time (i.e. when the module is evaluated) if the function/method registered doesn't make sense.

[eschnett]

Does it suffice to reserve _jl_ and __jl_? If there are not too many anticipated names, a jl prefix doesn't hurt, and might help readability.

[stevengj]

@eschnett, I'm not sure what purpose _jl_ would serve, because _jl looks like a prefix for Julia internals, which we can just put in Core or Base without exporting them. Any symbol we actually want to use would be something like __init__ or __precompile__ or __main__, and a _jl_ prefix seems confusing in those cases.

[vtjnash]

@Stefan I have largely expected Main.__init__ would take the place of __main__ or __start__ or other such. Is there any other need for these internal names? For most things, we can provide registration functions from Core (or via ccall), so I don't really see us needing to reserve a namespace in every Module for internal use.

[StefanKarpinski]

No, the name Main.__init__ would be fine and fits well with the existing meaning. The broader point of this issue is to have a way of pre-reserving names that have special meaning to Julia. People mistakenly use __xxx__ names in Python as well, but when they do so, they risk having their code break in strange ways in future versions where that name means something special.

[StefanKarpinski]

Seems like we don't need this (unlike Python, Julia doesn't have a global method namespace).