I still have no idea why you want to make this change, other than “putting an
access modifier on an extension is different from putting an access modifier on
a type”. Are you trying to hide protocol conformances that would be otherwise
public?
In my proposal I cannot hide a public protocol conformance. Its not possible
with normal types and it shouldn’t be possible with extensions as well.
(Correct me if I’m wrong.) I really want the same access control behavior with
extensions like whit classes, enums and structs. For new Swift developers such
consistency would be great, because they won’t need to learn another access
control behavior (second one goes to protocols).
As I showed in my proposal right now its possible to create three different
version of public protocol default implementation:
public protocol A {
func foo()
}
extension A {
public func foo() {}
}
public extension A {
func foo() {}
}
public extension A {
public func foo() {}
}
If it was a type and I wanted foo to be visible I’d do this:
public struct B {
public func foo() {}
}
With the proposed content access control we’d have only one way for public
protocol default implementation:
public extension A {
public func foo() {}
}
Yet it fells strange when there is protocol conformance that we’re not allowed
to use access modifier anymore for our extension bag.
// Assume `A` has no default implementation
// Extension must retain `public` because B is `public` and `A` as well
// Explicitly public which is crystal clear
public extension B : A {
// foo must retain `public`
public func foo()
// custom member - implicitly internal - like on classes enums structs
func member() {}
}
Some rules from the proposal:
Access modifier on extensions should respect the modifier of the extended type
and the protocol to which it should conform.
Public protocol:
public type + public protocol = public extension
internal type + public protocol = internal extension
private type + public protocol = private extension
Internal protocol:
public type + internal protocol = public extension or internal extension
internal type + internal protocol = internal extension
private type + internal protocol = private extension
Private protocol:
public type + private protocol = public extension or internal extension or
private extension
internal type + private protocol = internal extension or private extension
private type + private protocol = private extension
Multiple protocol conformance is decided analogously by using the highest
access modifier from all protocols + the access level of the extended type.
That has much greater consequences and a much stronger domino effect than what
you’ve discussed here.
Could you explain this a little more? Maybe I’m to blind to see what else could
break this my proposal.
--
Adrian Zubarev
Sent with Airmail
_______________________________________________
swift-evolution mailing list
[email protected]
https://lists.swift.org/mailman/listinfo/swift-evolution
