Initialization problem with Swift struct that contains lazy initializers

Question

I wrote two versions of code for a Swift programming exercise from an online programming exercise website. The exercise is as follows:

Find the difference between the square of the sum and the sum of the squares of the first N natural numbers. The square of the sum of the first ten natural numbers is (1 + 2 + ... + 10)² = 55² = 3025. The sum of the squares of the first ten natural numbers is 1² + 2² + ... + 10² = 385. Hence the difference between the square of the sum of the first ten natural numbers and the sum of the squares of the first ten natural numbers is 3025 - 385 = 2640.

The code for the first version is:

struct Squares {
    let squareOfSum : UInt64
    let sumOfSquares : UInt64
    let differenceOfSquares : UInt64

    init(_ number: UInt64) {
        var sum = ((1 + number) * number) / 2
        squareOfSum = sum * sum
        sum = 0
        for i in 1...number {
            sum = sum + (UInt64)(i * i)
        }
        sumOfSquares = sum
        differenceOfSquares = squareOfSum - sumOfSquares
    }
}
let sqrs = Squares(5)
print(sqrs.differenceOfSquares)

It passes compilation and runs without problem.

The code for the second version is:

struct Squares {
    let num : UInt64
    lazy var squareOfSum: UInt64 = {
        return ((1...num).reduce(0, +)).squared
    }()
    lazy var sumOfSquares: UInt64 = {
        return ((1...num).map{$0.squared}).reduce(0, +)
    }()
    lazy var differenceOfSquares: UInt64 = {return squareOfSum - sumOfSquares }()

    init(_ number: UInt64) {
        num = number
    }
}
extension Numeric {
    var squared: Self {
        return self * self
    }
}
let sqrs = Squares(5)
print(sqrs.differenceOfSquares)

When the code is compiled, the compiler produces the following messages:

/tmp/0C9C2EC3-543D-486F-BCB0-D181EC48DC82.8NCVch/main.swift:25:7: error: cannot use mutating getter on immutable value: 'sqrs' is a 'let' constant
print(sqrs.differenceOfSquares)
      ^~~~
/tmp/0C9C2EC3-543D-486F-BCB0-D181EC48DC82.8NCVch/main.swift:24:1: note: change 'let' to 'var' to make it mutable
let sqrs = Squares(5)
^~~
var

If I change let into var for sqrs, as suggested by the compiler, the code will run well. Alternatively, if I change the type struct into class to make the object mutable, the code will also run well. However, in the code in my first version, there's not problem with the combination of a struct object and a let mutability delimiter. How come in the second version, these two become incongruent? While I don't know why, I suspect that it may have to do with the lazy initializers in the second version.

Can anyone please help explain this? Thank you very much in advance.

Sweeper · Accepted Answer · 2020-07-17 00:36:33Z

1

Lazy properties have mutating getters, i.e. accessing a lazy property will potentially mutate the struct. Why? Think about the first time you access a lazy property. Before the first access, that property has no value, after you access it, the expression on the right of = is evaluated and assigned to the property. Now the property has a value. This is how accessing a lazy property can change the struct. As a result, you need a var to access lazy properties.

Changing the struct into a class also helps, because now sqrs stores a reference, and let sqrs only makes the reference to the object constant, rather than making the object itself constant.

The first version initialises all the properties in the initialiser. You are allowed to assign to each let property once in the initialiser, which is what the first version did. And since the properties are not lazy in the first version, you can access them with a let constant.

answered Jul 17, 2020 at 0:36

Sweeper

292k23 gold badges260 silver badges438 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Michael May Over a year ago

Thank you, Sweeper, for your clear explanation which is helpful for me to understand the matter. So, you mean, as far as lazy initialization concerned, the moment the lazy property is accessed and assigned to, the struct as whole is altered so that it cannot be assigned to a reference to a constant for a struct even for the first time? If that be so, it would be a pity for the language to be flexible. Anyway, in real life, security may override all other factors.

Collectives™ on Stack Overflow

Initialization problem with Swift struct that contains lazy initializers

1 Answer 1

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related