Swift override var inheritance - ios

Question

I am trying to do something like this in Swift.
public class BaseModel {
}
public class SubModel:BaseModel {
}
public class BaseClass {
public var model:BaseModel
init(_ model:BaseModel) {
self.model = model
}
}
public class SubClass: BaseClass {
override var model:SubModel
}
But the complier is not allowing me to override model object with a subclass. Is it possible to achieve something like what I am trying to do above in Swift using inheritance?

Answer 1

As written, this wouldn't be type-safe. Your interface requires that subclass.model = model has to work for any model (and in this specific example, SubClass(model) also is "legal" for any model because it's currently inheriting the init).
What I believe you really mean is that all BaseClass can return a Model, but SubClass can only be set with a SubModel.
How you fix this depends heavily on what the users of SubClass look like and why you're reaching for inheritance. As a rule, you should be hesitant to reach for inheritance in Swift. It's fully supported, but Swift tends to prefer other tools than class inheritance.
A common solution for this specific example would be a generic, for example:
// Place any general Model requirements here.
public protocol BaseModel {}
// Just marking things final to emphasize that subclassing is not required
// These can all also be structs depending on if you need values or references
public final class SubModel: BaseModel {}
public final class BaseClass<Model: BaseModel> {
var model: Model
init(_ model: Model) {
self.model = model
}
}
// You can typealias specific instances if that helps
// With this, the syntax is extemely close to what you were trying to do
typealias SubClass = BaseClass<SubModel>
let sc = SubClass(SubModel())
let model: BaseModel = sc.model
// But, it's type safe
public final class OtherModel: BaseModel {}
sc.model = OtherModel // Cannot assign value of type OtherModel to type SubModel
let bad = SubClass(OtherModel()) // Cannot convert value of type 'OtherModel' to expected argument type 'SubModel'
If BaseClass and SubClass were more complex, and had more internal logic to them, then you could move up to protocols for these, but it would depend on the particular problem you were solving. I'd generally start with generics for the situation you're describing.
You cannot change the types of stored properties in Swift. But covariant overrides are fine for methods and computed properties. So as long as you make model a computed property, you can use inheritance here, but you must be very careful when doing this to avoid crashes.
The simplest approach is to just add a new property with its own name to SubClass:
var subModel: SubModel { model as! SubModel }
But to get the overriding behavior you're asking for, you need to make model a computed property:
public class BaseClass {
private var _model: BaseModel
public var model: BaseModel { _model }
init(_ model:BaseModel) {
self._model = model
}
}
Then you can override model in SubClass:
public class SubClass: BaseClass {
public override var model: SubModel { super.model as! SubModel }
init(_ model: SubModel) {
super.init(model)
}
}
But note that this is dangerous. It is possible for BaseClass or a subclass of SubClass to break the invariant, and then this will crash. To fix that, you should make _model a let value, and make SubClass final:
public class BaseClass {
private let _model: BaseModel
public var model: BaseModel { _model }
init(_ model:BaseModel) {
self._model = model
}
}
public final class SubClass: BaseClass {
public override var model: SubModel { super.model as! SubModel }
init(_ model: SubModel) {
super.init(model)
}
}
All of this is awkward and hard to keep correct. It's hard to keep class inheritance correct in all OOP languages, and that leads to a lot of bugs. That's why Swift encourages other tools, like generics, to solve these problems. They're much easier to write correctly, and the compiler can catch your mistakes.