Best practice to implement Scala trait which supports method chaining

Question

I want to make a trait which add some property to a class and make it possible to chain methods. Tested in 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()

What is the most common practice in this kind of situation? (Type-safe way is preferred)

score 20 · Accepted Answer · answered Jan 28 '11 at 09:02

20

You can explicitly specify the instance type as the return type for setProp.

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

answered Jan 28 '11 at 09:02

Monkey

620
5
4

It works! But I don't understand why. I guess `this.type` is equal to `SomeProperty`, isn't it? Is this Scala specific? Or also possible in Java? – ihji Jan 28 '11 at 09:24
This article is helpful. http://scalada.blogspot.com/2008/02/thistype-for-chaining-method-calls.html – ihji Jan 28 '11 at 09:51
No that won't work from java -- you'd have to take generic's approach in java. – lscoughlin Jan 30 '11 at 10:49

score 1 · Answer 2 · answered Jan 28 '11 at 12:55

Not sure if this is what you're looking for

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

score 0 · Answer 3 · answered Jan 28 '11 at 09:04

Easiest thing to do is use a generic.

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
  }
}

Best practice to implement Scala trait which supports method chaining

3 Answers3

Linked