Práctica recomendada para implementar el rasgo de Scala que admite el método de encadenamiento

Question

Quiero hacer un rasgo que agregue alguna propiedad a una clase y permita encadenar métodos. Probado en Scala 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() 

¿Cuál es la práctica más común en este tipo de situación? (Se prefiere modo seguro)

Answer 1

Puede especificar explícitamente el tipo de instancia como el tipo de retorno para setProp.

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

Answer 2

Lo más fácil de hacer es utilizar un genérico.

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

No estoy seguro si esto es lo que estás buscando

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