Re: Implicit priority, Tuples and overloaded methods

My mistake, the code at the bottom should have been:

agent.call {
(msg, new Exception, "one")
}

with the error message:

Main.scala:65: error: ambiguous reference to overloaded definition,
both method apply in class Call of type (body: => (String, Throwable,
Array[Any]))(implicit m: Main.Call.Dummy3)Unit
and method apply in class Call of type (body: => (String,
Array[Any]))(implicit m: Main.Call.Dummy1)Unit
match argument types ((java.lang.String, java.lang.Exception,
java.lang.String))
agent.call {
^
one error found

So, still having an implicit priority problem.

On 10/14/2011 05:13 PM, mark dufresne wrote:
> Should
>
> agent.call(msg, new Exception, "one")
>
> be
>
> agent.call( (msg, new Exception, "one") )
>
> ?
>
> On Fri, Oct 14, 2011 at 4:27 PM, richard emberson
> > wrote:
>
>
> Basically, I'd like the method with the tuple:
> Tuple3[String, Throwable, Array[Any]]
> to be called from the code:
> agent.call(msg, new Exception, "one")
> but, rather, I get the following compiler error message:
>
> Main.scala:68: error: ambiguous reference to overloaded definition,
> both method apply in class Call of type (body: => (String,
> Throwable, Array[Any]))(implicit m: Main.Call.Dummy3)Unit
> and method apply in class Call of type (body: => (String,
> Array[Any]))(implicit m: Main.Call.Dummy1)Unit
> match argument types
> (java.lang.String,java.lang.__Exception,java.lang.String)
> agent.call(msg, new Exception, "one")
> one error found
>
> Here is the code:
>
>
> object Main {
> trait LowPriority {
> implicit def t1(t: Tuple2[String, Any]): Tuple2[String,
> Array[Any]] = {
> (t._1, Array(t._2))
> }
> implicit def t2(t: Tuple3[String, Any, Any]): Tuple2[String,
> Array[Any]] = {
> (t._1, Array(t._2, t._3))
> }
> }
> object Call extends LowPriority {
> implicit def t2t(t: Tuple3[String, Throwable, Any]):
> Tuple3[String, Throwable, Array[Any]] = {
> (t._1, t._2, Array(t._3))
> }
>
> class Dummy1
> object Dummy1 {
> implicit def dummyImplicit: Dummy1 = {
> println("Dummy1.dummyImplicit"__)
> new Dummy1
> }
> }
> class Dummy2
> object Dummy2 {
> implicit def dummyImplicit: Dummy2 = {
> println("Dummy2.dummyImplicit"__)
> new Dummy2
> }
> }
> class Dummy3
> object Dummy3 {
> implicit def dummyImplicit: Dummy3 = {
> println("Dummy3.dummyImplicit"__)
> new Dummy3
> }
> }
> }
> import Call._
>
> class Call {
>
> def apply(body: => Tuple2[String, Array[Any]])
> (implicit m: Dummy1): Unit = {
> println("message and array of parameters")
> }
> def apply(body: => Tuple2[String, Throwable])
> (implicit m: Dummy2): Unit = {
> println("message and throwable")
> }
> def apply(body: => Tuple3[String, Throwable, Array[Any]])
> (implicit m: Dummy3): Unit = {
> println("message, throwable and array of parameters")
> }
> }
>
> class Agent {
> val _call = new Call
>
> def call: Call = _call
> }
>
> def main(args: Array[String]): Unit = {
> val msg = "XXX"
> val agent = new Agent
> agent.call(msg, new Exception, "one")
> }
> }
>
> I tried to give the tuple conversion implicits priorities
> but it does not seem to matter.
>
> Thanks for any help.
>
> Richard
> ---
> Quis custodiet ipsos custodes
>
>
>
>
> --
> "...I have suffered the loss of all things, and count them as rubbish,
> that I may gain Christ" -Phil 3:8