as for language change, I believe the proposed syntax (`::`) can be reduced to a minimum if we we make `fullyqualifiedName` `::` a reduction to the from/Module inline import idiom. No complex corner case or new bug introduced, it could be done as a pure AST transformation
On Mon, Feb 13, 2017 at 9:32 PM, Timothee Cour <thelastmamm...@gmail.com> wrote: > > The only thing from has going for it is that it doesn't require a > language change. Yours does, so it should be compared to the proposals in > DIP1005 and not just from. > > indeed. But just because something can be done in library code doesn't > mean it should. Same exact rationale for: > `lazy`, `=>`, scope(exit), etc. All of these coul've been done in pure > library code, but the syntax sugar makes them particularly easy to use. > Syntax sugar should be used sparingly, but it makes sense if > > * it simplifies syntax compared to best possible library code > * it's for a common use case > > > > On Mon, Feb 13, 2017 at 9:03 PM, Jack Stouffer via Digitalmars-d < > digitalmars-d@puremagic.com> wrote: > >> 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. >>> >> >> The only thing from has going for it is that it doesn't require a >> language change. Yours does, so it should be compared to the proposals in >> DIP1005 and not just from. >> >> TBQH all the the proposed syntaxes for the DIP1005 problem kind of suck, >> because at the end of the day there's no good way to solve the problem. >> >> Every proposed solution either >> >> 1. Looks terrible (and some people highly underestimate the cost of a >> language looking bad), or >> 2. Complicate our already complex function definitions even further. How >> is a beginner not going to look at this and feel like barfing >> >> with (import std.datetime, std.range.primitives) void fun(R)(scope R r, >> const ref Systime value) if (isInputRange!R && !isFinite!R) { ... } >> >> But, I'm still of the opinion that the `with` syntax is currently the >> best proposal. Others have already shown the weaknesses of the `from!` >> approach. >> > >