Initializing a val lately

Question

Is it possible to do that in Scala using only val:

class MyClass {
  private val myVal1: MyClass2 //.....????? what should be here?

  def myMethod1(param1: Int) = {
    myVal1 = new MyClass2(param1)
    //....
    // some code....
  }
}

The idea is that I can't initialize myVal1 immediately since the argument for its constructor is unknown yet and I have to do that in myMethod1. myVal1 should be visible withing a class and should be immutable.

No mutable state allowed.

So is it possible?

I'd say you need to change your design. Your class can't be immutable if its state depends on someone calling a method in the future. If you want it to be immutable, you need to put `myVal1` into the constructor and change your design accordingly. — Petr, Jun 18 '13 at 14:54
Agreed - by definition, you have to have mutable state if you want a value to change - and to do this, that has to happen, you don't know your value until after the object is constructed, so it has to change from an initial (lack of a) value to the value. — Gareth Latty, Sep 28 '15 at 11:24

score 4 · Answer 1 · answered Jun 18 '13 at 06:16

4

No, it isn't possible to do in the way you want. Consider, what would be the result of

val mc = new MyClass
mc.method1(0)
mc.method1(1)

? An exception thrown for setting myVal1 twice? Or should it keep the first value?

answered Jun 18 '13 at 06:16

Alexey Romanov

167,066
35
309
487

score 3 · Accepted Answer · edited May 23 '17 at 11:44

3

This is not possible, but there are some ways (in addition to using param1 as a constructor parameter)

Change the var into an Option; the setter myMethod1 returns a new instance of the same class with the Option set to the value.
Create a separate mutable Builder class with a var, and turn it into an immutable one later, when all data has been collected
If you are dealing with forward or cyclic references, consider using call-by-name and lazy vals (example 1, example 2)

Update: Example for 1:

class MyClass(val myVal1: Option[Int]) {
  def myMethod1(param1: Int): MyClass = {
    new MyClass(Some(param1))
  }
}

object MyClass {
  def apply() = new MyClass(None)
  def apply(i: Int) = new MyClass(Some(i))
}

This pattern is used by immutable.Queue for example.

Update: Example for 3 (cyclic reference):

// ref ... call by name
class MyClass(val id: Int, ref: => MyClass) {
  lazy val myVal1 = ref

  override def toString: String = s"$id -> ${myVal1.id}"
}

to be used like this:

val a: MyClass = new MyClass(1, b)
val b: MyClass = new MyClass(2, a)
println(a)
println(b)

Update: Example for 3 (forward reference):

class MyClass2(val id: Int)

// ref ... call by name
class MyClass(val id: Int, ref: => MyClass2) {
  lazy val myVal1 = ref

  override def toString: String = s"$id -> ${myVal1.id}"
}

to be used with

val a = new MyClass(1, x)
println(a.id) // You can use a.id, but not yet the lazy val
val x = new MyClass2(10)
println(a)

edited May 23 '17 at 11:44

Community

1
1

answered Jun 18 '13 at 06:40

Beryllium

12,808
10
56
86

can you please show the examples of the first and third options? – Alan Coromano Jun 18 '13 at 06:49
I've added an example for the first option, and another link for the 3rd one. – Beryllium Jun 18 '13 at 07:29
thank you. what you mind adding an example of the third approach for my particular case? I went through the example in the link you gave me, but it turned out to be somewhat complicated and couldn't get along with it. – Alan Coromano Jun 18 '13 at 07:39
I've added simple example for option 3 – Beryllium Jun 18 '13 at 07:59
does the third one work only with cyclic references? anyway, I totally forgot about passing an argument by name. – Alan Coromano Jun 18 '13 at 08:49
I've added another example for option 3 (non-cyclic) – Beryllium Jun 18 '13 at 09:34
`Example for 3 (forward reference)` - do we really need passing `ref: => X)` as an argument by name, since `lazy val myVal1 = ref` is already lazy? – Alan Coromano Jun 18 '13 at 10:14
Yes, otherwise it is not "lazy enough". Just try it, I get a NPE in toString. – Beryllium Jun 18 '13 at 11:51
In my particular case, is there any way to solve my issue? I can't figure it out if using lazy val. What do you think? – Alan Coromano Jun 18 '13 at 13:56
I've changed the answer, and now I am out of *technical* ideas. Consider posting another question with additional background information, because there might be a completely different approach. – Beryllium Jun 18 '13 at 14:44

Max Plevako · Answer 3 · 2015-09-28T11:01:21.197

To imitate a lazy "value" whose initial value might not be retrieved until after instance initialization completes (btw, there is nothing special about such objects, e.g. Swift have lazy properties that are even recommended to be declared as variables), you can introduce a wrapper to repeat the same logic that the Scala compiler generates internally for lazy values in Scala:

class LazyVar[T] {

  private[this] var value$compute: () => T = () => null.asInstanceOf[T]
  @volatile private[this] var value$: T = null.asInstanceOf[T]
  @volatile private[this] var isInitialized$ = false
  @volatile private[this] var isComputed$ = false

  def value_=(value: T) = this.synchronized {
    if(!isInitialized$) {
      value$compute = () => value
      isInitialized$ = true
    }
    else throw new IllegalStateException("Already initialized")
  }

  def value: T = this.synchronized {
    if(!isInitialized$) throw new IllegalStateException("Not yet initialized")
    else if(isComputed$) value$
    else {
      value$ = value$compute()
      isComputed$ = true
      value$
    }
  }
}

Now you just have to change MyClass2 to LazyVar[MyClass2] keeping tha val keyword as you wanted:

case class MyClass2(param: Int)

class MyClass {
  private val myVal1: LazyVar[MyClass2] = new LazyVar[MyClass2]

  def this(param: Int) {
    this()
    println("Storing the result of an expensive function...")
    myVal1.value = new MyClass2(param)
  }

  def debug() = println(myVal1.value)
}

Now, if you write something like

val myClass = new MyClass(42)
myClass.debug
myClass.debug

you'll see the value is only computed once:

Storing the result of an expensive function...
MyClass2(42)
MyClass2(42)

Initializing a val lately

3 Answers3

Linked

Related