<html><head><meta http-equiv="Content-Type" content="text/html charset=utf-8"></head><body style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><blockquote type="cite" class=""><div dir="auto" class=""><div class="">IMHO proposals like this should never be discussed in the context of trivial examples as the full scope of their value gets lost. I have written enough generics code in other languages to appreciate the idea of a 'headline-form-followed-by-the-details-idea' for any complex declaration. My understanding is that the proposal offers to make us write explicitely what anyone reading the code will try to extract out of the declaration. Instead of 100's or 1000's doing the work in their heads, the code author does it once for all subsequent readers. What's not to like about this idea?</div></div></blockquote><div class=""><br class=""></div><div class="">There is a lot not to like about the idea; even if it was optional. Personally, I feel the problem is solved in a much, much more elegant manner by other proposals.</div><div class=""><br class=""></div><div class="">Firstly, the stuff after the ‘where’ clause is getting shorter once typealiases come to protocols. C.Iterator.Element become C.Element. In this one example, that’s 18 characters down to 9 - a 50% reduction in length. We tend to use quite expressive names for associated types, so I expect we’ll see similar gains elsewhere from this very simple proposal.</div><div class=""><br class=""></div><div class="">Not only that, but there’s a very good proposal to add ‘where’ clauses to associated types in the protocols themselves, which will likely further reduce the verbosity of the constraints you need to specify at each declaration site. <a href="https://github.com/hartbit/swift-evolution/blob/9acd75abfbe626bbb3f9458cc3f6edb1d1f88c95/proposals/XXXX-associated-types-constraints.md" class="">https://github.com/hartbit/swift-evolution/blob/9acd75abfbe626bbb3f9458cc3f6edb1d1f88c95/proposals/XXXX-associated-types-constraints.md</a></div><div class=""><br class=""></div><div class="">And then we have generic typealiases and generalised existentials, which would allow us to wrap those ‘where’ clauses in to something much more intelligible to a human being at first glance. ‘StringCollection’ or ‘CollectionOfStrings’ is much clearer than <C:Collection where C.Element==String>, no matter how you chop it up.</div><div class=""><br class=""></div><div class="">If I look at the other proposals, and where we are headed with much more expressive typealiases and associated types, I just feel that that’s the future: that’s the “swift’ way. It’s like type inference - all of the strict constraints are still there under-the-hood, but you’re able to work at a much clearer and more obvious abstraction level. This proposal pulls us further away from things like ‘obviousness’, and like I said, simply feels like an inelegant solution.</div><div class=""><br class=""></div><div class="">At the very least, I think we should shelve the discussion until the larger expansion of typealiases, etc is complete. We should re-evaluate at that time, with a bigger set of more general-purpose tools to produce readable code.</div><div class=""><br class=""></div><br class=""><div><blockquote type="cite" class=""><div class="">On 14 May 2016, at 22:28, L. Mihalkovic via swift-evolution <<a href="mailto:swift-evolution@swift.org" class="">swift-evolution@swift.org</a>> wrote:</div><br class="Apple-interchange-newline"><div class=""><meta http-equiv="content-type" content="text/html; charset=utf-8" class=""><div dir="auto" class=""><div class=""><br class=""></div><div class=""><br class="">On May 14, 2016, at 9:43 PM, Pyry Jahkola via swift-evolution <<a href="mailto:swift-evolution@swift.org" class="">swift-evolution@swift.org</a>> wrote:<br class=""><br class=""></div><blockquote type="cite" class=""><div class=""><meta http-equiv="Content-Type" content="text/html charset=utf-8" class=""><div class="">Tony & Haravikk,</div><div class=""><br class=""></div><div class="">(Reformatting your quoted examples just a bit…)</div><br class=""><div class=""><blockquote type="cite" class=""><blockquote type="cite" class="">It enables things like:<br class=""><font face="Menlo" style="font-size: 11px;" class=""> <b class="">func</b> someMethod<S : SequenceType, T>(value: S) -> AnySequence<T><br class=""> <b class="">where</b> S.Generator.Element == T { ... }</font><br class=""></blockquote><br class="">I'm not assuming that. Under the current syntax, I would format your example as:<br class=""><br class=""><font face="Menlo" style="font-size: 11px;" class=""> <b class="">func</b> someMethod<<br class=""> S : SequenceType, T<br class=""> <b class="">where</b> S.Generator.Element == T<br class=""> >(value: S) -> AnySequence<T> {<br class=""> ...<br class=""> }</font><br class=""></blockquote></div><br class=""><div class="">You are both right here, but please note that the proposal still also allows moving <b class="">all</b> constraints to the `<font face="Menlo" class=""><span style="font-size: 11px;" class=""><b class="">where</b></span></font>` clause:</div><div class=""><br class=""></div><div class=""><font face="Menlo" style="font-size: 11px;" class=""> <b class="">func</b> someMethod<S, T>(value: S) -> AnySequence<T></font></div><div class=""><font face="Menlo" style="font-size: 11px;" class=""> <b class="">where</b> S : SequenceType,</font></div><div class=""><font face="Menlo" style="font-size: 11px;" class=""> S.Generator.Element == T</font></div><div class=""><font face="Menlo" style="font-size: 11px;" class=""> {</font></div><div class=""><font face="Menlo" style="font-size: 11px;" class=""> ...</font></div><div class=""><font face="Menlo" style="font-size: 11px;" class=""> }</font></div><div class=""><br class=""></div><div class="">just like Swift 2 allows doing so within the `<font face="Menlo" class=""><span style="font-size: 11px;" class=""><...></span></font>` brackets:</div><div class=""><br class=""></div><div class=""><div class=""><font face="Menlo" style="font-size: 11px;" class=""> <b class="">func</b> someMethod<S, T<br class=""> <b class="">where</b> S : SequenceType, S.Generator.Element == T</font></div><div class=""><font face="Menlo" class=""><span style="font-size: 11px;" class=""> >(value: S) -> AnySequence<T> {<br class=""> ...<br class=""> }</span><br class=""></font></div></div><div class=""><br class=""></div><div class="">The reason I'd recommend that style for anything but simple constraints is because:</div><div class=""><br class=""></div><div class="">1) It makes the call site `<font face="Menlo" class=""><span style="font-size: 11px;" class=""><b class="">let</b> items = someMethod(value: things)</span></font>` lightest to visually match to the declaration, because the only thing between the function name and its argument list is the `<font face="Menlo" class=""><span style="font-size: 11px;" class=""><...></span></font>` bracketed list of introduced generic types which you'll expect to see in the function signature and constraints.</div><div class=""><br class=""></div><div class="">2) In general, the `<font face="Menlo" class=""><span style="font-size: 11px;" class=""><b class="">where</b></span></font>` constraints really apply to the whole function/type declaration, not just a single generic parameter.</div><div class=""><br class=""></div><div class="">3) It was claimed that all constraints should go right next to the introduction of the generic parameters. But that isn't the whole case because Swift also applies <i class="">implicit</i> constraints onto any generic parameters that are used in constrained positions. If that wasn't clearly said, take the following example in Swift 2.x:</div><div class=""><br class=""></div><div class=""><font face="Menlo" class=""><span style="font-size: 11px;" class=""> <b class="">func</b> aMethod<S : SequenceType, T <b class="">where</b> S.Generator.Element == T>(value: S) -> Set<T> {</span></font></div><div class=""><font face="Menlo" class=""><span style="font-size: 11px;" class=""> <b class="">return</b> Set(value)</span></font></div><div class=""><font face="Menlo" class=""><span style="font-size: 11px;" class=""> }</span></font></div><div class=""><br class=""></div><div class="">That declaration actually makes you wait all the way until the return type `<font face="Menlo" class=""><span style="font-size: 11px;" class="">Set<T></span></font>` until you learn that `<font face="Menlo" style="font-size: 11px;" class="">T</font>` must also necessarily be `<font face="Menlo" style="font-size: 11px;" class="">Hashable</font>`. So I don't see how it's that different if the `<font face="Menlo" class=""><span style="font-size: 11px;" class=""><b class="">where</b></span></font>` clause isn't right next to the generic type arguments' introduction:</div><div class=""><br class=""></div><div class=""><div class=""><font face="Menlo" class=""><span style="font-size: 11px;" class=""> <b class="">func</b> </span></font><span style="font-family: Menlo; font-size: 11px;" class="">aMethod</span><font face="Menlo" class=""><span style="font-size: 11px;" class=""><S, T>(value: S) -> Set<T> <font color="#919191" class="">// FWIW, this line contains what I usually have in mind when browsing code.</font></span></font></div><div class=""><font face="Menlo" class=""><span style="font-size: 11px;" class=""> <b class="">where</b> <font color="#919191" class="">// T : Hashable, // (implicit)</font></span></font></div><div class=""><font face="Menlo" class=""><span style="font-size: 11px;" class=""> S</span></font><span style="font-family: Menlo; font-size: 11px;" class=""> : SequenceType,</span></div><div class=""><span style="font-family: Menlo; font-size: 11px;" class=""> S.Generator.Element == T</span></div><div class=""><font face="Menlo" class=""><span style="font-size: 11px;" class=""> {</span></font></div><div class=""><font face="Menlo" class=""><span style="font-size: 11px;" class=""> <b class="">return</b> Set(value)</span></font></div><div class=""><font face="Menlo" class=""><span style="font-size: 11px;" class=""> }</span></font></div></div><div class=""><br class=""></div><div class="">— Pyry</div><div class=""><br class=""></div></div></blockquote><div class=""><br class=""></div><div class=""><br class=""></div><br class=""><blockquote type="cite" class=""><div class=""><div class="">PS. Besides, neither the original example nor mine was really fair; you don't need `<font face="Menlo" class=""><span style="font-size: 11px;" class=""><b class="">where</b></span></font>` for these. Instead, you'd just write:</div><div class=""><br class=""></div><div class=""><font face="Menlo" class=""><span style="font-size: 11px;" class=""> <b class="">func</b> someMethod<S : SequenceType>(value: S) -> AnySequence<S.Generator.Element> {</span></font></div><div class=""><font face="Menlo" class=""><span style="font-size: 11px;" class=""> ...</span></font></div><div class=""><font face="Menlo" class=""><span style="font-size: 11px;" class=""> }</span></font></div><div class=""><br class=""></div><div class="">which SE-0081 has nothing to argue for or against.</div><div class=""><br class=""></div></div></blockquote><blockquote type="cite" class=""><div class=""><span class="">_______________________________________________</span><br class=""><span class="">swift-evolution mailing list</span><br class=""><span class=""><a href="mailto:swift-evolution@swift.org" class="">swift-evolution@swift.org</a></span><br class=""><span class=""><a href="https://lists.swift.org/mailman/listinfo/swift-evolution" class="">https://lists.swift.org/mailman/listinfo/swift-evolution</a></span><br class=""></div></blockquote></div>_______________________________________________<br class="">swift-evolution mailing list<br class=""><a href="mailto:swift-evolution@swift.org" class="">swift-evolution@swift.org</a><br class="">https://lists.swift.org/mailman/listinfo/swift-evolution<br class=""></div></blockquote></div><br class=""></body></html>