More on semantics of opPow: return type

[Lars T. Kyllingstad]

Andrei Alexandrescu wrote:
> Lars T. Kyllingstad wrote:
>> Andrei Alexandrescu wrote:
>>> Nice analysis. IMHO this should lead us to reconsider the necessity 
>>> of "^^" in the first place. It seems to be adding too little real 
>>> value compared to the complexity of defining it.
>>>
>>> Andrei
>>
>>
>> It adds a lot of value to the ones that actually use it, even though 
>> you may not be one of them. Exponentiation is extremely common in 
>> numerics.
> 
> Well I write numerics and I do use exponentiation occasionally, but 
> never to the extent of yearning for ^^. "Extremely common" would be, I 
> think, quite difficult to argue.

Yeah, I get a little carried away. The point I was trying to make is 
that it's not as uncommon as some would have it.

The fundamental reason why I want opPow so badly is in fact not even how 
often I use it. If that was the case, I'd want a special "writefln" 
operator as well. The main reason is that exponentiation is such a basic 
mathematical operation, right up there with addition and multiplication, 
that it deserves an operator of its own.

I also seem to remember someone (was it Don or bearophile, perhaps?) 
listing various optimisation possibilities that are more readily 
available if ^^ is a built-in operator.


>> Here are some statistics for you: A Google code search (see below) for 
>> FORTRAN code using the power operator **, which until recently didn't 
>> have a D equivalent, yields roughly 56100 results.
>>
>> A search for the FORTRAN equivalents of << yield 400 results for ILS() 
>> and 276 results for LSHIFT(). Yet, left shift apparently deserves a 
>> place in D.
>>
>>
>> (I've used http://www.google.com/codesearch, with the following search 
>> strings for **, ILS and LSHIFT, respectively:
>>
>>     [0-9a-zA-Z)]\*\*[0-9a-zA-Z(] lang:fortran
>>     ils\([0-9a-zA-Z] lang:fortran
>>     lshift\([0-9a-zA-Z] lang:fortran
>>
>> As statistics go, this is probably not a prime example, but it is at 
>> least an indication.)
> 
> Thanks for collecting the evidence. To make it more meaningful, you may 
> want to report it to the total number of lines of code searched. I don't 
> know how to do that with codesearch.
> 
> FWIW, this search:
> 
> [0-9a-zA-Z)]\*\*[013456789a-zA-Z(] lang:fortran
> 
> yields 30,300 results, meaning that almost half the uses of 
> exponentiation is to square things.

...which is still a valid use case, since foo*foo evaluates foo twice 
and square(foo) is no better than pow(foo, 2).


> So I'm not sure what this all is supposed to argue for or against. What 
> I can say is that Don's analysis suggested to me, let's leave all that 
> aggravation to overloads of pow() and call it a day. I was much more in 
> favor of ^^ before I saw how quickly it gets complicated. That kind of 
> stuff just doesn't strike me as the kind of things you put straight in 
> the core language.

You could say the same for arrays. T[new] and ~=, anyone? ;)

-Lars