Static calculation on demand? - swift

Question

I'm developing a class with a lot of functionality. Some functions need a lot of time, so I would store the result at creation for later access. But if this value is never needed, the calculation was wasted time.
In this case I would use a marker, if the value is already calculated. If yes, use the stored value. If not, it will calculate the value and store it in its static variable.
So I need the function itself, a marker and a variable for the saved result. Three items for every function!
Is there in Swift anything build in like "optional static functions"??
I would prefer to use
a = function()
for every call. The first call will calculate and save the result, all others will only take the precalculated result (like from a cache).

Answer 1

Lazy stored properties
In your comment below you describe that
But I don't meant global statically values, but for each instance. So
if you use foo1 and foo2, than foo2 needs to calculate its own
function for its own, because it only depends on values of foo2. It
can not rely on the globally calculated version which was done before
by foo1. So it is something like a "local static variable"
So it seems you may have a heavy computation for each instance of Foo, and you want to make certain that this computation is performed at most once, for each given instance of Foo. This demand is very close to the very definition of lazy (stored) properties in Swift: if a first call is made to get the value of a given lazy property, the property will be instantiated (e.g. by a call to some method, execution of a once-only executed closure, or simply by a given value/literal), and the value stored in the property. All subsequent calls to the lazy property will simply make use of the stored value (given you don't choose to mutate the property: lazy instance properties may not be immutables).
E.g., in practice:
class Foo {
lazy var bar: Int = self.reallyHeavyCalculation()
lazy var baz: Int = {
print("... heavy stuff")
return 2 * self.baq
}()
private func reallyHeavyCalculation() -> Int {
// ...
print("... other heavy stuff")
return 42
}
var bax: Int?
var baq: Int // instance value used in once-only computation
// of (lazy) property baz: at baz instantiation
init(baq: Int) { self.baq = baq }
}
let foo1 = Foo(baq: 50)
print("My first foo has never accessed his bar or baz")
foo1.bax = foo1.bar // at first call: compute 'bar' for this Foo instance
var baxBaz = foo1.bar // 'foo1.bar' already computed
print(foo1.baz) // at first call: compute 'baz' for this Foo instance
baxBaz = foo1.baz // 'foo1.baz' already computed
/* Prints:
My first foo has never accessed his bar or baz
... other heavy stuff
... heavy stuff
100 */
Static properties are always computed lazily
(When I initially read your question, I perceived your use case to be that of class/static properties, that are to be computed only once. I will leave this part of the answer as it is still relevant to the subject, and might be helpful to future readers)
Static properties are always computed lazily, meaning they will only be instantiated with a value given at least one call to them. After this instantiation, e.g. in case of a static immutable property, the once-only calculated value is readily available and stored in the static property.
We may read from the Language Guide - Properties:
Type Properties
...
Stored type properties are lazily initialized on their first access.
They are guaranteed to be initialized only once, even when accessed by
multiple threads simultaneously, and they do not need to be marked
with the lazy modifier.
...
Global and Local Variables
...
Global constants and variables are always computed lazily, in a
similar manner to Lazy Stored Properties. Unlike lazy stored
properties, global constants and variables do not need to be marked
with the lazy modifier.
We can verify this behavior with simple example:
class Foo {
static let foo: Int = reallyHeavyCalculation() // lazy
static let bar: Int = {
print("... heavy stuff")
return 99
}() // lazy
private static func reallyHeavyCalculation() -> Int {
// ...
print("... other heavy stuff")
return 42
}
var bax: Int? = nil
var baz = Foo.bar
}
print("I've never had a foo")
let foo1 = Foo()
// first initializion of instance member 'baz' by
// type member 'bar': compute bar
print("I have a foo")
foo1.bax = Foo.foo // at first call: compute 'Foo.foo'
let foo2 = Foo() // 'Foo.bar' already computed
print("I have another foo")
foo2.bax = Foo.foo // 'Foo'foo' already computed
/* Prints:
I've never had a foo
... heavy stuff
I have a foo
... other heavy stuff
I have another foo */
In the example above, the reallyHeavyComputation() (/closure associated with Foo.bar) method will be called exactly once in case you ask (at least once) for the value of the static immutable property Foo.foo (/Foo.bar). No additional calls will be made to reallyHeavyComputation() (/closure), even if you ask for the Foo.foo (/Foo.bar) value repeatedly.