Zurückgegebenes Objekt basierend auf dem Eingabetyp

Question

Ich versuche, eine Scala-Funktion zu implementieren, die userFor ähnlich ist, wie in dem folgenden Codefragment gezeigt, wobei der Rückgabetyp der Funktion vom Typ des Eingabeparameters abhängt. In diesem Beispiel meldet der Scala-Compiler "Der Ausdruck vom Typ System1User.type entspricht nicht dem erwarteten Typ SystemUser[S]".

Gibt es eine Möglichkeit, eine Factory-Methode wie userFor zu erstellen, die den Kompilierzeittyp der Eingabe verwendet, um den richtigen Ausgabetyp zurückzugeben?

sealed trait System { 
    def name: String 
} 
case object System1 extends System { def name = "1" } 
case object System2 extends System { def name = "2" } 

sealed trait SystemUser[S <: System] { 
    def use(s: S): String 
} 
object System1User extends SystemUser[System1.type] { 
    override def use(s: System1.type) = s"${s.name} is in use" 
} 
object System2User extends SystemUser[System2.type] { 
    override def use(s: System2.type) = s"${s.name} is in use" 
} 

object SystemUser { 
    //TODO: how to make the types work out here? 
    def userFor[S <: System](sys: S): SystemUser[S] = { 
    sys match { 
     case System1 => System1User 
     case System2 => System2User 
    } 
    } 

} 

Answer 1

Ich entschied, dass in meinem Fall ist es ausreichend war es nur:

object SystemUser { 

    def userFor(sys: System1.type): SystemUser[System1.type] = { 
    sys match { 
     case System1 => System1User 
    } 
    } 

    def userFor(sys: System2.type): SystemUser[System2.type] = { 
    sys match { 
     case System2 => System2User 
    } 
    } 

} 

Answer 2

Problem ist die Tatsache, dass Sie ein SystemUser[S] von userFor, wo S einige Subtyp von System zurückzukehren versprach. Aber Sie können dieses Versprechen nicht halten. Sie geben nicht zurück SystemUser[S]; Sie geben entweder SystemUser[System1.type] oder SystemUser[System2.type] zurück. Was würde passieren, wenn S etwas anderes als einer dieser beiden Typen ist? Was passiert, wenn jemand userFor aufgerufen hat, der mit SomeNewSystemSubtype parametrisiert wurde (sagen wir, dass es ein gültiger Subtyp von System ist)?

können Sie die Abhängigkeit entfernen S zu geben und einfach zurückgeben „einige Subtyp von System“:

def userFor[S <: System](sys: S): SystemUser[_ <: System] = { 

sauberere Lösung wäre SystemUser covariant in seiner Art Parameter zu machen, weil dann SystemUser[System1.type] eine Unterklasse von SystemUser[System] wäre , was bedeutet, würden Sie in der Lage sein, dies zu tun:

sealed trait SystemUser[+S <: System] { 
    def use(s: S): String 
} 
... 
def userFor[S <: System](sys: S): SystemUser[System] = { 

Aber leider Ihre Methode def use(s: S): String einen Parameter vom Typ S, und das ist eine kontravariante Position. Ich bin mir nicht sicher, ob Sie mit diesem Zeug vertraut sind, aber das zu tun ist nicht einfach - Sie müssten Ihre Methode in etwas wie def use[T >: S](s: T): String ändern, was Änderungen in den Implementierungen erfordern würde (da jetzt jeder Typ über S als erscheinen kann ein Parameter) und in Ihrem Fall ist dies wahrscheinlich nicht wert.