On Tuesday, 14 February 2017 at 03:49:28 UTC, Timothee Cour wrote:
What about allowing syntax sugar as an alternative to relying
on the new `from/Module` inline import idiom:
```
void fun(T)(std.stdio::File input, T value) if
(std.traits::isIntegral!T)
{...}
```
instead of:
```
void fun(T)(Module!"std.stdio".File input, T value) if
(Module!"std.traits".isIntegral!T) {...}
```
Rationale:
* this reads much better (less noise); same as `=>` syntax for
lambdas
* this is expected to be a very common pattern, so might as
well make it as simple as possible
* not particular on which symbol is used, could be something
else, so long it doesn't involve writing a string such as
from!"std.traits". But :: will be familiar to those coming from
C++/rust etc.
* from!"" is too loose and can be abused arbitrarily:
```
// this compiles
void fun(){
from!"std.stdio; pragma(msg,`abuse...`); import
std.stdio".File a;
}
```
Furthermore this is useful in other scenarios, namely when an
import is
used only once in a context:
```
auto fun(){ return std.file::getcwd; }
```
is more DRY; instead of:
```
auto fun(){ static import std.file; return std.file.getcwd; }
auto fun(){ return Module!"std.file".getcwd; }
```
NOTE: if :: is not feasible for whatever reason, let's consider
other symbols without prejudice to this proposal.
Well, as Jack said there's no real clean way to do this without
cluttering the function signatures more. However if this does
happen through a language change, :: would look kind of awkward
imo. I'd go with the following idea instead.
void fun(T)(#std.stdio.File input, T value)
if (#std.traits.isIntegral!T)
{...}
Doesn't necessarily have to be the octothorpe, but I think it
looks a bit cleaner.
