Improvements to a custom scala recursion prevention mechanisem

Question

I would like to create a smart recursion prevention mechanism. I would like to be able to annotate a piece of code somehow, to mark that it should not be executed in recursion, and if it is indeed executed in recursion, then I want to throw a custom error (which can be caught to allow executing custom code when this happens)

Here is my attempt until here:

import scala.collection.mutable.{Set => MutableSet, HashSet => MutableHashSet } case class RecursionException(uniqueID:Any) extends Exception("Double recursion on " + uniqueID) object Locking { var locks:MutableSet[Any] = new MutableHashSet[Any] def acquireLock (uniqueID:Any) : Unit = { if (! (locks add uniqueID)) throw new RecursionException(uniqueID) } def releaseLock (uniqueID:Any) : Unit = { locks remove uniqueID } def lock1 (uniqueID:Any, f:() => Unit) : Unit = { acquireLock (uniqueID) try { f() } finally { releaseLock (uniqueID) } } def lock2[T] (uniqueID:Any, f:() => T) : T = { acquireLock (uniqueID) try { return f() } finally { releaseLock (uniqueID) } } }

and now to lock a code segment I do:

import Locking._ lock1 ("someID", () => { // Custom code here })

My questions are:

Is there any obvious way to get rid of the need for hard coding a unique identifier? I need a unique identifier which will actually be shared between all invocations of the function containing the locked section (so I can't have something like a counter for generating unique values, unless somehow scala has static function variables). I thought on somehow
Is there any way to prettify the syntax of the anonymouse function? Specifically, something that will make my code look like lock1 ("id") { /* code goes here */ } or any other prettier look.
A bit silly to ask in this stage, but I'll ask anyway - Am I re-inventing the wheel? (i.e. does something like this exist?)

Wild final thought: I know that abusing the synchronized keyword (at least in java) can gaurantee that there would be only one execution of the code (in the sense that no multiple threads can enter that part of the code at the same time). I don't think it prevents from the same thread to execute the code twice (although I may be wrong here). Anyway, if it does prevent it, I still don't want it (even thoug my program is single threaded) since I'm pretty sure it will lead to a deadlock and won't report an exception.

Edit: Just to make it clearer, this project is for error debugging purposes and for learning scala. It has no real useage other than easily finding code errors at runtime (for detecting recursion where it shouldn't happen). See the comments to this post.

Regardless of whether you're reinventing a wheel, why do you want this wheel? What's the value in preventing recursion? — Don Roby
– Don Roby, Commented Oct 24, 2011 at 20:01
@DonRoby: The main purpose is code testing (obviously it has no good purpose for programming). I'm writing a complex system where lots of functions call one another in long chains, where it may be easy to get confused while programming and potentially cause a recursion. Having a runtime error specifying this would be easier than reading long stacktraces. Other than that, it looks like an excellent way to practice scala :) — Barak Itkin
– Barak Itkin, Commented Oct 24, 2011 at 20:07
@PabloFernandez: Lock the entire body of a function with it. Try def bad:Unit = { lock1("hi", () => bad) } and then run bad. I agree that this mechanisem can be used for more than just preventing recursion, but recursion prevention was the original reason it was created for — Barak Itkin
– Barak Itkin, Commented Oct 24, 2011 at 20:19

Didier Dupont · Accepted Answer · 2011-10-24 20:48:38Z

Not quite sure what you're aiming at, but a few remarks:

First, you do not need to do lock1 and lock2 to distinguish Unit and the other type. Unit is a proper value type, the generic method will work for it too. Also, you should probably use a call by name argument => T, rather than a function () => T, and use two argument lists:

def lock[T] (uniqueID:Any)(f: => T) : T = { acquireLock (uniqueID) try { f } finally { releaseLock (uniqueID) } }

Then you can call with lock(id){block} and it looks like common instructions such as if or synchronized.

Second, why do you need a uniqueId, why make Lock a singleton? Instead, make Lock a class, an have as many instances as you would have had ids.

class Lock { def lock[T](f: => T): T = {acquireLock() ...} }

(You may even name your lock method apply, so you can just do myLock{....} rather than myLock.lock{...})

Multithreading aside, you now just need a Boolean var for acquire/releaseLock

Finally, if you need to support multithreading, you have to decide whether several thread can enter the lock (that would not be recursion). If they can, the boolean should be replaced with a DynamicVariable[Boolean] (or maybe a java ThreadLocal, as DynamicVariable is an InheritableThreadLocal, which you may or may not want). If they cannot, you just need to synchronize access in acquire/releaseLock.

Interesting point with the Unit as a type - I didn't know you can do that. Other than that, for the syntax correction - see the error I got below in Pablo's answer. For the creation of a new class - won't it create a new class instance at each invocation of the function? How then would the locking be shared between the instances?
certainly you would not do new Lock().lock{...}, that would not server any purpose. you would create locks as members of classes if the lock is instance specific, as global object otherwise. Same as what you do with synchronization lock, at least when it is not this.

Pablo Fernandez · Accepted Answer · 2011-10-24 20:37:41Z

Is there any obvious way to get rid of the need for hard coding a unique identifier?

Since for what you said on the comments this is not prod code, I guess you could use the functions hashCode property like this:

def lock1 (f:() => Unit) : Unit = { acquireLock (f.hashCode) try { f() } finally { releaseLock (f.hashCode) }

Is there any way to prettify the syntax of the anonymouse function?

With the before-mentioned change the syntax should be prettier:

lock1 {

If you're planning on keeping the identifier (if hashcode doesn't cut it for you) you can define your method like this:

def lock1 (uniqueID:Any)(f:() => Unit) : Unit = {

That will let you call the lock1 method with:

lock("foo") { }

Cheers!

The solution for the hashCode works :) The otherone however gives me syntax errors: def bad:Unit = { lock1("hi") {bad} } returns <console>:12: error: type mismatch; found : Unit required: () => Unit. Is there a scala version limitation for this? (Using 2.8.1)

Collectives™ on Stack Overflow

Improvements to a custom scala recursion prevention mechanisem

2 Answers 2

2 Comments

1 Comment

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

1 Comment

Related