syntax sugar: std.path::buildPath instead of from!"std.path".buildPath

[Timothee Cour via Digitalmars-d]

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 <thelastmammoth at 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 at 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.
>>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.puremagic.com/pipermail/digitalmars-d/attachments/20170213/933017c6/attachment-0001.html>