Scala: why can't I declare values in a constructor?

Question

I would like to declare some auxiliary values inside a case class constructor, but it seems not to be correct Scala.

In short, the following piece of code is correct:

case class Something(
    text1: String,
    text2: String
) {
    def this(datetime: LocalDateTime) {
        this(
            s"date: ${datetime.toLocalDate.toString()}",
            s"time: ${datetime.toLocalTime.toString()}"
        )
    }
}

and the following is not:

case class Something(
    text1: String,
    text2: String
) {
    def this(datetime: LocalDateTime) {
        val date = datetime.toLocalDate.toString()
        val time = datetime.toLocalTime.toString()
        this(
            s"date: $date",
            s"time: $time"
        )
    }
}

even though the latter would be more legible and easier to maintain. (Imagine using more complex operations than just calling two methods.) Why is that?

Is there another way to write a constructor like that or a way to work around this?

Answer 1

In Scala first call must be to primary constructor. After that you can have as much code as you want. Read this for explanation.

Similar rule applies to Java for this and super. Not exactly same though. Read this.

The reason why this and super must be first is, that one can set fields to various values before that actual this(x, y) is called. This means object is being constructed and different values can be visible to any thread that may have reference to the object while construction is in progress.

Thanks.

Answer 2

Auxiliary constructors have a constraint that it should call a previous auxiliary constructor or primary constructor on the first line of its body. The second code does not follow that rule. Hence the error.

Answer 3

In your second case you are not allowed to define variables inside constructor before this(params) call, as computing inside constructors are discouraged in scala class or case class. One way you can fix it is pass inline constructor params.

  test("test case class custom constructor") {
    case class Something(text1: String,text2: String) {

      def this(datetime: LocalDateTime) {
        this(datetime.toLocalDate.toString(), datetime.toLocalTime.toString())
        //you can do whatever you want after this(x, y) is invoked
        val testVal = "apple"
        println(testVal)
      }
    }

    new Something(LocalDateTime.now()).text1 shouldBe "2017-07-16"
    new Something(LocalDateTime.now()).text2 should not be empty
  }

Another way (Encouraged way) is define case class and then define apply inside a companion object as below (for older version maybe 2.11.8, companion object had to be defined first and only case class which seems to be fixed now - https://issues.scala-lang.org/browse/SI-3772)

  test("test class with companion apply method") {

    case class Something(val text1: String, val text2: String) {}

    object Something {

      def apply(datetime: LocalDateTime): Something = {

        val x = datetime.toLocalDate.toString()
        val y = datetime.toLocalTime.toString()

        new Something(x, y)
      }
    }

    Something(LocalDateTime.now()).text1 shouldBe "2017-07-16"
    Something(LocalDateTime.now()).text2 should not be empty

  }

scastie code - https://scastie.scala-lang.org/prayagupd/yn2bJWHkQ6Gbli5Ll6I6CQ/1