Why I can't use let in protocol in Swift?
"A var in a protocol with only get isn't just a let?" No. A let
indicates a constant. But that is not the case here. Consider the following:
protocol SomeProtocol { var someProperty: String { get }}class SomeClass : SomeProtocol { var someProperty: String = "" func cla () { someProperty = "asd" }}let someInstance = SomeClass()print(someInstance.someProperty) // outputs ""someInstance.cla()print(someInstance.someProperty) // outputs "asd"
The protocol specifies what the conforming class shows to the outside - some property of type String
named someProperty
which you can at least get.
If the protocol specifies { get }
your class can choose to conform via let someProperty: String = ""
but it can similarly choose to conform via the above code. If on the other hand the protocol specifies { get set }
you cannot use let
in the implementation but have to make it set-able as well.
A protocol simply cannot define that a value has to be constant - neither should it, that is an implementation detail that has to be taken care (or decided about) by the class / struct that implements it.
The difference is between
protocol MyProtocol { let someProperty: String}
which makes no sense — a protocol isn't supposed to dictate how someProperty
is defined/stored, only that it's available as a property. It could be either a computed or stored property, but that's for the implementer to decide, not the protocol itself.
and
protocol MyProtocol { var someProperty: String { get } // abstract interface}struct MyStruct: MyProtocol { let someProperty: String // concrete implementation: stored property}struct OtherStruct: MyProtocol { let i: Int var someProperty: String { return "\(i)" } // concrete implementation: computed property}
which is perfectly allowed!
I think a protocol can require that a structure has something, but it can't restrict functionality of struct or object. That shouldn't prevent you from doing what you'd probably like to do in code, for example using a var
in the protocol and a let
for the implementation is acceptable.
protocol MyProtocol { var trythis: Int { get }}struct MyStructure: MyProtocol { let trythis: Int}