Here, "parameterized" should really be "parameterized by type." In other cases, the warning indicates that since you have defined an implicit conversion that is both overloaded (there are other methods with the same name) and generic , then the method cannot actually be used as an implicit representation, although it can be used to implicitly convert a simple value. I will try to illustrate the difference with an example:
class MyClass object MyClass { implicit def finish: MyClass = null implicit def finish[R](result: R): MyClass = null } val a: Int = 123 val b: MyClass = a // Compiles fine: implicit conversion properly applied def foo[R<%MyClass]( r: R ) {} foo( 123 ) // Error: No implicit view available from Int => Test.MyClass
In the above code snippet, a (of type Int ) is implicitly converted to MyClass , so the implicit conversion works as expected.
However, the interesting part is with the foo method. It is declared with reference to MyClass . In other words, you should be able to pass foo any value that is implicitly converted to MyClass . But here it does not compile. This is the error the compiler warned about. And of course, if you comment out the first finish overload (one that does not accept a type parameter), or rename the version so that they are not overloads (let's say you renamed one of them to finish2 ), then the compilation error disappears.
If you are interested in what is between the first case (direct implicit conversion) and the difference between the second (calling a method with a binding to a view), which may differ from the first, it can compile, but not another, the key point is that related representation, it is required to transfer value of implicit function.
Really,
def foo[R<%MyClass]( r: R )
coincides with
def foo[R]( r: R )( implicit conv: R => MyClass)
Therefore, when calling foo compiler must not only find the corresponding implicit conversion, but also advance the implicit conversion method (second overload finish ) into the function instance and pass it implicitly to foo .
I believe this is a promotion that the compiler (for some reason) does not know how to do in the case of parameterized and overloaded type methods. This is pure speculation, but I’m sure it’s just a limitation of the implementation: it would be very useful, but it would lead to enough problems with the implementation so that it is not considered important enough (after all, you can fix it just by renaming the implicit conversion method) .
As a side note, the warning is not issued (by default) in scala 2.10 (it was too noisy with the growth of the type of using the class in scala), but the real problem remains, and the call to foo still does not compile.