You are way ahead of what I was thinking xD I was thinking of raising the error when a function from that module was used. Raising the error at compile time is pretty cool, and if it’s possible I’m in.
I’m the first to admit that this is very confusing. But adding aliasp, requirep or even importp and usep wouldn’t increase complexity, because anyonw who uses the first four immediately understands how to use private versions. They’re just the same but for a private module.
The original confusion comes from the large number of concepts you need to understand, some of which require the user to be compfortable with macros and (even worse!) the implementation details of the Elixir compiler. For example:
-
to understand use, you need to know what macros are and how to define them. Otherwise, use is complete magic. It doesn’t help that most educational materials tell you to use GenServer, and Bam! you have a genserver. When you understand how macros work, you understand that the use macro is defining a bunch of overrideable functions in your module and implementing the GenServer behaviour. But notice that there are a bunch of concepts you need to understand (macors, overrideable defs, behaviours, etc.)
-
to understand the differences between require and alias, you need to know that the Elixir compiler is a parallel compiler. And that is because it is so slow that it’s worth it to hack the default Erlang error handling mechanisms just to improve compilation speed. So you have a distinction which seems arbitrary until you understand the reasons behind it. If the elixir compiler was blazing fast (which unfortunately, it isn’r for a number of reasons), you could require everything and alias nothing. Ultimately, alias is just a faster require which can’t export macros because they haven’t been compiled yet.
-
To understand import, you must again understand that the Elixir has a prallel compiler and you can’t assume that the compiler for one file knows what exactly has been defined in another file, unless you force an ordering.
I’m totally unaware of Elixir’s early history, and these decisions probably predate the parallel compiler, but these are the ways I personally make sense of the use, require, import and alias. If I were designing the language from scratch, I’d have only import X and import X, qualified: true or something like that. And use, of couse (actually, I’d have never come up with use, which is an amazing feature to save typing). But ultimately, use X is just import X, qualified: true; X.some_magic().
This complexity makes people confused in the beginning, of course, but it’s pretty simple when you think of it as a trick to improve compilation speed.
EDIT: This goes offtopic by a wide margin; the main point is that what whoever understands user, … require, will also understand the p versions without problem, because they are just private versions of the four commands.
People already confuse use, require, import and alias.
