2
votes

I have a follow-on question to the problem that the presence of overloaded method definitions with and without parameters leads to a compilation error, which is already discussed here: Why is this reference ambiguous?

To recap:

 trait A { 
    def foo( s: String ) : String
    def foo : String = foo( "foo" )
 }
 object B extends A {
    def foo( s: String ) : String = s
 } 
 B.foo     // won't compile

results in the error message:

 error: ambiguous reference to overloaded function
 both method foo in object B of type(s: String)String
 and method foo in trait A of type => String
 match expected type Unit
 B.foo

A solution that works is to provide the compiler with the expected type, like so:

 val s: String = B.foo

Unfortunately, one may not always want to introduce an extra variable (e.g. within an assertion). One of the solutions recommended at least twice in the answers to the earlier article referenced above was to invoke the method with empty parentheses, like so:

 B.foo()

Unfortunately, this leads to a similar compiler error (Scala 2.9.0.1):

 (s: String)String <and>
 => String
 cannot be applied to ()
 B.foo()

Is this a bug, or was the recommended solution in error? And ultimately: what options are there to do this concisely, as in:

 assert( B.foo == "whatever" )

instead of

 val expected : String = B.foo
 assert( expected == "whatever" )

Thanks.

2
B doesn't compile, because you forgot to provide the implementation for the def foo: String in trait A.agilesteel
@agilesteel right, the implementation of paramless foo on A got lost in the transfer. Fixed that now. Error remains the same.Gregor Scheidt

2 Answers

6
votes
assert( (B.foo: String) == "whatever" )
2
votes

You can add empty parenthesis to second foo definition:

trait A { 
  def foo( s: String ) : String
  def foo() : String
}

Then you can remove the disambiguation as explained elsewhere:

assert( B.foo() == "whatever" )