exponential operator

On Thu, Dec 22, 2011 at 08:10:50PM +0100, Antoras wrote:
> I asked myself why Scala hasn't an exponential operator like '^' or
> '**' as many other languages have.
>
> I noticed that Scalas precedence rules will not work very well with
> such operators because '^' has low precedence and '**' has the same
> precedence than '*' and '/'.
>
> Therefore I want to know if would be a good design decision to
> introduce such an operator to the language (either to the libs as an
> implicit conversion or as a built-in operator).
>
> What yo you think? Do you appreciate such an operator or do you
> think that there will be more problems than advantages?

The following ASCII characters have higher precedence than *:

# (# is unavailable, ## is used for hashing)
@ (@ is unavailable)
? (unused afaik)
\ (\ is used with xml and maybe other places?)
~ (unused afaik)

Any of these can be used to build an exponentiation operator with the
right precedence. You can test this in the REPL:

implicit def xyz(d:Double) = new { def ~**(e:Double) = math.pow(d, e) }
2.0 * 3.0 ~** 4.0 * 5.0

This will return 810.0 like you'd expect (incorrect operator precedence
might result in 6480.0, 6.973568802E9 or 3.656158440062976E15).

I really miss this operator from other language and wish Scala included
it. Besides the fact that I resent having to type math.pow, I
especially hate using it with Int (the most common case in my opinion)
as I have to convert back to Int from Double. Compare:

math.pow(3, 5).toInt // scala

with

3 ** 5 # python

Python is just plain better than us here. The Scala example contains so
much noise, I have a hard time visually parsing out what is actually
happening. At a minimum I'd like to see math.pow provide interfaces for
Int and Long. Ideally we'd see the introduction of an exponentiation
operator.

While it's not mentioned specifically in the proposal Tom Switzer and I
are working on, I really feel that Scala could be improved by going
beyond the "Java bare minimum" of numeric operators and types. There's
no reason we can't do as well as Python (especially since our primitive
types have better performance).

I brought this topic up two or three years ago. You are correct about the precedence issues, and I don't think there is a simple solution. After thinking about it, I realized that a general exponentiation operator is not very important. In practice, the exponent is nearly always two (squaring) or, less often, three (cubing), so you can just write these trivial functions:
    def sqr(x: Int) = x * x    def cube(x: Int) = x * x * x
    def sqr(x: Double) = x * x    def cube(x: Double) = x * x * x
In the rare case when you need an exponent other than two or three, just use the "pow" function.
I think the "sqr" and "cube" functions should be added to the standard math package for convenience.
--Russ P.

On Thu, Dec 22, 2011 at 11:10 AM, Antoras <mail [at] antoras [dot] de> wrote:

I asked myself why Scala hasn't an exponential operator like '^' or '**' as many other languages have.

I noticed that Scalas precedence rules will not work very well with such operators because '^' has low precedence and '**' has the same precedence than '*' and '/'.

Therefore I want to know if would be a good design decision to introduce such an operator to the language (either to the libs as an implicit conversion or as a built-in operator).

What yo you think? Do you appreciate such an operator or do you think that there will be more problems than advantages?

--
http://RussP.us