Question

I’m writing some training material for the Groovy language and I’m preparing an example which would explain Closures.
The example is a simple caching closure for “expensive” methods, withCache

def expensiveMethod( Long a ) {
    withCache (a) {
        sleep(rnd())
        a*5
    }
}

So, now my question is: which of the two following implementations would be the fastest and more idiomatic in Groovy?

 def withCache = {key, Closure operation ->

    if (!cacheMap.containsKey(key)) {
        cacheMap.put(key, operation())
    }
    cacheMap.get(key)
 }

or

def withCache = {key, Closure operation ->
    def cached = cacheMap.get(key)
    if (cached) return cached
    def res = operation()
    cacheMap.put(key, res)
    res
}

I prefer the first example, as it doesn’t use any variable but I wonder if accessing the get method of the Map is slower than returning the variable containing the computed result.

Obviously the answer is “it depends on the size of the Map” but, out of curiosity, I would like to have the opinion of the community.

Thanks!

Answer 1

Firstly I agree with OverZealous, that worrying about two get operations is a premature optimization. The second exmaple is also not equal to the first. The first allows null for example, while the second on uses Groovy-Truth in the if, which means that null evals to false, as does for example an empty list/array/map. So if you want to show calling Closure I would go with the first one. If you want something more idiomatic I would do this instead for your case:

def expensiveMethod( Long a ) {
    sleep(rnd())
    a*5
}
def cache = [:].withDefault this.&expensiveMethod