Scala Mutable Option?

Question

I want something like this:

private val cachedResponse = mutable.Option.empty[A]

def get: A = cachedResponse getOrElseUpdate db.findModel()

def update: Unit = {
  db.updateModel
  cachedResponse.empty()    // set it to None/Option.empty
}

I am not looking for a generic HashMap based memoization like this. I tried implementing it using a var Option[A] but it did not look very idiomatic to me:

private var cachedResponse: Option[A] = None

def get: A = cachedResponse getOrElse {
 cachedResponse = Option(db.findModel())
 cachedResponse.get
}

def update: Unit = {
  db.updateModel
  cachedResponse = None
}

A quick googling found this implementation which looks like what you want...: http://blog.adamdklein.com/?p=689 — experquisite, Oct 20 '14 at 21:59

score 5 · Accepted Answer · answered Oct 21 '14 at 00:47

There isn't one built into the standard library.

Using a var containing an immutable Option is the idiomatic way to do it (assuming you can't rewrite this to not use state at all).

Otherwise, you should build your own. Here's the core of an implementation:

class MutableOpt[A] {
  private[this] var myValue: A = _
  private[this] var loaded = false
  private def valueEquals(o: Any) = myValue == o
  def get = if (loaded) myValue else throw new NoSuchElementException("MutableOpt")
  def set(a: A): this.type = { loaded = true; myValue = a; this }
  def getOrSet(a: => A): A = {
    if (!loaded) {
      myValue = a
      loaded = true
    }
    myValue
  }
  def isEmpty = !loaded
  def nonEmpty = loaded
  def foreach[U](f: A => U): Unit = if (loaded) f(myValue)
  def transform(f: A => A): this.type = { if (loaded) myValue = f(myValue); this }
  def clear(): this.type = { loaded = false; this }
  def toOption = if (loaded) Some(myValue) else None
  override def toString = if (loaded) "MutableOpt("+myValue.toString+")" else "MutableOpt()"
  override def hashCode = if (loaded) myValue.hashCode else 1751
  override def equals(o: Any) = o match {
    case m: MutableOpt[_] =>
      (isEmpty && m.isEmpty) || (nonEmpty && m.nonEmpty && m.valueEquals(myValue))
    case _ => false
  }
}
object MutableOpt {
  def from[A](o: Option[A]) = {
    val m = new MutableOpt[A]
    o match {
      case Some(a) => m set a
      case _ =>
    }
    m
  }
}

Define together with :paste if using the REPL.

LGTM. Thanks for sharing. But, there might be some race condition in getrSet in a multi threaded environment.. — pathikrit, Oct 21 '14 at 03:19
True, that is exactly one of the advantages of immutability over mutability. — Nader Ghanbari, Oct 21 '14 at 04:46
@wrick - Absolutely, just like with almost everything mutable. You could make all the operations atomic, but performance would suffer. — Rex Kerr, Oct 21 '14 at 08:48

Scala Mutable Option?

1 Answers1

Linked