CODEWITHSUNDEEP
scalamethods
Peter
Peter

Reputation: 509

Scala - method precedence

I am new to Scala. I wonder whether it is possible to define some precedence with method calls. For example, if I have the chain of method calls:

someObject method1 param1 method2 param2 method3 param3

can this be equivalent to the following: 

someObject.method1(param1).method2(param2.method3(param3))

or 

someObject method1 param1 method2 (param2 method3 param3)

So I want method3 to take precedence over method2...

The reason I want to do this is that I want to develop a DSL, so I want to avoid using dots and parentheses as much as possible. If you guys find another solution for me, feel free to let me know.

Upvotes: 17

Views: 1856

Answers (2)

huynhjl
huynhjl

Reputation: 41646

You'll have to use methods with special operator characters to influence precedence as implied by Tomasz. This is partly why lots of Scala DSL make heavy use of operators. Also why some DSL are hard to read if you don't work with them daily.

Given method with using only letters, underscore and digits - you won't be able to influence things, here is what I put together for myself after reading the spec:

  • Any method which takes a single parameter can be used as an infix operator: a.m(b) can be written a m b.

  • Any method which does not require a parameter can be used as a postfix operator: a.m can be written a m.

  • Postfix operators have lower precedence than infix operators, so foo bar baz means foo.bar(baz) while foo bar baz bam means (foo.bar(baz)).bam and foo bar baz bam bim means (foo.bar(baz)).bam(bim).

So without knowing at all what your method signatures are, the following code (because it's all alphanumeric):

someObject method1 param1 method2 param2 method3 param3

will be parsed as:

someObject.method1(param1).method2(param2).method3(param3)

If you rename method3 to |*| or +:+ or whatever operator makes sense, you can achieve what you want:

someObject method1 param1  method2 param2 |*| param3
// same as
someObject.method1(param1).method2(param2.|*|(param3))

For example to see the difference:

implicit def pimp(s:String) = new {
    def |*|(t:String) = t + s
    def switch(t:String) = t + s 
}

scala> "someObject" concat "param1" concat "param2" |*| "param3"
res2: java.lang.String = someObjectparam1param3param2

scala> "someObject" concat "param1" concat "param2" switch "param3"
res3: java.lang.String = param3someObjectparam1param2

Upvotes: 12

Tomasz Nurkiewicz
Tomasz Nurkiewicz

Reputation: 340733

This behavior is defined in chapter 6.12.3 Infix Operations of The Scala Language Specification.

In short: methods are invoked from left to right by default with some exceptions. These exceptions were only introduced to support mathematical operators precedence. So when you have two functions named * and +:

a + b * c

This will always be translated to:

a.+(b.*(c))

Here the first name of the function controls the precedence. However for ordinary functions you cannot control the order. Think about it - this would actually cause havoc and terribly unmaintainable code.

See also (not quite duplicate?): Operator precedence in Scala.

Upvotes: 4

Related Questions