generic variable rememberer without pass by reference

Question

I have the following snippet of code:

val oldStep = step
try {
  someDangerousActionPotentiallyModifyingStep()
} finally {
  step = oldStep
}

Is it possible to write a generic helper method to abstract away the pattern? Then I could use the helper method like this:

remember(step) {
  someDangerousActionPotentiallyModifyingStep()
}

Of course the following approach does not work, because Scala does not support pass by reference:

def remember[T](x: T)(action: => Unit) {
  val previousValue = x
  try {
    action
  } finally {
    x = previousValue
  }
}

I solved the problem by changing the step data member into an implicit parameter. That way, I never have to restore the old value of step, because its value never changes inside the same scope :)

[Somewhat related](http://stackoverflow.com/questions/869033/how-do-i-copy-an-object-in-java). You could make a shallow/deep copy of object and pass it to dangerous action on every try. — om-nom-nom, Jun 27 '13 at 15:22
Scala's closures are real (unlike Java's fake ones), meaning they do capture any free variables used within them. So for that purpose, it does have a kind of by-reference semantics. — Randall Schulz, Jun 27 '13 at 15:27
@RandallSchulz I have no idea what you're talking about. Where does Scala pass by reference? — fredoverflow, Jun 27 '13 at 15:30
If a closure makes a reference to a variable defined outside that closure, Scala compiles it (the closure *and* the referenced variable) in such a way that writing to it from the closure is reflected for all the references to that variable, both inside and outside the closure (and vice versa). There really is a single shared container for that variable that gets used by any reference (read or write) to that variable. This differs from Java which, creates a copy of variables accessed with this kind of pattern and thus forces read-only (assign once) semantics for such variables. — Randall Schulz, Jun 27 '13 at 20:50

Rüdiger Klaehn · Accepted Answer · 2013-06-27T16:42:41.120

The problem is that a var does not give you enough control to do what you want to do.

As a direct answer to your question: you need an object with an update method instead of a field. Something like this:

class Box[T](var value:T) { 
  def apply = value
  def update(newValue:T) { value = newValue }
  override def toString = value.toString 
}

Then you can solve your problem like this:

def remember[T](box:Box[T])(action: =>Unit) { 
  val prev = box.apply
  try { 
    action 
  } catch { 
    case _ => box() = prev 
  } 
}

val step = new Box(0)

// working update
remember(step) { step() = 4 }

// step is now 4

// aborted update
remember(step) { step() = 5; throw new Exception }

// step is still 4

But note that this is really not very idiomatic scala. You should try to make your someDangerousActionPotentiallyModifyingStep a side-effect-free function that returns the new step.

Basically like this:

try {    
  step = someDangerousFunctionOfStep(step)
} catch {
  case _ => // we don't have to do anything because step is still the same
}

If that is not possible for some reason, you might want to investigate Akka agents, which are conceptually similar to the Box above, except with the difference that they are thread-safe and can be used in a transactional way.

Here is how you would use akka agents to solve the problem:

First you need an actor system:

implicit val actorSystem = akka.actor.ActorSystem("test")

Then you can define an agent containing the step value

val step = akka.agent.Agent(0)

Now you can update it in a transaction:

import scala.concurrent.stm._    

atomic { txn => step() = 4 } 
// step.get will now return 4

atomic { txn => step() = 5; throw new Exception }
// step.get will still return 5. You will have to catch the exception if you don't want
// it to propagate outward

The real power of akka agents comes when you have multiple agents and update them atomically. See the akka agents docs for the canonical "account transfer" transaction example.

cmbaxter · Answer 2 · 2013-06-27T16:53:08.190

1

It's pretty ugly (and an affront to immutability), but you could try something like this:

def remember[T](newT:T, get: => T, set:(T) => Unit)(action: => Unit) = {
  var old = get
  set(newT)
  try{
    action
  }
  finally{
    set(old)
  }
}

And then use it like this:

var x = "hello"

remember[String]("world", x, x = _){
  //do something dangerous here 
}

edited Jun 27 '13 at 16:53

answered Jun 27 '13 at 16:44

cmbaxter

35,283
4
86
95

score 1 · Answer 3 · answered Jun 27 '13 at 21:09

1

I think you're looking for Loan pattern.

http://blog.knoldus.com/2012/11/16/scalaknol-understanding-loan-pattern/

answered Jun 27 '13 at 21:09

JasonG

5,794
4
39
67

generic variable rememberer without pass by reference

3 Answers3