> On Nov 22, 2017, at 2:59 PM, Mike Kluev <mike.kl...@gmail.com> wrote: > > on Date: Tue, 21 Nov 2017 22:54:21 -0800 Douglas Gregor <dgre...@apple.com > <mailto:dgre...@apple.com>> wrote: > > > On Nov 21, 2017, at 10:48 PM, David Hart <da...@hartbit.com > > <mailto:da...@hartbit.com>> wrote: > > > > On 22 Nov 2017, at 07:41, Douglas Gregor via swift-evolution > > <swift-evolution@swift.org <mailto:swift-evolution@swift.org> > > <mailto:swift-evolution@swift.org <mailto:swift-evolution@swift.org>>> > > wrote: > > > >> > >> I think it’s straightforward and less ugly to make structural types allow > >> extensions and protocol conformances. > > > > Can somebody explain to me what is less ugly about that? I would have > > naturally thought that the language would be simpler as a whole if there > > only existed nominal types and all structural types were just sugar over > > them. > > See Thorsten’s response with, e.g., > > Function<Double, InoutParam<String>, Param<Int>> > > which handles “inout” by adding wrappers around the parameter types (which > one would have to cope with in any user of Function), but still doesn’t > handle argument labels. To handle argument labels, we would need something > like strings as generic arguments. We’d also need to handle calling > conventions and anything else we invent for function types. > > > can you outline how extensions and protocol conformances might look for > structural types? to compare the ugliness of both approaches.
There are some examples at https://github.com/apple/swift/blob/master/docs/GenericsManifesto.md#extensions-of-structural-types e.g., making all tuples of Equatable elements Equatable (which also mixes in conditional conformances and variadic generics): extension<...Elements : Equatable> (Elements...) : Equatable { // extending the tuple type "(Elements...)" to be Equatable } One could imagine adding a “curry” operation to function types: extension<Param1, Param2, Result> (Param1, Param2) -> Result { var curried: (Param1) -> (Param2) -> Result { return { (arg1: Param1) in { (arg2: Param2) in self(arg1, arg2) } } } } Or perhaps making metatypes Hashable so they can be used as keys into a Dictionary: extension<T> T.Type: Hashable { var hashValue: Int { return ObjectIdentifier(self).hashValue } static func ==(lhs: T.Type, rhs: T.Type) -> Bool { /* standard library magic */ } } - Doug
_______________________________________________ swift-evolution mailing list swift-evolution@swift.org https://lists.swift.org/mailman/listinfo/swift-evolution