Haben Sie automatisch + = definiert, wenn Sie + definieren?

Question

Ich habe einen Typ, der eine benutzerdefinierte + definiert hat. Ich frage mich, ob es für Swift möglich war, automatisch eine Definition für += zu schreiben, nämlich a += b ->a = a+b. Idealerweise müsste ich nicht für jeden Operator, den ich schreibe, den entsprechenden Zuweisungsoperator schreiben.

Beispielcode:

class A { 
    var value: Int 

    init(_ value: Int) { 
     self.value = value 
    } 

    static func +(lhs: A, rhs: A) -> A { 
     return A(lhs.value + rhs.value) 
    } 
} 

var a = A(42) 
let b = A(10) 

// OK 
let c = a + b 

// error: binary operator '+=' cannot be applied to two 'A' operands 
// Ideally, this would work out of the box by turning it into a = a+b 
a += b 

Answer 1

Normalerweise haben Sie += zu definieren, wenn Sie + definieren.

Sie könnten ein Summable Protokoll erstellen, das sowohl + und += erklärt, aber Sie werden immer noch keine konkrete Bedeutung der + Funktion, da die Zugabe von beliebigen Typen hat zu definieren. Hier ein Beispiel:

protocol Summable { 
    static func +(lhs: Self, rhs: Self) -> Self 
    static func +=(lhs: inout Self, rhs: Self) 
} 

extension Summable { 
    static func +=(lhs: inout Self, rhs: Self) { lhs = lhs + rhs } 
} 

struct S: Summable { } 

func +(lhs: S, rhs: S) -> S { 
    // return whatever it means to add a type of S to S 
    return S() 
} 

func f() { 
    let s0 = S() 
    let s1 = S() 
    let _ = s0 + s1 

    var s3 = S() 

    s3 += S() // you get this "for free" because S is Summable 
}