Typ Anpassung in scala

Question

object Test1 extends App { 

    object specificTypes extends Enumeration { 
    type specificTypes = Value 
    val Red = Value 
    val Green = Value 
    val Blue = Value 
    } 

    abstract class outer { 
    type T <: Test1.specificTypes.Value 
    def pr(w: T) 
    } 

    class red extends outer { 
    type T = Test1.specificTypes.Red // Getting Error Here, type Red is not a member of object Test1.specificTypes 
    def pr(w: T) = println("hello red") 
    } 

    val r = new red 
    r.pr(Test1.specificTypes.Red) 

} 

type Rot ist kein Mitglied des Objekts Test1.specificTypes, wie es zu lösen, wo ich werde an

Answer 1

type T = Test1.specificTypes.Red weist den Typ nicht zu. Es versucht den Wert als Typ zuzuweisen, der natürlich nicht kompiliert wird.

Wie wäre es damit?

object Test1 extends App { 


    object specificTypes extends Enumeration { 
    type specificTypes = Value 
    val Red = Value 
    val Green = Value 
    val Blue = Value 
    } 

    abstract class outer { 
    type T <: Test1.specificTypes.Value 
    def pr(w: T) 
    } 

    class red extends outer { 
    type T = Test1.specificTypes.Red.type //IMPORTANT THING! 
    def pr(w: T) = println("hello red") 
    } 
    class blue extends outer { 
    type T = Test1.specificTypes.Blue.type //IMPORTANT THING! 
    def pr(w: T) = println("hello blue") 
    } 

    val r = new red 
    //r.pr(Test1.specificTypes.Blue) // compilation error 
    /* 
    Error:(23, 28) type mismatch; 
    found : Test1.specificTypes.Blue.type (with underlying type Test1.specificTypes.Value) 
    required: Test1.r.T 
     (which expands to) Test1.specificTypes.Red.type 
    r.pr(Test1.specificTypes.Blue) 
    */ 


    val b = new blue 
    b.pr(Test1.specificTypes.Blue) // compiles, prints hello blue 
} 

ABER, für Sie Fall (wie Sie erwähnt)

ich einige Klassen mit Typ haben, möchte ich passend zu den Klassen nach Typ in Muster unterscheiden

Ich würde verwenden eine einfache sealed trait, genau wie in der Antwort des Chobeat.

Answer 2

Ich glaube, es ist besser, den Typ T in einem Begleitobjekt zu speichern, wenn Sie möchten, um eine ähnliche Struktur zu behalten. Andernfalls könnten Sie eine Summe Typ verwenden und wie diese

sealed trait Colour 

trait Red extends Colour 

trait Green extends Colour 

class RedClass extends Red 
class GreenClass extends Green 


def matchMethod(check:Colour) = {   

    check match { 

     case Red => println("hello this is red") 
     case Green => println("hello this is green") 
    } 
} 

Auf diese Weise etwas tun können Sie erschöpfend und sicher, ohne seltsame Art Referenzen entsprechen.