Cannot override val with lazy val??

7 replies

Thu, 2011-04-07, 22:24

Adam Tistler

Joined: 2009-05-18,

I was a little surprised that scala does not allow you to override a val with a lazy val. I guess that this kind of makes sense since a lazy val is really a function definition that only get evaluated once so
technically it is not immutable?? However you also are not allowed to override a lazy val with a def....hmm

I was also surprised that you cannot override a var with a var. I can't think of a use case where this would cause problems.....hmm.

I decided to test all cases as shown below. Could anyone shed some light on the "why" behind preventing certain override cases.

Base class Overridden by Compiled?
------------------------------------------------------------------------------

lazy val
lazy val yes
val no
var no
def no
val
lazy val no
val yes
var no
def no
var
lazy val no
val no
var no
def no

def
lazy val yes
val yes
var no
def yes
------------------------------------------------------------------------------

Test code:

trait WithLazyVal {
lazy val x = "adam"
}
trait WithVal {
val x = "adam"
}
trait WithDef {
def x = "adam"
}
trait WithVar {
var x = "adam"
}

class Test1 extends WithLazyVal {
override var x = "mike"
}
class Test2 extends WithLazyVal {
override val x = "mike"
}
class Test3 extends WithLazyVal {
override def x = "mike"
}
class Test4 extends WithLazyVal {
override lazy val x = "mike"
}
class Test5 extends WithVal {
override var x = "mike"
}
class Test6 extends WithVal {
override val x = "mike"
}
class Test7 extends WithVal {
override def x = "mike"
}
class Test8 extends WithVal {
override lazy val x = "mike"
}
class Test9 extends WithVar {
override var x = "mike"
}
class Test10 extends WithVar {
override val x = "mike"
}
class Test11 extends WithVar {
override def x = "mike"
}
class Test12 extends WithVar {
override lazy val x = "mike"
}
class Test13 extends WithDef {
override var x = "mike"
}
class Test14 extends WithDef {
override val x = "mike"
}
class Test15 extends WithDef {
override def x = "mike"
}
class Test16 extends WithDef {
override lazy val x = "mike"
}

Results:

scala> trait WithLazyVal {
| lazy val x = "adam"
| }
defined trait WithLazyVal

scala> trait WithVal {
| val x = "adam"
| }
defined trait WithVal

scala> trait WithDef {
| def x = "adam"
| }
defined trait WithDef

scala> trait WithVar {
| var x = "adam"
| }
defined trait WithVar

scala>

scala> class Test1 extends WithLazyVal {
| override var x = "mike"
| }
:7: error: overriding lazy value x in trait WithLazyVal$class of type java.lang.String;
variable x needs to be a stable, immutable value
override var x = "mike"
^

scala> class Test2 extends WithLazyVal {
| override val x = "mike"
| }
:7: error: overriding lazy value x in trait WithLazyVal$class of type java.lang.String;
value x must be declared lazy to override a concrete lazy value
override val x = "mike"
^

scala> class Test3 extends WithLazyVal {
| override def x = "mike"
| }
:7: error: overriding lazy value x in trait WithLazyVal$class of type java.lang.String;
method x needs to be a stable, immutable value
override def x = "mike"
^

scala> class Test4 extends WithLazyVal {
| override lazy val x = "mike"
| }
defined class Test4

scala> class Test5 extends WithVal {
| override var x = "mike"
| }
:7: error: overriding value x in trait WithVal$class of type java.lang.String;
variable x needs to be a stable, immutable value
override var x = "mike"
^

scala> class Test6 extends WithVal {
| override val x = "mike"
| }
defined class Test6

scala> class Test7 extends WithVal {
| override def x = "mike"
| }
:7: error: overriding value x in trait WithVal$class of type java.lang.String;
method x needs to be a stable, immutable value
override def x = "mike"
^

scala> class Test8 extends WithVal {
| override lazy val x = "mike"
| }
:7: error: overriding value x in trait WithVal$class of type java.lang.String;
lazy value x cannot override a concrete non-lazy value
override lazy val x = "mike"
^

scala> class Test9 extends WithVar {
| override var x = "mike"
| }
:7: error: overriding variable x in trait WithVar$class of type java.lang.String;
variable x cannot override a mutable variable
override var x = "mike"
^

scala> class Test10 extends WithVar {
| override val x = "mike"
| }
:7: error: overriding variable x in trait WithVar$class of type java.lang.String;
value x cannot override a mutable variable
override val x = "mike"
^

scala> class Test11 extends WithVar {
| override def x = "mike"
| }
:7: error: overriding variable x in trait WithVar$class of type java.lang.String;
method x cannot override a mutable variable
override def x = "mike"
^

scala> class Test12 extends WithVar {
| override lazy val x = "mike"
| }
:7: error: overriding variable x in trait WithVar$class of type java.lang.String;
lazy value x cannot override a mutable variable
override lazy val x = "mike"
^

scala> class Test13 extends WithDef {
| override var x = "mike"
| }
:7: error: method x_= overrides nothing
override var x = "mike"
^

scala> class Test14 extends WithDef {
| override val x = "mike"
| }
defined class Test14

scala> class Test15 extends WithDef {
| override def x = "mike"
| }
defined class Test15

scala> class Test16 extends WithDef {
| override lazy val x = "mike"
| }
defined class Test16