Sorry--I'm not at all saying that I think there's a problem. As you asked, I attempted to supply a contrived use case for a typealias declared in a protocol having a more restricted scope than the protocol itself. I was asking if it would be supported as part of your proposal.
On Mon, May 9, 2016 at 3:11 PM, David Hart <da...@hartbit.com> wrote: > I don’t see a problem with your example. Because the typealias is > fileprivate, it doesn’t exist as far as MyUsefulType is concerned. The same > way the following works: > > ``` > class Base { > private typealias Foo = Int > func foo() -> Int { > return Foo() > } > } > ``` > > Other file: > > ``` > class Derived: Base { > typealias Foo = String > func bar() -> String { > return "Hello \(foo())" > } > } > ``` > > On 09 May 2016, at 10:37, Xiaodi Wu <xiaodi...@gmail.com> wrote: > > On Mon, May 9, 2016 at 2:31 AM, David Hart <da...@hartbit.com> wrote: > >> >> On 09 May 2016, at 09:16, Xiaodi Wu <xiaodi...@gmail.com> wrote: >> >> One more thought here: >> >> It goes a long way to say "typealiases in protocols are to have the same >> semantics as aliases outside protocols." I'm inclined to agree on that, but >> I haven't thought it totally through. >> >> Now, I can have private typealiases outside protocols. Could I have >> private typealiases inside protocols? They'd be handy for referencing types >> while implementing default methods in protocol extensions and whatnot >> without worrying about collisions with typealiases in conforming types… >> >> >> Sounds like it should be allowed. I’ll add something about it in the >> proposal. Could you give an example of what you mean by "without worrying >> about collisions with typealiases in conforming types…”? >> >> > I wonder if this takes things in an, um, interesting direction. Suppose I > could have this (a contrived example--it may fall apart on further study): > > ``` > protocol MyUsefulProtocol { > associatedtype Storage : Collection > fileprivate typealias UniqueIdentifier = Storage.Index > func doUsefulThing() -> Storage > } > > extension MyUsefulProtocol { > func doUsefulThing() -> Storage { > // do something useful in this default implementation > // use UniqueIdentifier internally here and only here > } > } > ``` > > In a different file: > > ``` > struct MyUsefulType<A : Hashable, B> : MyUsefulProtocol { > /* I could do this if I wanted: > typealias UniqueIdentifier = A > > More importantly, I could retroactively conform MyUsefulType > to MyUsefulProtocol even if they happen to have clashing > typealiases, which is great because the typealias in > MyUsefulProtocol is used for clarity and convenience inside > the default implementation and is irrelevant here > */ > func doUsefulThing() -> Dictionary<A, B> { > // do something useful but different > // from the default implementation > } > } > ``` > > I wonder, though, if this is to be allowed, whether much the same could be > achieved by instead allowing associatedtype declarations to have default > values (for example: `associatedtype UniqueIdentifier : Equatable = > Storage.Index`), at which point we might be one step away from going full > circle and eliminating the distinction between associatedtypes and > typealiases once again. > > > On Mon, May 9, 2016 at 01:52 David Hart <da...@hartbit.com> wrote: >> >>> I understand that name clashing in those instances is important to >>> discuss, but I still think it is slightly orthogonal to the proposal. Let >>> me try to explain why. >>> >>> If typealises in protocols are to have the same semantics as alises >>> outside protocols (as I think they should), then they don’t change anything >>> about the rules of collision. For example, the problem already exists today >>> with associated types: >>> >>> protocol Foo { >>> associatedtype Inner: IntegerType >>> func foo(inner: Inner) >>> } >>> >>> protocol Bar { >>> associatedtype Inner: FloatingPointType >>> var inner: Inner { get } >>> } >>> >>> struct FooBarImpl: Foo, Bar { // error: Type ‘FooBarImpl’ does not >>> conform to protocol ‘Bar' >>> func foo(inner: Int) {} >>> var inner: Float >>> } >>> >>> Type aliasing would not change anything about the fact that those >>> collisions already exists in the language and are not very well handled: >>> either they are meant to be forbidden but in that case we need better >>> diagnostics, or we want to have a way to work around them. Perhaps you’d >>> like to start a discussion around fixing that ? >>> >>> On 09 May 2016, at 08:06, Xiaodi Wu <xiaodi...@gmail.com> wrote: >>> >>> I see your point that nothing breaks in the stdlib with your proposal >>> alone. It's undeniably true--by construction!--that a purely additive >>> feature, if never used, will not cause problems. >>> >>> That said, since the time that this feature was outlined in Doug's >>> manifesto, I have been wondering how clashes such as the examples in my >>> previous email are to be handled--i.e. what the rules of the language are >>> to be--which I think is certainly germane to your proposal. Can a >>> conforming type override a protocol typealias? Can a type conform to two >>> protocols with conflicting typealiases if all requirements are otherwise >>> satisfied? Surely, these merit discussion in your proposal. >>> >>> On Mon, May 9, 2016 at 12:48 AM David Hart <da...@hartbit.com> wrote: >>> >>>> Hello Xiaodi, >>>> >>>> What I mean by there is no impact on existing code is that the language >>>> change has no impact. Of course, if the Standard Library then declares a >>>> typealias Element in Sequence, it will clash with code which has declared >>>> an Element typealias in sub-protocols, but that is separate from the >>>> proposal. >>>> >>>> On 09 May 2016, at 07:28, Xiaodi Wu <xiaodi...@gmail.com> wrote: >>>> >>>> If the protocol Sequence has typealias Element, does that mean I also >>>> have MyConformingSequence.Element? >>>> >>>> If so, I think there is a potential impact on existing code not >>>> mentioned. Suppose MyConformingSequence already (unwisely) declares >>>> typealias Element. Now, what happens when I try to migrate my code to your >>>> proposed version of Swift? >>>> >>>> This is a toy example, of course. More generally, though, I wonder >>>> about this question: >>>> >>>> Suppose two protocols A and B each declare typealias Element. These >>>> typealiases are, as you proposed, intended to simplify referencing indirect >>>> associated types. But are they themselves considered protocol requirements? >>>> >>>> I ask because, suppose I want to conform type T to A and B. I implement >>>> all the required methods and properties for such conformance. I declare the >>>> appropriate typealiases for the associatedtypes declared in both protocols. >>>> But, if A.Element and B.Element are incompatible with each other, it is >>>> nonetheless impossible to conform T to both A and B? If it's forbidden, >>>> isn't that kind of a bummer, since what's getting in the way is a naming >>>> clash arising from a facility intended to simplify the naming of things >>>> rather than provide for new functionality? If it's permitted, what is >>>> T.Element? Some clarity here would be nice. >>>> On Sun, May 8, 2016 at 6:17 PM David Hart via swift-evolution < >>>> swift-evolution@swift.org> wrote: >>>> >>>>> Hello, >>>>> >>>>> I’ve come again with another proposal directly from the Generics >>>>> Manifesto. Please let me know if it needs any modifications before sending >>>>> the pull request. >>>>> >>>>> Typealiases in protocols and protocol extensions >>>>> >>>>> - Proposal: SE-XXXX >>>>> >>>>> <https://github.com/hartbit/swift-evolution/blob/typealiases-in-protocols/proposals/XXXX-typealiases-in-protocols.md> >>>>> - Authors: David Hart <https://github.com/hartbit>, Doug Gregor >>>>> <https://github.com/DougGregor> >>>>> - Status: TBD >>>>> - Review manager: TBD >>>>> >>>>> >>>>> <https://github.com/hartbit/swift-evolution/blob/typealiases-in-protocols/proposals/XXXX-typealiases-in-protocols.md#introduction> >>>>> Introduction >>>>> >>>>> This proposal is from the Generics Manifesto >>>>> <https://github.com/apple/swift/blob/master/docs/GenericsManifesto.md> and >>>>> brings the typealias keyword back into protocols for type aliasing. >>>>> >>>>> <https://github.com/hartbit/swift-evolution/blob/typealiases-in-protocols/proposals/XXXX-typealiases-in-protocols.md#motivation> >>>>> Motivation >>>>> >>>>> In Swift versions prior to 2.2, the typelias keyword was used outside >>>>> of protocols to declare type aliases and in protocols to declare >>>>> associated >>>>> types. Since SE-0011 >>>>> <https://github.com/apple/swift-evolution/blob/master/proposals/0011-replace-typealias-associated.md> >>>>> and >>>>> Swift 2.2, associated type now use the associatedtype keyword and >>>>> typelias is available for implementing true associated type aliases. >>>>> >>>>> <https://github.com/hartbit/swift-evolution/blob/typealiases-in-protocols/proposals/XXXX-typealiases-in-protocols.md#proposed-solution>Proposed >>>>> solution >>>>> >>>>> The solution allows the creation of associated type aliases. Here is >>>>> an example from the standard library: >>>>> >>>>> protocol Sequence { >>>>> associatedtype Iterator : IteratorProtocol >>>>> typealias Element = Iterator.Element >>>>> } >>>>> >>>>> The example above shows how this simplifies referencing indirect >>>>> associated types: >>>>> >>>>> func sum<T: Sequence where T.Element == Int>(sequence: T) -> Int { >>>>> return sequence.reduce(0, combine: +) >>>>> } >>>>> >>>>> >>>>> <https://github.com/hartbit/swift-evolution/blob/typealiases-in-protocols/proposals/XXXX-typealiases-in-protocols.md#detailed-design>Detailed >>>>> design >>>>> >>>>> The following grammar rules needs to be added: >>>>> >>>>> *protocol-member-declaration* → *protocol-typealias-declaration* >>>>> >>>>> *protocol-typealias-declaration* → *typealias-declaration* >>>>> >>>>> <https://github.com/hartbit/swift-evolution/blob/typealiases-in-protocols/proposals/XXXX-typealiases-in-protocols.md#impact-on-existing-code>Impact >>>>> on existing code >>>>> This will have no impact on existing code, but will probably require >>>>> improving the Fix-It that was created for migrating typealias to >>>>> associatedtype in Swift 2.2. >>>>> _______________________________________________ >>>>> swift-evolution mailing list >>>>> swift-evolution@swift.org >>>>> https://lists.swift.org/mailman/listinfo/swift-evolution >>>>> >>>> >>>> >>> >> > >
_______________________________________________ swift-evolution mailing list swift-evolution@swift.org https://lists.swift.org/mailman/listinfo/swift-evolution