What is the rationale for allowing to assign a new struct value to self?

Question

I'm not a Swift programmer, so I have no clue about the language. I'm just asking out of curiosity. I came across a language construct where self inside a mutating function gets assigned a new value like in the function moveByAssigmentToSelf in the example below.

struct Point {
    var x = 0.0
    var y = 0.0

    mutating func moveByAssigmentToSelf(_ deltaX: Double, _ deltaY: Double) {
        self = Point(x: x + deltaX, y: y + deltaY)
    }

    mutating func moveByMutatingMembers(_ deltaX: Double, _ deltaY: Double) {
        self.x += deltaX
        self.y += deltaY
    }
}

Coming from a C/C++/Java/C# background I think of self as a pointer (address) to the (start of) the struct value somewhere in memory (e.g. on the stack). To me, assigning to something that should be equivalent to this in a C++ struct looks very strange. AFAICT, the function moveByMutatingMembers should have an observationally equivalent effect and would be the natural thing to do in the C++/Java world.

Can someone explain to a non-Swift programmer what is the rationale / idea behind this concept?

All I can find in the language reference (the chapter on expressions) are the following vague statements: "In an initializer, subscript, or instance method, self refers to the current instance of the type in which it occurs." and "In a mutating method of a value type, you can assign a new instance of that value type to self."

What I'm trying to understand is why is that assignment a good idea, which programming problems does it solve compared to the conventional solution?

In other words: Why does this make sense from a language-design perspective? Or: What would you lose if you had to do it the C++/Java way?

BTW, out of curiosity, I had a look at the Godbolt disassembly of this example and for my untrained eyes the output for moveByAssigmentToSelf looks horribly inefficient compared to the alternative.

Answer 1

Coming from a C/C++/Java/C# background I think of self as a pointer

This is incorrect. Since this type is a value type (a struct), self is a copy of that value. The power of mutating is that it will, at the end of the function, replace the previous value with the new value. Values do not have "instances." They're just values.

For a useful introduction to value types in Swift, see Value and Reference Types. Also useful is Structures and Enumerations Are Value Types from the main Swift documentation.

Swift structs are somewhat like C++, if you let go of preconceptions about new and pointers and references, and just consider structs to be structs. They're passed as values (copies), just like C++ structs. It's just that in Swift this is the normal way to do things, unlike in C++, where things are generally passed by reference.

To your question about efficiency, that's just because you didn't turn on optimizations. With optimizations, they're literally the same code, and they inline the call to the init:

output.Point.moveByAssigmentToSelf(Swift.Double, Swift.Double) -> ():
        movupd  xmm2, xmmword ptr [r13]
        unpcklpd        xmm0, xmm1
        addpd   xmm0, xmm2
        movupd  xmmword ptr [r13], xmm0
        ret

output.Point.moveByMutatingMembers(Swift.Double, Swift.Double) -> ():
        jmp     (output.Point.moveByAssigmentToSelf(Swift.Double, Swift.Double) -> ())

---

Looking at your questions to @matt, I expect this may also help you understand the system a bit better:

var p: Point = Point(x: 1, y: 2) {
    didSet { print("new Point: \(p)")}
}

p.moveByMutatingMembers(1, 2)

This prints "new Point" just one time, because p is replaced (set) just one time.

On the other hand:

p.x = 0
p.y = 1

This will print "new point" twice because p is replaced twice. Calling a mutator on Point replaces the entire value with a new value.

Answer 2

Assigning to self is useful for several reasons, but your example does not illustrate any. While this would be better spelled by + and += operators, assigning to self would make sense in your example only if another method already existed which performed the work on a new value.

func moved(_ deltaX: Double, _ deltaY: Double) -> Self {
  .init(x: x + deltaX, y: y + deltaY)
}

mutating func move(_ deltaX: Double, _ deltaY: Double) {
  self = moved(deltaX, deltaY)
}

The other option for nonmutating and mutating pairs switches the work to the mutating variant:

func moved(_ deltaX: Double, _ deltaY: Double) -> Self {
  var point = self
  point.move(deltaX, deltaY)
  return point
}

mutating func move(_ deltaX: Double, _ deltaY: Double) {
  x += deltaX
  y += deltaY
}

See union for one example of that in action in the standard library. Your performance concerns are not unfounded but the __consuming you'll find there will soon put them to rest.

Answer 3

Structs do not actually mutate. Merely saying myPoint.x = 1.0 actually replaces the struct. Thus it is no big deal if a struct substitutes a new copy of the struct as self, because that's exactly what you do every time you assign into a property of the struct.

That is why you cannot assign into a struct instance referenced by a let variable; this would require assigning a new struct into that variable, and you can't because let signifies a constant.

let myPoint = Point()
myPoint.x = 1 // illegal, and now you know why

Contrast a class, which is mutable in place — and that's why you can assign into a property of a class instance referenced by a let variable.