Imported From: https://issues.scala-lang.org/browse/SI-2272?orig=1
Reporter: @dlwh

@adriaanm said:
I think this is an inherent limitation of Scala's type inference algorithm. I don't know the details, but the rule of thumb is that you should avoid constraints that have type variables (type parameters that must be inferred) on both sides (such as Fx <: F[I]).

It works if you define stringer as:

implicit def stringer[I](a: F[I]) = a.get.toString

@dlwh said:
If it's impossible, it's impossible. (And can be closed as such!) If it were possible, I'd sure like it.

You're right that the example would work with that solution, but this is just a simplified test case. In reality, I have a type F[I] that has many subtypes, and I really want to define an implicit def foo[I,Fx<:F[I]](t: Fx): Wrapper[I,Fx] . For most things I can do foo[Fx<:F[_]], but that solution runs into a few other limitations that I'm trying to simplify into something I can turn into a bug report.

@odersky said:
It's impossible given the current type inference scheme.

@adriaanm said:
You can however work around it using implicits (once the fix for #2261 is in trunk -- you can get it now from my github: http://github.com/adriaanm/scala/commits/ticket/2261). Using the compiler in my working copy:

dhcp-10-9-32-075:tmp adriaan$$ /Users/adriaan/git/scala-mirror/build/quick/bin/scala
Welcome to Scala version 2.8.0.r0-b20090826112135 (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_13).
Type in expressions to have them evaluated.
Type :help for more information.

scala> trait F[I]
defined trait F

scala> class FInt extends F[Int]
defined class FInt

scala> class FString extends F[String]
defined class FString

scala> class Wrapper[I, Fx](implicit val w: Fx <:< F[I])
defined class Wrapper

scala>   implicit def foo[Fx, I](t: Fx)(implicit w: Fx <:< F[I]): Wrapper[I,Fx] = null.asInstanceOf[Wrapper[I,Fx]]
foo: [Fx,I](t: Fx)(implicit w: <:<[Fx,F[I]])Wrapper[I,Fx]

scala> foo(new FInt)                                                                                              
res1: Wrapper[Int,FInt] = null

Note the inferred return type for res1!

<:< is nothing special, BTW:

  sealed abstract class <:<[-From, +To] extends (From => To)
  implicit def conforms[A]: A <:< A = new (A <:< A) {def apply(x: A) = x}

@dlwh said:
Thanks Adriaan; that's very clever!

(And thanks for considering the change, Scala folks!)

• David