Idiomatic Swift, zipping and retroactive modeling

[vitamin (Jon Gilbert)]

@ExFalsoQuodlibet

This thread discusses a way to implement another very, very common thing, that is, producing an identical copy of something, save for some specific properties, by writing only the code needed for changing those properties. @Jens shows some alternatives, along with other posters,

See my pitch for Compositional Initialization:

Compositional Initialization

Compositional Initalization Introduction This proposal introduces an opt-in protocol, PropertyInitializable, which provides two new init methods: failable init from a collections of extensible, typesafe keypath-value Property objects non-failable init to clone from another instance, mutating select properties The name “compositional init” means that this proposal allows the state of an object or struct to be assembled compositionally from sets of properties (including another instance). Com…

This addresses the exact thing you're asking about.

As well, it would offer a novel, albeit non-idiomatic, approach to your first question:

extension Location: PropertyInitializable {
    static var _blank: Location {
        return Self(x: 0, y: 0, a: 0)
    }
}

func process(_ results: MyResult<Int> ...) -> MyResult<Location> {
    var properties = [PartialProperty<Location>]()
    for (i, r) in results.enumerated() {
        switch (i, r) {
        case let (_, .failure(err)):
            return .failure(err) 
        case let (i, .success(n)):
            var path: WritableKeyPath<Location, Int>
            switch i {
            case 0: path = \.x
            case 1: path = \.y
            case 2: path = \.a
            default: fatalError()
            }
            properties += try! [path <- n]
        }
    }
    guard let loc = Location(properties) else {
        return .failure(.someError)
    }
    return .success(loc)
}


let result = process(r1, r2, r3)