Can a method argument serve as an implicit parameter to an implicit conversion?

The following code in a REPL session:

case class Foo(x : Int)

case class Bar(x : Int)

case class Converter(y : Int) {
    def convert(x : Int) = x + y
}

implicit def fooFromBar(b : Bar)(implicit c : Converter) = Foo(c convert (b x))

def roundaboutFoo(x : Int, converter : Converter) : Foo = Bar(x)

Gives me this error:

error: could not find implicit value for parameter c: Converter def roundaboutFoo(x : Int, converter : Converter) : Foo = Bar(x)

In case it's not obvious (implicits), what I'm trying to do is have Bar(x) implicitly converted to a Foo. The implicit conversion itself though is parameterised by an implicit Converter. The times when I want to use this conversion all have an instance of Converter available as a parameter to the method.

I half-expected this to die by not being able to find an implicit conversion from Bar to Foo, due to fooFromBar not being a s开发者_高级运维imple function from Foo to Bar, but I read in this question that implicit conversions can have implicit parameters, and indeed the compiler seems to have figured that part out.

I found another question with a detailed answer specifically about where Scala looks for things to fill in implicits. But it only confirms my earlier understanding: that Scala looks first in the immediate scope, and then a bunch of other places that aren't relevant here.

I wondered if what was going on was that Scala doesn't look at local method arguments when examining the local scope for values to pass as implicit parameters. But adding something like val c = converter to roundaboutFoo doesn't change the error message I get.

Can this be made to work? If not, can anyone help me understand what to look for to recognise that code like this isn't going to work?

converter needs to either be an implicit parameter itself:

def roundaboutFoo(x: Int)(implicit converter: Converter): Foo = Bar(x)

or assigned to an implicit val:

def roundaboutFoo(x: Int, converter: Converter): Foo = {
  implicit val conv = converter
  Bar(x)
}

Regular parameters are not implicit, and thus aren't searched when trying to fill in an implicit argument.