Najlepsza praktyka implementacji cechy Scala, która obsługuje łańcuchowanie metod.

Question

Chcę stworzyć cechę, która dodaje pewne właściwości do klasy i umożliwia łańcuch metod. Testowane w Scali 2.8.1.

trait SomeProperty { 
    var prop : String = "default" 
    def setProp(s: String) = { 
     prop = s 
     this 
    } 
} 
sealed abstract class Value 
case class IntegerValue(v: Int) extends Value 
case class FloatValue(v: Float) extends Value with SomeProperty { 
    def foo() = { println("I'm foo.") } 
} 
case object UnknownValue extends Value with SomeProperty { 
    def bar() = { println("I'm bar.") } 
} 

scala> val x = UnknownValue 
scala> x.setProp("test").bar() 
<console>:10: error: value bar is not a member of SomeProperty 
    x.setProp("test").bar() 

Jaka jest najczęstsza praktyka w tego rodzaju sytuacjach? (Preferowana metoda zapisu)

Answer 1

Można jawnie określić typ instancji jako typ powrotu dla metody setProp.

trait SomeProperty { 
    var prop : String = "default" 
    def setProp(s: String):this.type = { 
     prop = s 
     this 
    } 
} 

Answer 2

Najprostszą rzeczą do zrobienia jest użycie generycznych.

object Value { 

    trait SomeProperty[X] { 
    var str: String = null; 
    def setStr(s: String): X = { 
     str = s; 
     return this.asInstanceOf[X] 
    } 
    } 

    abstract sealed class Value 
    case class IntegerValue(i: Int) 
    case class StringValue(s: String) extends SomeProperty[StringValue] { 
    def foo(): Unit = { 
     println("Foo.") 
    } 
    } 
    case class UnknownValue(o: Any) extends SomeProperty[UnknownValue] { 
    def bar(): Unit = { 
     println("Bar.") 
    } 
    } 

    def main(args: Array[String]): Unit = { 

    new UnknownValue(18).setStr("blah blah blah").bar 
    new StringValue("A").setStr("halb halb halb").foo 
    } 
} 

Answer 3

Nie wiem, czy to jest to, czego szukasz

scala> trait Property[T] { 
    | me: T => 
    | var prop:String="" 
    | def setProp(s:String) = { 
    |  prop=s 
    |  me 
    | } 
    | } 
defined trait Property 

scala> class A extends Property[A] 
defined class A 

scala> class B extends Property[B] 
defined class B 

scala> val a= new A 
a: A = A@694a18 

scala> val b = new B 
b: B = B@1108691 

scala> a.setProp("Hi") 
res13: Property[A] with A = A@694a18 

scala> a.setProp("Hi").setProp("Bye") 
res14: Property[A] with A = A@694a18 

scala> b.setProp("D") 
res15: Property[B] with B = B@1108691