Unfortunately, this doesn’t play so well with another wonderful Scala feature — implicit parameters. It’s often the case that you’ll want to defer resolution of an implicit until a method call, rather than in the scope of object creation. But lazy values cannot take any parameters, implicit or otherwise — so it seems you’re stuck.

Memoized to the rescue! This is a simple helper class that takes care of the caching of a result. Where you might have had the following method with an implicit parameter:

def foo(implicit bar: Bar): ResultType = { ... }

you instead write the following:

private var _foo = Memoized[ResultType]
def foo(implicit bar: Bar) = _foo or { ... }

(complete source below the fold)

That’s it; nothing fancy. This is not a true memoization solution for a function that takes a parameter — check out the memo package in Scalaz for that. But I’ve found it handy, and you might too.

class Memoized[T] {
	private var value: Option[T] = None
	def isEmpty = value.isEmpty
	def isDefined = ! isEmpty
	def get: T = value.get
	def set(newValue: T) { value = Some(newValue) }
	def getOrSet( newValue: => T): T = if (isDefined) get else {
		set(newValue)
		get
	}
	def or( newValue: => T): T = getOrSet(newValue)
	override def toString = value.toString
}
 
object Memoized {
	def apply[T] = new Memoized[T]
}