<div class="gmail_quote">On Thu, Jun 9, 2011 at 12:46 AM, Jonathan M Davis <span dir="ltr"><<a href="mailto:jmdavisProg@gmx.com">jmdavisProg@gmx.com</a>></span> wrote:<br><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex;">

<div><div></div><div class="h5">On 2011-06-09 00:20, Andrew Wiley wrote:<br>
> On Wed, Jun 8, 2011 at 12:41 PM, Alex_Dovhal <<a href="mailto:alex_dovhal@yahoo.com">alex_dovhal@yahoo.com</a>> wrote:<br>
> > There have been several topics discussing UFCS recently. So here is one<br>
> > more)<br>
> > One idea about UFCS - mark UFCS argument with @, @_, or _ symbol,<br>
> > e.g. you have some function:<br>
> > void func(Type1 p1, Type2 p2);<br>
> ><br>
> > and later call it:<br>
> > fucn(a, b);  //or<br>
> > a.func(@_, b);  //or<br>
> > b.func(a, @_);<br>
> ><br>
> > This way Timon Gehr's example:<br>
> >    take(10,stride(2,cycle([3,2,5,3])));<br>
> >    [3,2,5,3].cycle().stride(2).take(10);<br>
> ><br>
> > would be written as this:<br>
> >    [3,2,5,3].cycle(@_).stride(2, @_).take(10, @_);<br>
> ><br>
> > Which is a little longer. On the other side this way benefits from:<br>
> >  * UFCS is directly seen by both the programmer and compiler;<br>
> >  * UFCS doesn't mix with member call syntax;<br>
> >  * UFCS can be used for any type and for any argument, e.g.<br>
> ><br>
> >    a.func(@, b) or b.func(a, @);<br>
> ><br>
> >  * UFCS can be used for more than one argument: a.func(@_, @_~[1]);<br>
> ><br>
> > What do you think?<br>
><br>
> I find it funny that @ was initially adopted for annotations, to be used<br>
> similar to Java and Scala. I come from that world, and one of the rules for<br>
> annotations is that they cannot directly alter the code the compiler<br>
> outputs. You can add plugins to the Java compiler that use annotations to<br>
> modify the AST before it's compiled, and you can use annotations for<br>
> runtime bytecode generation or interpret them using reflection, but if you<br>
> take unannotated code and annotated code and compile it (without altering<br>
> the compiler), the generated code will not change.<br>
> The idea was to make them a part of the language composed entirely of<br>
> metadata (some of which was enforced to be correct by the compiler) that<br>
> could be completely ignored if the programmer didn't want to use it.<br>
> Now that D has taken up this syntax, we've done almost the opposite. @ is<br>
> mostly used in situations where it changes the compiled code, changes the<br>
> existing language,  and is in no way optional. We don't really support user<br>
> defined metadata, and we can't use what annotations we have as metadata<br>
> because only the compiler can actually use it. Most of the uses I've seen<br>
> seem to be a way to cram more keywords into the language without adding<br>
> more keywords.<br>
> I've been holding in this sort of rant for a while, but in summary, my<br>
> response is that unless the desired use for @ was defined radically<br>
> differently by D when it was adopted (and, as far as I can tell, it<br>
> wasn't), seeing another abuse of it just makes me feel slightly sick<br>
> inside.<br>
<br>
</div></div>As it is, user-defined attributes can be added later using the @ syntax. True,<br>
all of the current uses of @ are for where we decided to save a keyword, but<br>
that doesn't stop user-defined attributes from using the syntax later. It just<br>
means that those that are currently defined will always be special.<br></blockquote><div><br></div><div>This is the difference in philosophy at the core of my general unhappiness. When Java officially added annotations, they were designed and built to be used for user-defined metadata. We added "Property" to the grammar, celebrated that we had them too, then stopped. The result is that we're throwing around @ as an excuse for language keywords and boasting about how we have annotations when, by the definition of any other language, we simply don't.</div>

<div>I guess the best answer from where I'm standing is to start throwing around possible syntaxes for annotation declarations and references to them in compile-time reflection. I just really hope this gets in to D2, so we aren't permanently stuck with "fake annotations."</div>

<div><br></div><div><br></div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex;">
Regardless, I see little point in using it for UFCS. If we want to<br>
specifically mark parameters for it, I think that the suggestion of using<br>
"this" makes a lot more sense. You wouldn't even have to change the grammar<br>
(unlike if you used @). You'd just change the semantic phase to treat "this"<br>
specially as a function parameter and not freak out about it being a keyword.<br>
Using @ would be a much bigger language change and for no gain whatsoever as<br>
far as I can see.<br>
<font color="#888888"><br></font></blockquote><div><br></div><div>I agree. The "this" syntax seems far more logical and straightforward.</div></div><br>