How can implicits with multiple inputs be used in Scala?

Question

For example, how can I write an expression where the following is implicitly applied:

implicit def intsToString(x: Int, y: Int) = "test"

val s: String = ... //?

Thanks

Answer 1

Implicit functions of one argument are used to automatically convert values to an expected type. These are known as Implicit Views. With two arguments, it doesn't work or make sense.

You could apply an implicit view to a TupleN:

implicit def intsToString( xy: (Int, Int)) = "test"
val s: String = (1, 2)

You can also mark the final parameter list of any function as implicit.

def intsToString(implicit x: Int, y: Int) = "test"
implicit val i = 0
val s: String = intsToString

Or, combining these two usages of implicit:

implicit def intsToString(implicit x: Int, y: Int) = "test"
implicit val i = 0
val s: String = implicitly[String]

However it's not really useful in this case.

UPDATE

To elaborate on Martin's comment, this is possible.

implicit def foo(a: Int, b: Int) = 0
// ETA expansion results in:
// implicit val fooFunction: (Int, Int) => Int = (a, b) => foo(a, b)

implicitly[(Int, Int) => Int]

Answer 2

Jason's answer misses out one very important case: an implicit function with multiple arguments where all but the first are implicit ... this requires two parameter lists, but that doesn't seem to be out of scope given the way the question was expressed.

Here's an example of an implicit conversion which takes two arguments,

case class Foo(s : String)
case class Bar(i : Int)

implicit val defaultBar = Bar(23)

implicit def fooIsInt(f : Foo)(implicit b : Bar) = f.s.length+b.i

Sample REPL session,

scala> case class Foo(s : String)
defined class Foo

scala> case class Bar(i : Int)
defined class Bar

scala> implicit val defaultBar = Bar(23)
defaultBar: Bar = Bar(23)

scala> implicit def fooIsInt(f : Foo)(implicit b : Bar) = f.s.length+b.i
fooIsInt: (f: Foo)(implicit b: Bar)Int

scala> val i : Int = Foo("wibble")
i: Int = 29