How to use lazy initialization with getter/setter method?

Question

How i can use lazy initialization with get and set() closure.

Here is lazy initialization code:

lazy var pi: Double = {
        // Calculations...
        return resultOfCalculation
        }()

and here is getter/setter code :

var pi: Double {
    get {
        //code to execute
        return someValue
    }
    set(newValue) {
        //code to execute
    }
}

1. Those aren't closures 2. The getter won't run until it's called. What are you trying to accomplish? — jscs, Aug 29 '17 at 12:33
How do you anticipate this working? With a `lazy` property it's set at the first access. With a setter it's set as soon as the setter is used. Do you want a default lazy getter and an explicit setter? Please add more detail. — , Aug 29 '17 at 12:33
You might be check : property observer The willSet and didSet observers of superclass properties are called when a property is set in a subclass initializer, after the superclass initializer has been called. They are not called while a class is setting its own properties, before the superclass initializer has been called. — karthikeyan, Aug 29 '17 at 12:36

Rob Napier · Answer 1 · 2017-08-29T13:52:38.233

I assume what you're trying to do is lazily generate the default for a writable property. I often find that people jump to laziness when it isn't needed. Make sure this is really worth the trouble. This would only be worth it if the default value is rarely used, but fairly expensive to create. But if that's your situation, this is one way to do it.

lazy implements one very specific and fairly limited pattern that often is not what you want. (It's not clear at all that lazy was a valuable addition to the language given how it works, and there is active work in replacing it with a much more powerful and useful system of attributes.) When lazy isn't the tool you want, you just build your own. In your example, it would look like this:

private var _pi: Double?
var pi: Double {
    get {
        if let pi = _pi { return pi }
        let result = // calculations....
        _pi = result
        return result
    }

    set { _pi = newValue }
}

This said, in most of the cases I've seen this come up, it's better to use a default value in init:

func computePi() -> Double {
    // compute and return value
}

// This is global. Globals are lazy (in a thread-safe way) automatically.
let computedPi = computePi()

struct X {
    let pi: Double // I'm assuming it was var only because it might be overridden
    init(pi: Double = computedPi) {
        self.pi = pi
    }
}

Doing it this way only computes pi once in the whole program (rather than once per instance). And it lets us make pi "write-exactly-once" rather than mutable state. (That may or may not match your needs; if it really needs to be writable, then var.)

A similar default value approach can be used for objects that are expensive to construct (rather than static things that are expensive to compute) without needing a global.

struct X {
    let pi: Double
    init(pi: ExpensiveObject = ExpensiveObject()) {
        self.pi = pi
    }
}

But sometimes getters and setters are a better fit.

score 2 · Answer 2 · answered Aug 29 '17 at 13:55

The point of a lazy variable is that it is not initialized until it is fetched, thus preventing its (possibly expensive) initializer from running until and unless the value of the variable is accessed.

Well, that's exactly what a getter for a calculated variable does too! It doesn't run until and unless it is called. Therefore, a getter for a calculated variable is lazy.

The question, on the whole, is thus meaningless. (The phrase "How i can use lazy initialization" reveals the flaw, since a calculated variable is never initialized — it is calculated!)

How to use lazy initialization with getter/setter method?

2 Answers2