Scala Typ Löschung Problem mit pfadabhängig/geschachtelte Typen

Question

ist folgendes Nehmen wir an:

class Wrapper1 { 
    case class Condition(test: String) 
} 
object Wrapper1 extends Wrapper1 

class Wrapper2 { 
    case class Condition[A](test: String) 
} 
object Wrapper2 extends Wrapper2 


class Test 
    type T = // whatever 

    def test(fn: T => Wrapper1.Condition): X 
    def test[R](fn: T => Wrapper2.Condition[R]): X 
} 

Das Problem ist, dass wegen der Typ Löschung diese Methoden genau die gleiche Art nach dem Löschen haben. Es ist einfach, die Unterschrift des zweiten mit sagen zu ändern:

def test[R](fn: T => Wrapper2.Condition[R])(implicit ev: R =:= R): X 

Aber das verwirrt den Compiler und die test Methode an anderen Orten verwendet, ist nicht möglich. Aus verschiedenen Gründen versuche ich, den Namen dieser Methode konsistent zu halten. Gibt es eine Möglichkeit, dies erfolgreich zu tun?

Answer 1

endlich in der Lage, es zu trainieren. Was ich suchte, war eine Möglichkeit, an eine HList bedingt anzuhängen. Grundsätzlich mussten mehrere Überladungen derselben Methode koexistieren, da sie eine andere Art von HList zurückgeben würden.

Um nur eine Methode zu haben, mussten Argumente vorgeben, wie die endgültige Signatur der Methode aussah.

Also lassen Sie uns die folgende übernehmen, die test Methode hatte

def test[RR](arg: Type1[RR]): Wrapper[RR :: ExistingHList] 

zurückzukehren bzw.:

def test(arg: Type2): Wrapper[ExistingList] 

Das gleiche Verfahren würde zu einem Hlist abhängig davon, ob oder nicht das Argument anhängen haben bestimmte Bedingungen erfüllt. Das Update war so trivial wie die Verwendung , die standardmäßig das vorhandene HList zurückgibt, wenn wir versuchen, HNil an eine Liste anzufügen.

Machen Sie das Argument von Type2 geben Sie eine HNil zurück oder implizit in etwas konvertieren, das am Ende HNil wäre der Ansatz, der funktioniert.

Im Einzelnen:

class Wrapper[PS <: HList] { 
    def test[ 
     RR, 
     HL <: HList, 
     Out <: HList 
    ](
     condition: T => Wrapper[HL] 
    )(implicit prepend: Prepend.Aux[HL, PS, Out]): Wrapper[Out[ 
    } 

Dieser Ansatz funktioniert, wenn die Bedingung Funktion eine Wrapper[HNil] für Situationen zurückkehren, wo die Funktion muss nicht das Ende Rückgabetyp ändern. Funktionen, die ändern, sind einfach frei, um ihre eigenen HList unabhängig aufzubauen.

Answer 2

scheint diese Scala double definition (2 methods have the same type erasure)

Mein Vorschlag kein Duplikat ist ... haben nur eine einzige Methode

def test[Cond: TypeTag](fn: T => Cond): X = { 
    if(typeOf[T] <:< typeOf[Wrapper1.Condition]) ... 
    else if(typeOf[T] <:< typeOf[Wrapper2.Condition[_]) ... 
    else ... 
}