Implizite Konvertierungen funktionieren nicht mit Typparametern

Question

Ich habe ein Problem mit impliziten Konvertierungen, die unter bestimmten Umständen nicht funktionieren (höherwertige Typen). Bei einem System, einen Ausdruck Typ und zwei spezifische Expressionsuntertypen:

trait Sys[S <: Sys[S]] 

object Expr { 
    trait Var [S <: Sys[S], A] extends Expr[S, A] 
    trait Const[S <: Sys[S], A] extends Expr[S, A] 
} 
trait Expr[S <: Sys[S], A] 

Und einen Zuhälter Klasse für die Expression Operationen:

class RichDoubleExpr[S <: Sys[S]](ex: Expr[S, Double]) { 
    def gugu(): String = "yes" 
} 

Dann gibt implizite Konvertierungen von Primitiven Ausdrücke sein lassen, und aus Ausdrücke zum Ausdruck ops:

implicit def const[S <: Sys[S]](d: Double): Expr[S, Double] = 
    new Expr.Const[S, Double] {} 

implicit def exprOps[S <: Sys[S], A <% Expr[S, Double]](v: A): RichDoubleExpr[S] = 
    new RichDoubleExpr(v) 

folgenden Werken (also impliziten Verfahren const):

3.4.gugu() 

Die folgende nicht Arbeit (und damit implizit Verfahren exprOps):

def test[S <: Sys[S]]: String = { 
    val v = new Expr.Var[S, Double] {} 
    v.gugu() 
} 

mit dem folgenden Fehler:

error: No implicit view available from java.lang.Object with 
    Expr.Var[S,Double] => Expr[S,Double]. 
      v.gugu() 
     ^

Da nun Expr.Var erstreckt Expr und die Typparameter sind identisch, diese Fehlermeldung macht für mich eindeutig keinen Sinn. Irgendwelche Ideen, wie das zu beheben ist?

Answer 1

Eine tragfähige Lösung in meinem Fall ist es etwas 'fix' Typ Parameter S:

class ExprImplicits[S <: Sys[S]] { 
    implicit def const(d: Double): Expr[S, Double] = new Expr.Const[S, Double] {} 

    implicit def exprOps[A <% Expr[S, Double]](v: A): RichDoubleExpr[S] = 
    new RichDoubleExpr(v) 
} 

Jetzt kann ich die implicits für ein bestimmtes System importieren:

def test[S <: Sys[S]]: String = { 
    val imp = new ExprImplicits[S] 
    import imp._ 

    3.4.gugu() // ok 
    val v = new Expr.Var[S, Double] {} 
    v.gugu() // ok 
}