<html><head><style>
body {
font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
padding:1em;
margin:auto;
background:#fefefe;
}
h1, h2, h3, h4, h5, h6 {
font-weight: bold;
}
h1 {
color: #000000;
font-size: 28pt;
}
h2 {
border-bottom: 1px solid #CCCCCC;
color: #000000;
font-size: 24px;
}
h3 {
font-size: 18px;
}
h4 {
font-size: 16px;
}
h5 {
font-size: 14px;
}
h6 {
color: #777777;
background-color: inherit;
font-size: 14px;
}
hr {
height: 0.2em;
border: 0;
color: #CCCCCC;
background-color: #CCCCCC;
display: inherit;
}
p, blockquote, ul, ol, dl, li, table, pre {
margin: 15px 0;
}
a, a:visited {
color: #4183C4;
background-color: inherit;
text-decoration: none;
}
#message {
border-radius: 6px;
border: 1px solid #ccc;
display:block;
width:100%;
height:60px;
margin:6px 0px;
}
button, #ws {
font-size: 12 pt;
padding: 4px 6px;
border-radius: 5px;
border: 1px solid #bbb;
background-color: #eee;
}
code, pre, #ws, #message {
font-family: Monaco;
font-size: 10pt;
border-radius: 3px;
background-color: #F8F8F8;
color: inherit;
}
code {
border: 1px solid #EAEAEA;
margin: 0 2px;
padding: 0 5px;
}
pre {
border: 1px solid #CCCCCC;
overflow: auto;
padding: 4px 8px;
}
pre > code {
border: 0;
margin: 0;
padding: 0;
}
#ws { background-color: #f8f8f8; }
.bloop_markdown table {
border-collapse: collapse;
font-family: Helvetica, arial, freesans, clean, sans-serif;
color: rgb(51, 51, 51);
font-size: 15px; line-height: 25px;
padding: 0; }
.bloop_markdown table tr {
border-top: 1px solid #cccccc;
background-color: white;
margin: 0;
padding: 0; }
.bloop_markdown table tr:nth-child(2n) {
background-color: #f8f8f8; }
.bloop_markdown table tr th {
font-weight: bold;
border: 1px solid #cccccc;
margin: 0;
padding: 6px 13px; }
.bloop_markdown table tr td {
border: 1px solid #cccccc;
margin: 0;
padding: 6px 13px; }
.bloop_markdown table tr th :first-child, table tr td :first-child {
margin-top: 0; }
.bloop_markdown table tr th :last-child, table tr td :last-child {
margin-bottom: 0; }
.bloop_markdown blockquote{
border-left: 4px solid #dddddd;
padding: 0 15px;
color: #777777; }
blockquote > :first-child {
margin-top: 0; }
blockquote > :last-child {
margin-bottom: 0; }
code, pre, #ws, #message {
word-break: normal;
word-wrap: normal;
}
hr {
display: inherit;
}
.bloop_markdown :first-child {
-webkit-margin-before: 0;
}
code, pre, #ws, #message {
font-family: Menlo, Consolas, Liberation Mono, Courier, monospace;
}
.send { color:#77bb77; }
.server { color:#7799bb; }
.error { color:#AA0000; }</style></head><body style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;"><div class="bloop_markdown"><p></p></div><div class="bloop_original_html"><style>
body {
font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
padding:1em;
margin:auto;
background:#fefefe;
}
h1, h2, h3, h4, h5, h6 {
font-weight: bold;
}
h1 {
color: #000000;
font-size: 28pt;
}
h2 {
border-bottom: 1px solid #CCCCCC;
color: #000000;
font-size: 24px;
}
h3 {
font-size: 18px;
}
h4 {
font-size: 16px;
}
h5 {
font-size: 14px;
}
h6 {
color: #777777;
background-color: inherit;
font-size: 14px;
}
hr {
height: 0.2em;
border: 0;
color: #CCCCCC;
background-color: #CCCCCC;
display: inherit;
}
p, blockquote, ul, ol, dl, li, table, pre {
margin: 15px 0;
}
a, a:visited {
color: #4183C4;
background-color: inherit;
text-decoration: none;
}
#message {
border-radius: 6px;
border: 1px solid #ccc;
display:block;
width:100%;
height:60px;
margin:6px 0px;
}
button, #ws {
font-size: 12 pt;
padding: 4px 6px;
border-radius: 5px;
border: 1px solid #bbb;
background-color: #eee;
}
code, pre, #ws, #message {
font-family: Monaco;
font-size: 10pt;
border-radius: 3px;
background-color: #F8F8F8;
color: inherit;
}
code {
border: 1px solid #EAEAEA;
margin: 0 2px;
padding: 0 5px;
}
pre {
border: 1px solid #CCCCCC;
overflow: auto;
padding: 4px 8px;
}
pre > code {
border: 0;
margin: 0;
padding: 0;
}
#ws { background-color: #f8f8f8; }
.bloop_markdown table {
border-collapse: collapse;
font-family: Helvetica, arial, freesans, clean, sans-serif;
color: rgb(51, 51, 51);
font-size: 15px; line-height: 25px;
padding: 0; }
.bloop_markdown table tr {
border-top: 1px solid #cccccc;
background-color: white;
margin: 0;
padding: 0; }
.bloop_markdown table tr:nth-child(2n) {
background-color: #f8f8f8; }
.bloop_markdown table tr th {
font-weight: bold;
border: 1px solid #cccccc;
margin: 0;
padding: 6px 13px; }
.bloop_markdown table tr td {
border: 1px solid #cccccc;
margin: 0;
padding: 6px 13px; }
.bloop_markdown table tr th :first-child, table tr td :first-child {
margin-top: 0; }
.bloop_markdown table tr th :last-child, table tr td :last-child {
margin-bottom: 0; }
.bloop_markdown blockquote{
border-left: 4px solid #dddddd;
padding: 0 15px;
color: #777777; }
blockquote > :first-child {
margin-top: 0; }
blockquote > :last-child {
margin-bottom: 0; }
code, pre, #ws, #message {
word-break: normal;
word-wrap: normal;
}
hr {
display: inherit;
}
.bloop_markdown :first-child {
-webkit-margin-before: 0;
}
code, pre, #ws, #message {
font-family: Menlo, Consolas, Liberation Mono, Courier, monospace;
}
.send { color:#77bb77; }
.server { color:#7799bb; }
.error { color:#AA0000; }</style><div class="bloop_markdown"><p></p></div><div class="bloop_original_html"><style>body{font-family:Helvetica,Arial;font-size:13px}</style><div id="bloop_customfont" style="font-family:Helvetica,Arial;font-size:13px; color: rgba(0,0,0,1.0); margin: 0px; line-height: auto;">I open a new thread just for clarity. This proposal was started two weeks ago in a discussion thread where I talked to the community and refined the proposal over a few past days. The overall response was positive to this proposal.</div><div id="bloop_customfont" style="font-family:Helvetica,Arial;font-size:13px; color: rgba(0,0,0,1.0); margin: 0px; line-height: auto;"><br></div><div id="bloop_customfont" style="font-family:Helvetica,Arial;font-size:13px; color: rgba(0,0,0,1.0); margin: 0px; line-height: auto;">Original thread: <a href="https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160502/016523.html"><span style="color: rgb(0, 0, 0);">[Pitch] merge types and protocols back together with type<Type, Protocol, ...></span></a></div><div id="bloop_customfont" style="font-family:Helvetica,Arial;font-size:13px; color: rgba(0,0,0,1.0); margin: 0px; line-height: auto;"><br></div><div id="bloop_customfont" style="font-family:Helvetica,Arial;font-size:13px; color: rgba(0,0,0,1.0); margin: 0px; line-height: auto;">This is my first proposal where I'll submit a pull request. Furthermore my English isn’t that great so please bear with me. If you spot any typos or other mistakes I’d be happy to look into your feedback. Feel free to send me such feedback in private.</div><div id="bloop_customfont" style="font-family:Helvetica,Arial;font-size:13px; color: rgba(0,0,0,1.0); margin: 0px; line-height: auto;"><br></div><div id="bloop_customfont" style="font-family:Helvetica,Arial;font-size:13px; color: rgba(0,0,0,1.0); margin: 0px; line-height: auto;">Just for clarification: this proposal does not try to create type intersection in Swift, so please don’t ask me to change this. `Type intersection` is totally a different story and can have its own thread and proposal. ;)</div><div id="bloop_customfont" style="font-family:Helvetica,Arial;font-size:13px; color: rgba(0,0,0,1.0); margin: 0px; line-height: auto;"><br></div><div id="bloop_customfont" style="font-family:Helvetica,Arial;font-size:13px; color: rgba(0,0,0,1.0); margin: 0px; line-height: auto;">Here is the formatted version of my proposal: <a href="https://github.com/DevAndArtist/swift-evolution/blob/master/proposals/nnnn-mechanism-to-combine-types-and-protocols.md">https://github.com/DevAndArtist/swift-evolution/blob/master/proposals/nnnn-mechanism-to-combine-types-and-protocols.md</a></div><div id="bloop_customfont" style="font-family:Helvetica,Arial;font-size:13px; color: rgba(0,0,0,1.0); margin: 0px; line-height: auto;"><br></div><div id="bloop_customfont" style="font-family:Helvetica,Arial;font-size:13px; color: rgba(0,0,0,1.0); margin: 0px; line-height: auto;">I hope to see your final feedback before I submit the proposal to the evolution repository.</div><div id="bloop_customfont" style="font-family:Helvetica,Arial;font-size:13px; color: rgba(0,0,0,1.0); margin: 0px; line-height: auto;"><br></div><div class="bloop_sign" id="bloop_sign_1463417988041157120"><div style="font-family:helvetica,arial;font-size:13px">-- <br>Adrian Zubarev<br>Sent with Airmail</div></div></div><div class="bloop_markdown"><p></p>
<h1 id="newmechanismtocombinetypeswithorprotocols">New mechanism to combine <code>Types</code> with/or <code>Protocols</code></h1>
<ul>
<li>Proposal: <a href="https://github.com/apple/swift-evolution/blob/master/proposals/NNNN-name.md">SE-NNNN</a></li>
<li>Author(s): <a href="https://github.com/DevAndArtist">Adrian Zubarev</a></li>
<li>Status: <a href="#rationale">Awaiting review</a></li>
<li>Review manager: TBD</li>
</ul>
<h2 id="introduction">Introduction</h2>
<p>The current <code>protocol<></code> mechanism defines the <code>Any</code> protocol to which all types implicitly conform. It also can combine distinct protocols to a new <code>Protocol</code>, whereas combinging <code>SubProtocol</code> with its <code>BaseProtocol</code> will be inferred as <code>SubProtocol</code> (the order withhin the angle brackets doesn’t matter). I propose to replace the current <code>protocol<></code> mechanism with a new more powerful mechanism called <code>All<></code>, which will allow combining <code>Types</code> with independent <code>Protocols</code> and enforce <strong>all</strong> constraints.</p>
<p>Swift-evolution thread: <a href="https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160502/016523.html">[Pitch] Merge <code>Types</code> and <code>Protocols</code> back together with <code>type<Type, Protocol, ...></code></a></p>
<h2 id="motivation">Motivation</h2>
<p>The motivation for this proposal comes from solving the missing <code>Type</code> issue (<a href="https://openradar.appspot.com/20990743">rdar://20990743</a>) and combining the idea mentioned in the generics manifesto for Swift 3 in section <a href="https://github.com/apple/swift/blob/master/docs/GenericsManifesto.md#renaming-protocol-to-any-">Renaming <code>protocol<...></code> to <code>Any<...></code></a>. </p>
<p>The proposed mechanism will allow us to create a new <code>Type</code> from extendable distinct types - there are still some restrinctions you can read about below.</p>
<h2 id="proposedsolution">Proposed solution</h2>
<p>First step to implement this proposal would need to rename <code>protocol<></code> to <code>All<></code> and configure the migration process to update code that used old style <code>protocol<></code>.</p>
<p>Next the <code>All<></code> mechanism would be extended to allow nesting and at most one <strong>extendable</strong> value or reference type. When all types within angle brackets are indepented/distinct to each other a new <code>Type</code> will be formed by <code>All<A, B, ...></code>. This new <code>Type</code> can be used to store instances that conform to <strong>all</strong> constrains defined by <code>All<></code> without any generic context (see <strong>Detailed design</strong> for more information).</p>
<p>Here only some subtype of <code>UIView</code> (dynamic type) conforms to <code>SomeProtocol</code>, but both types within angle brackets are distinct.</p>
<pre><code class="swift">protocol SomeProtocol {}
extension SomeProtocol {
func foo() { print("fooooo") }
}
// we'll be able to store the new type without generics
class A {
var view: All<UIView, SomeProtocol>
init(view: All<UIView, SomeProtocol>) {
self.view = view
}
// `dynamicType` of the `view` might be `UIButton` for example
// but we still be able to acces SomeProtocol which only UIButton conforms to
func doSomeWork() {
self.view.removeFromSuperview() // just for a simple example
self.view.foo() // prints "fooooo"
}
}
extension UIButton: SomeProtocol {}
let button: SomeProtocol = UIButton() // split types for the example
if let mergedValue = button as? All<UIView, SomeProtocol> {
let a = A(view: mergedValue)
a.doSomeWork()
}
</code></pre>
<h2 id="detaileddesign">Detailed design</h2>
<h4 id="rulesforall:">Rules for <code>All<></code>:</h4>
<ol>
<li><p>Empty <code>All<></code> will be used as <code>typealias Any = All<></code>. No constraints means it can accept any type or simply that all types implicitly conform to empty <code>All<></code>. This is the logical replacement for <code>typealias Any = protocol<></code>.</p></li>
<li><p>The order of <code>Types</code> within angle brackets doesn’t matter: <code>All<A, B> == All<B, A></code>. (The compiler already reorders the types by its own will from <code>protocol<B, A></code> to <code>protocol<A, B></code>.)</p></li>
<li><p><code>All<></code> can be composed from protocols and by the mention of this rule fully replace <code>protocol<...></code> </p>
<ul>
<li><code>All<ProtocolA, ...></code> equals to old <code>protocol<ProtocolA, ...></code></li>
<li><code>All<ProtocolX></code> equals to old <code>protocol<ProtocolX></code> or simply inferred as <code>ProtocolX</code></li>
</ul></li>
<li><p><code>All<></code> can contain at most one <u>extendable</u> value or reference type plus none or n protocols.</p>
<ul>
<li><code>All<ReferenceType></code> or <code>All<ReferenceType, Protocol, ...></code></li>
<li><code>All<ValueType></code> or <code>All<ValueType, Protocol, ...></code></li>
<li>This rule will disallow <code>All<></code> to contain unnecessary inheritance type branches from subtypeable types.</li>
<li>Furthermore will this rule ban confusion when using <code>All<T, U></code> in a generic context.</li>
</ul></li>
<li><p>Subtypeable <code>Type</code> from within angle brackets of <code>All<></code> can be seen as the base type of the dynamic type.</p></li>
<li><p>Nesting <code>All<></code> is allowed under special rules:</p>
<ul>
<li><code>A: All<></code> can contain <code>B: All<></code> if <code>B</code> is composed from protocols:
<ul>
<li>e.g. <code>All<AnyType, All<ProtocolA, ProtocolB, ...>></code> will be inferred as <code>All<AnyType, ProtocolA, ProtocolB, ...></code></li>
</ul></li>
<li>For subtypeable types <code>A: All<></code> can contain <code>B: All<></code> if <code>B</code> is composed from a possible base type of <code>A</code> and none or n protocols:
<ul>
<li>e.g. <code>A = All<All<C, Protocol>, SomeProtocol></code> where <code>B = All<C, Protocol></code> and <code>C</code> is some base <code>Type</code> of <code>A</code> which implies to <code>A = All<C, Protocol, SomeProtocol></code></li>
<li>Again nesting the inheritance type branch is not allowed, because of rule #4.</li>
</ul></li>
</ul></li>
<li><p>All types should be checked againts each other to find a simplified <code>Type</code>. At the end all type dependencies should be distinct and will form a new constrained type. These constraints are then tested against the dynamic type.</p>
<pre><code class="swift">protocol X {} protocol Y: X {}
class A: X {} class B: Y {}
All<A, X, Y> /* inferred as */ All<A, Y>
// e.g. will the above type accept `B` but not `A` as long `A` doesn't conform to `Y`
All<B, X, Y> /* inferred as */ All<B> /* or simply just */ B
</code></pre></li>
<li><p><code>All<></code> can be an optional type <code>All<>?</code> or <code>All<>!</code></p></li>
</ol>
<h4 id="detaileddesignforallbelowtypeisanextendabletype:">Detailed design for <code>All<></code> (below <code>type</code> is an extendable type):</h4>
<ol>
<li><p><code>type A</code> can be applied to <code>All<A> == A</code>, <code>All<Any> == Any == All<></code> or <code>All<GenericType> == GenericType</code></p></li>
<li><code>type B: C</code>:
<ul>
<li><p><code>class B: ProtocolC</code> can be applied to:</p>
<table>
<colgroup>
<col style="text-align:left;">
<col style="text-align:center;">
</colgroup>
<thead>
<tr>
<th style="text-align:left;">Type</th>
<th style="text-align:center;">Equivalent inferred <code>Type</code> (** generic)</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:left;"><code>All<ProtocolC></code></td>
<td style="text-align:center;"><code>ProtocolC</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any, ProtocolC></code></td>
<td style="text-align:center;"><code>ProtocolC</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any></code></td>
<td style="text-align:center;"><code>Any</code> or <code>All<></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType, ProtocolC></code></td>
<td style="text-align:center;">**<code>DynamicType: ProtocolC</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType></code></td>
<td style="text-align:center;">**<code>DynamicType</code> </td>
</tr>
<tr>
<td style="text-align:left;"><code>All<B, ProtocolC></code></td>
<td style="text-align:center;"><code>B</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<B></code></td>
<td style="text-align:center;"><code>B</code></td>
</tr>
</tbody>
</table>
</li>
<li><p><code>class B: ClassC</code> can be applied to:</p>
<ul>
<li>One would not want to combine <code>All<ClassC, B></code> even in a generic context like <code>All<T, U></code> for example to union one value of <code>B</code> and another value of <code>ClassC</code>, because followed by rule #2 the compiler will reoder the types to <code>All<B, ClassC></code> and infer that as <code>B</code>. <code>B</code> can not hold <code>ClassC</code>. This implies that <code>All<></code> does not intersect types and the need of rule #4.</li>
</ul>
<table>
<colgroup>
<col style="text-align:left;">
<col style="text-align:center;">
</colgroup>
<thead>
<tr>
<th style="text-align:left;">Type</th>
<th style="text-align:center;">Equivalent inferred <code>Type</code> (** generic)</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:left;"><code>All<ClassC></code></td>
<td style="text-align:center;"><code>ClassC</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<B></code></td>
<td style="text-align:center;"><code>B</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType></code></td>
<td style="text-align:center;">**<code>DynamicType</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any></code></td>
<td style="text-align:center;"><code>Any</code> or <code>All<></code></td>
</tr>
</tbody>
</table>
</li>
<li><p><code>struct B: ProtocolC</code> is analogous to <code>class B: ProtocolC</code>.</p></li>
<li><p><code>enum B: ProtocolC</code> is analogous to <code>struct B: ProtocolC</code>.</p></li>
<li><p><code>protocol B: C</code> can be applied to:</p>
<table>
<colgroup>
<col style="text-align:left;">
<col style="text-align:center;">
</colgroup>
<thead>
<tr>
<th style="text-align:left;">Type</th>
<th style="text-align:center;">Equivalent inferred <code>Type</code> (** generic)</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:left;"><code>All<Any, B></code></td>
<td style="text-align:center;"><code>B</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any, C></code></td>
<td style="text-align:center;"><code>C</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any></code></td>
<td style="text-align:center;"><code>Any</code> or <code>All<></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType, B></code></td>
<td style="text-align:center;">**<code>DynamicType: B</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType, C></code></td>
<td style="text-align:center;">**<code>DynamicType: C</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType></code></td>
<td style="text-align:center;">**<code>DynamicType</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<B, C></code></td>
<td style="text-align:center;"><code>B</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<B></code></td>
<td style="text-align:center;"><code>B</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<C></code></td>
<td style="text-align:center;"><code>C</code></td>
</tr>
</tbody>
</table>
</li>
</ul></li>
<li><code>type B</code> distinct to <code>C</code>:
<ul>
<li>The following points will produce a new <code>Type</code>:
<ul>
<li><code>class B</code> and <code>protocol C</code> can be combined to <code>All<B, C></code>.</li>
<li><code>struct B</code> and <code>protocol C</code> can be combined to <code>All<B, C></code>.</li>
<li><code>enum B</code> and <code>protocol C</code> can be combined to <code>All<B, C></code>.</li>
<li><code>protocol B</code> and <code>protocol C</code> can be combined to <code>All<B, C></code>.</li>
</ul></li>
<li>The following points should all raise an compilation error:
<ul>
<li><code>class B</code> and <code>class C</code> can NOT be combined.</li>
<li><code>struct B</code> and <code>struct C</code> can NOT be combined.</li>
<li><code>enum B</code> and <code>enum C</code> can NOT be combined.</li>
</ul></li>
</ul></li>
<li><code>type D: E, F</code> where <code>E</code> doesn’t conform to <code>F</code>:
<ul>
<li><p><code>class D: ClassE, ProtocolF</code> type can be applied to:</p>
<table>
<colgroup>
<col style="text-align:left;">
<col style="text-align:center;">
</colgroup>
<thead>
<tr>
<th style="text-align:left;">Type</th>
<th style="text-align:center;">Equivalent inferred <code>Type</code> (** generic)</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:left;"><code>All<ProtocolF></code></td>
<td style="text-align:center;"><code>ProtocolF</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any, ProtocolF></code></td>
<td style="text-align:center;"><code>ProtocolF</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any></code></td>
<td style="text-align:center;"><code>Any</code> or <code>All<></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType, ProtocolF></code></td>
<td style="text-align:center;">**<code>DynamicType: ProtocolF</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType></code></td>
<td style="text-align:center;">**<code>DynamicType</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D, ProtocolF></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<ClassE, ProtocolF></code></td>
<td style="text-align:center;"><strong>NEW:</strong> <code>All<ClassE, ProtocolF></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<ClassE></code></td>
<td style="text-align:center;"><code>ClassE</code></td>
</tr>
</tbody>
</table>
</li>
<li><p><code>class D: ProtocolE, ProtocolF</code> type can be applied to:</p>
<table>
<colgroup>
<col style="text-align:left;">
<col style="text-align:center;">
</colgroup>
<thead>
<tr>
<th style="text-align:left;">Type</th>
<th style="text-align:center;">Equivalent inferred <code>Type</code> (** generic)</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:left;"><code>All<ProtocolE, ProtocolF></code></td>
<td style="text-align:center;"><code>All<ProtocolE, ProtocolF></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<ProtocolE></code></td>
<td style="text-align:center;"><code>ProtocolE</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<ProtocolF></code></td>
<td style="text-align:center;"><code>ProtocolF</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any, ProtocolE, ProtocolF></code></td>
<td style="text-align:center;"><code>All<ProtocolE, ProtocolF></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any, ProtocolE></code></td>
<td style="text-align:center;"><code>ProtocolE</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any, ProtocolF></code></td>
<td style="text-align:center;"><code>ProtocolF</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any></code></td>
<td style="text-align:center;"><code>Any</code> or <code>All<></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType, ProtocolE, ProtocolF></code></td>
<td style="text-align:center;">**<code>DynamicType: All<ProtocolE, ProtocolF></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType, ProtocolE></code></td>
<td style="text-align:center;">**<code>DynamicType: ProtocolE</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType, ProtocolF></code></td>
<td style="text-align:center;">**<code>DynamicType: ProtocolF</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType></code></td>
<td style="text-align:center;">**<code>DynamicType</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D, ProtocolE, ProtocolF></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D, ProtocolE></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D, ProtocolF></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
</tbody>
</table>
</li>
<li><p><code>struct D: ProtocolE, ProtocolF</code> is analogous to <code>class D: ProtocolE, ProtocolF</code>.</p></li>
<li><p><code>enum D: ProtocolE, ProtocolF</code> is analogous to <code>struct D: ProtocolE, ProtocolF</code>.</p></li>
<li><p><code>protocol D: E, F</code> type can be applied to:</p>
<table>
<colgroup>
<col style="text-align:left;">
<col style="text-align:center;">
</colgroup>
<thead>
<tr>
<th style="text-align:left;">Type</th>
<th style="text-align:center;">Equivalent inferred <code>Type</code> (** generic)</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:left;"><code>All<GenericType, E, F></code></td>
<td style="text-align:center;">**<code>DynamicType: All<E, F></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType, E></code></td>
<td style="text-align:center;">**<code>DynamicType: E</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType, F></code></td>
<td style="text-align:center;">**<code>DynamicType: F</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType></code></td>
<td style="text-align:center;">**<code>DynamicType</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D, E, F></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D, E></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D, F></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<E, F></code></td>
<td style="text-align:center;"><code>All<E, F></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<E></code></td>
<td style="text-align:center;"><code>E</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<F></code></td>
<td style="text-align:center;"><code>F</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
</tbody>
</table>
</li>
</ul></li>
</ol>
<p>Possible functions (just a few examples - solves rdar://problem/15873071 and <a href="https://openradar.appspot.com/20990743">rdar://20990743</a>):</p>
<pre><code class="swift">// with assumed generalized `class` and `AnyObject` typealias in mind
// current verion with unwanted `@objc` and possible bridging
func woo<T: AnyObject where T: SomeProtocol>(value: T)
// rewritten without generics to accept only classes that conform to `SomeProtocol`
func woo(value: All<AnyObject, SomeProtocol>)
// more specific example which accepts all subtypes of `UIView` that conform
// to `SomeProtocol` and one would drop generics here
func woo(value: All<UIView, SomeProtocol>)
</code></pre>
<h2 id="impactonexistingcode">Impact on existing code</h2>
<p>These changes will break existing code. Projects using old style <code>protocol<></code> mechanism will need to migrate to the new <code>All<></code> mechanism. The code using old style <code>protocol<></code> won’t compile until updated to the new conventions.</p>
<h2 id="alternativesconsidered">Alternatives considered</h2>
<p>This feature was orginally proposed as <code>type<></code> but was renamed to <code>All<></code> (idea provided by: <a href="https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160509/017397.html">Thorsten Seitz</a>) to dodge possible confusion and serve its main purpose to enforce multiple/<strong>all</strong> constraints. </p>
<p>This proposal was overall updated to include any possible overlap with <a href="https://github.com/apple/swift/blob/master/docs/GenericsManifesto.md">Generics Manifesto</a> for Swift 3. The reason the mechanism in this proposal is called <code>All<></code> instead of the suggested name <code>Any<></code> from the manifesto is to reserve that name for future usage explained in <strong>Future directions</strong> below.</p>
<p>The mechanism still could be named <code>Any<></code> and the described <code>Any<></code> in <strong>Future directions</strong> could be named <code>Either<></code>.</p>
<p>Any other rule changes for <code>All<></code> are not considered.</p>
<h2 id="futuredirections">Future directions</h2>
<ul>
<li>Generalize <code>class</code> constraints. This will create the possibility for <code>AnyObject</code> typealias.</li>
</ul>
<pre><code class="swift">typealias AnyObject = All<class> // @objc will be removed
// or
typealias ClassInstance = All<class>
// and ban confusion with old `AnyClass` vs. `AnyObject`
typealias ClassType = ClassInstance.Type
</code></pre>
<ul>
<li>Adding constraints for other extendable types like <code>struct</code> and <code>enum</code> and generalize these. This change will allo us to form more typealiases like:</li>
</ul>
<pre><code class="swift">typealias AnyStruct = All<struct>
typealias AnyEnum = All<enum>
// or
typealias StructInstance = All<struct>
typealias EnumInstance = All<enum>
// and
typealias StructType = StructInstance.Type
typealias EnumType = EnumInstance.Type
</code></pre>
<p>Possible functions (just a few more examples):</p>
<pre><code class="swift">// to start with we should remember that we are already to do some syntax
// magic with current`protocol<>`
protocol A { func zoo() }
// this is the base design that does not violate any rule
func boo(value: All<A>) { value.zoo() }
// this is the refined design that we all use today
func boo(value: A) { value.zoo() }
// we could constrain functions to accept only structs
// this might be seen as an enforcement to the library user to design a
// struct in this scenario
func foo(value: StructInstance)
// structs that conforms to a specific protocol (from our library?)
func foo(value: All<StructInstance, SomeProtocol>)
// one could use of ClassInstance and EnumInstance analogically
// generalized way with generics
func foo<T: struct where T: SomeProtocol>(value: T)
// or
func foo<T: StructInstance where T: SomeProtocol>(value: T)
// current only one verion for classes with unwanted `@objc` and possible bridging
func woo<T: AnyObject where T: SomeProtocol>(value: T)
// better alternative might look like
func woo<T: class where T: SomeProtocol>(value: T)
// or
func woo<T: ClassInstance where T: SomeProtocol>(value: T)
// `All<>` combine with generics
func woo<T: UIView>(value: All<T, SomeProtocol>)
// or simpler without generics
func woo(value: All<UIView, SomeProtocol>)
// non-generic approach to accept only reference-types which conforms to `SomeProtocol`
func zoo(value: All<ClassInstance, SomeProtocol>)
// or
func zoo(value: All<class, SomeProtocol>)
</code></pre>
<p>Possible scenarios:</p>
<pre><code class="swift">// constrainted to accept only structs
struct A<T: struct> {
var value: T
}
// or
struct A<T: StructInstance> {
var value: T
}
protocol SomeProtocol { /* implement something shiny */ }
// lets say this array is filled with structs, classes and enums that conforms to `SomeProtocol`
let array: [SomeProtocol] = // fill
// this would be new
var classArray: [SomeProtocol] = array.filter { $0 is All<class, SomeProtocol> }
var structArray: [SomeProtocol] = array.filter { $0 is All<struct, SomeProtocol> }
var enumArray: [SomeProtocol] = array.filter { $0 is All<enum, SomeProtocol> }
// we still would have to convert these types
</code></pre>
<p>Flattened operators or even <code>Type operators</code> for <code>All<></code>:</p>
<pre><code class="swift">class B {
var mainView: UIView & SomeProtocol
init(view: UIView & SomeProtocol) {
self. mainView = view
}
}
</code></pre>
<blockquote>
<p>The <code>&</code> type operator would produce a “flattened" <code>All<></code> with its operands. It could be overloaded to accept either a concrete type or a protocol on the lhs and would produce <code>Type</code> for an lhs that is a type and <code>all</code> when lhs is a protocol. <code>Type operators</code> would be evaluated during compile time and would produce a type that is used where the expression was present in the code. This is a long-term idea, not something that needs to be considered right now. </p>
<p>Written by: <a href="https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160509/017499.html">Matthew Johnson</a></p>
</blockquote>
<p>Adding <code>Any<></code> or <code>Either<></code> which can reduce overloading (idea provided by: <a href="https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160509/017397.html">Thorsten Seitz</a>). <code>Any<></code> or <code>Either<></code> will pick the first type match from angle brackets with the dynamic type at compile time and proceed. One would then need to handle the value by own desire.</p>
<pre><code class="swift">func foo(value: Any<String, Int>) {
if let v = value as? String {
// do some work
} else if let v = value as? Int {
// do some work
}
}
// flattened version for `Any<>` or `Either<>`
func foo(value: String | Int)
</code></pre>
<p>Mix different types like <code>All<></code> and <code>Any<></code>:</p>
<pre><code class="swift">// accept dynamic type constrained by
// (`ClassA` AND `SomeProtocol`) OR (`ClassB` AND `SomeProtocol`)
func foo(value: All<Any<ClassA, ClassB>, SomeProtocol>)
// flattened version
func foo(value: (ClassA | ClassB) & SomeProtocol)
</code></pre>
<p>Typealias <code>AnyValue</code> or <code>ValueInstance</code> (for extendable types only):</p>
<pre><code class="swift">typealias AnyValue = Any<All<struct>, All<enum>> // magic isn't it?
typealias AnyValue = Any<AnyStruct, AnyEnum>
// or
typealias ValueInstance = Any<All<struct>, All<enum>>
typealias ValueInstance = Any<StructInstance, EnumInstance>
// and
typealias ValueType = ValueInstance.Type
// flattened version
typealias AnyValue = All<struct> | All<enum>
typealias AnyValue = AnyStruct | AnyEnum
typealias ValueInstance = StructInstance | EnumInstance
// any value which conforms to `SomeProtocol`; reference types finally are out the way
func foo<T>(value: All<AnyValue, SomeProtocol>)
func foo<T>(value: All<ValueInstance, SomeProtocol>)
// flattened version
func foo<T>(value: AnyValue & SomeProtocol)
func foo<T>(value: ValueInstance & SomeProtocol)
</code></pre></div></div><div class="bloop_markdown"><p></p>
<h1 id="newmechanismtocombinetypeswithorprotocols">New mechanism to combine <code>Types</code> with/or <code>Protocols</code></h1>
<ul>
<li>Proposal: <a href="https://github.com/apple/swift-evolution/blob/master/proposals/NNNN-name.md">SE-NNNN</a></li>
<li>Author(s): <a href="https://github.com/DevAndArtist">Adrian Zubarev</a></li>
<li>Status: <a href="#rationale">Awaiting review</a></li>
<li>Review manager: TBD</li>
</ul>
<h2 id="introduction">Introduction</h2>
<p>The current <code>protocol<></code> mechanism defines the <code>Any</code> protocol to which all types implicitly conform. It also can combine distinct protocols to a new <code>Protocol</code>, whereas combinging <code>SubProtocol</code> with its <code>BaseProtocol</code> will be inferred as <code>SubProtocol</code> (the order withhin the angle brackets doesn’t matter). I propose to replace the current <code>protocol<></code> mechanism with a new more powerful mechanism called <code>All<></code>, which will allow combining <code>Types</code> with independent <code>Protocols</code> and enforce <strong>all</strong> constraints.</p>
<p>Swift-evolution thread: <a href="https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160502/016523.html">[Pitch] Merge <code>Types</code> and <code>Protocols</code> back together with <code>type<Type, Protocol, ...></code></a></p>
<h2 id="motivation">Motivation</h2>
<p>The motivation for this proposal comes from solving the missing <code>Type</code> issue (<a href="https://openradar.appspot.com/20990743">rdar://20990743</a>) and combining the idea mentioned in the generics manifesto for Swift 3 in section <a href="https://github.com/apple/swift/blob/master/docs/GenericsManifesto.md#renaming-protocol-to-any-">Renaming <code>protocol<...></code> to <code>Any<...></code></a>. </p>
<p>The proposed mechanism will allow us to create a new <code>Type</code> from extendable distinct types - there are still some restrinctions you can read about below.</p>
<h2 id="proposedsolution">Proposed solution</h2>
<p>First step to implement this proposal would need to rename <code>protocol<></code> to <code>All<></code> and configure the migration process to update code that used old style <code>protocol<></code>.</p>
<p>Next the <code>All<></code> mechanism would be extended to allow nesting and at most one <strong>extendable</strong> value or reference type. When all types within angle brackets are indepented/distinct to each other a new <code>Type</code> will be formed by <code>All<A, B, ...></code>. This new <code>Type</code> can be used to store instances that conform to <strong>all</strong> constrains defined by <code>All<></code> without any generic context (see <strong>Detailed design</strong> for more information).</p>
<p>Here only some subtype of <code>UIView</code> (dynamic type) conforms to <code>SomeProtocol</code>, but both types within angle brackets are distinct.</p>
<pre><code class="swift">protocol SomeProtocol {}
extension SomeProtocol {
func foo() { print("fooooo") }
}
// we'll be able to store the new type without generics
class A {
var view: All<UIView, SomeProtocol>
init(view: All<UIView, SomeProtocol>) {
self.view = view
}
// `dynamicType` of the `view` might be `UIButton` for example
// but we still be able to acces SomeProtocol which only UIButton conforms to
func doSomeWork() {
self.view.removeFromSuperview() // just for a simple example
self.view.foo() // prints "fooooo"
}
}
extension UIButton: SomeProtocol {}
let button: SomeProtocol = UIButton() // split types for the example
if let mergedValue = button as? All<UIView, SomeProtocol> {
let a = A(view: mergedValue)
a.doSomeWork()
}
</code></pre>
<h2 id="detaileddesign">Detailed design</h2>
<h4 id="rulesforall:">Rules for <code>All<></code>:</h4>
<ol>
<li><p>Empty <code>All<></code> will be used as <code>typealias Any = All<></code>. No constraints means it can accept any type or simply that all types implicitly conform to empty <code>All<></code>. This is the logical replacement for <code>typealias Any = protocol<></code>.</p></li>
<li><p>The order of <code>Types</code> within angle brackets doesn’t matter: <code>All<A, B> == All<B, A></code>. (The compiler already reorders the types by its own will from <code>protocol<B, A></code> to <code>protocol<A, B></code>.)</p></li>
<li><p><code>All<></code> can be composed from protocols and by the mention of this rule fully replace <code>protocol<...></code> </p>
<ul>
<li><code>All<ProtocolA, ...></code> equals to old <code>protocol<ProtocolA, ...></code></li>
<li><code>All<ProtocolX></code> equals to old <code>protocol<ProtocolX></code> or simply inferred as <code>ProtocolX</code></li>
</ul></li>
<li><p><code>All<></code> can contain at most one <u>extendable</u> value or reference type plus none or n protocols.</p>
<ul>
<li><code>All<ReferenceType></code> or <code>All<ReferenceType, Protocol, ...></code></li>
<li><code>All<ValueType></code> or <code>All<ValueType, Protocol, ...></code></li>
<li>This rule will disallow <code>All<></code> to contain unnecessary inheritance type branches from subtypeable types.</li>
<li>Furthermore will this rule ban confusion when using <code>All<T, U></code> in a generic context.</li>
</ul></li>
<li><p>Subtypeable <code>Type</code> from within angle brackets of <code>All<></code> can be seen as the base type of the dynamic type.</p></li>
<li><p>Nesting <code>All<></code> is allowed under special rules:</p>
<ul>
<li><code>A: All<></code> can contain <code>B: All<></code> if <code>B</code> is composed from protocols:
<ul>
<li>e.g. <code>All<AnyType, All<ProtocolA, ProtocolB, ...>></code> will be inferred as <code>All<AnyType, ProtocolA, ProtocolB, ...></code></li>
</ul></li>
<li>For subtypeable types <code>A: All<></code> can contain <code>B: All<></code> if <code>B</code> is composed from a possible base type of <code>A</code> and none or n protocols:
<ul>
<li>e.g. <code>A = All<All<C, Protocol>, SomeProtocol></code> where <code>B = All<C, Protocol></code> and <code>C</code> is some base <code>Type</code> of <code>A</code> which implies to <code>A = All<C, Protocol, SomeProtocol></code></li>
<li>Again nesting the inheritance type branch is not allowed, because of rule #4.</li>
</ul></li>
</ul></li>
<li><p>All types should be checked againts each other to find a simplified <code>Type</code>. At the end all type dependencies should be distinct and will form a new constrained type. These constraints are then tested against the dynamic type.</p>
<pre><code class="swift">protocol X {} protocol Y: X {}
class A: X {} class B: Y {}
All<A, X, Y> /* inferred as */ All<A, Y>
// e.g. will the above type accept `B` but not `A` as long `A` doesn't conform to `Y`
All<B, X, Y> /* inferred as */ All<B> /* or simply just */ B
</code></pre></li>
<li><p><code>All<></code> can be an optional type <code>All<>?</code> or <code>All<>!</code></p></li>
</ol>
<h4 id="detaileddesignforallbelowtypeisanextendabletype:">Detailed design for <code>All<></code> (below <code>type</code> is an extendable type):</h4>
<ol>
<li><p><code>type A</code> can be applied to <code>All<A> == A</code>, <code>All<Any> == Any == All<></code> or <code>All<GenericType> == GenericType</code></p></li>
<li><code>type B: C</code>:
<ul>
<li><p><code>class B: ProtocolC</code> can be applied to:</p>
<table>
<colgroup>
<col style="text-align:left;">
<col style="text-align:center;">
</colgroup>
<thead>
<tr>
<th style="text-align:left;">Type</th>
<th style="text-align:center;">Equivalent inferred <code>Type</code> (** generic)</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:left;"><code>All<ProtocolC></code></td>
<td style="text-align:center;"><code>ProtocolC</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any, ProtocolC></code></td>
<td style="text-align:center;"><code>ProtocolC</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any></code></td>
<td style="text-align:center;"><code>Any</code> or <code>All<></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType, ProtocolC></code></td>
<td style="text-align:center;">**<code>DynamicType: ProtocolC</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType></code></td>
<td style="text-align:center;">**<code>DynamicType</code> </td>
</tr>
<tr>
<td style="text-align:left;"><code>All<B, ProtocolC></code></td>
<td style="text-align:center;"><code>B</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<B></code></td>
<td style="text-align:center;"><code>B</code></td>
</tr>
</tbody>
</table>
</li>
<li><p><code>class B: ClassC</code> can be applied to:</p>
<ul>
<li>One would not want to combine <code>All<ClassC, B></code> even in a generic context like <code>All<T, U></code> for example to union one value of <code>B</code> and another value of <code>ClassC</code>, because followed by rule #2 the compiler will reoder the types to <code>All<B, ClassC></code> and infer that as <code>B</code>. <code>B</code> can not hold <code>ClassC</code>. This implies that <code>All<></code> does not intersect types and the need of rule #4.</li>
</ul>
<table>
<colgroup>
<col style="text-align:left;">
<col style="text-align:center;">
</colgroup>
<thead>
<tr>
<th style="text-align:left;">Type</th>
<th style="text-align:center;">Equivalent inferred <code>Type</code> (** generic)</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:left;"><code>All<ClassC></code></td>
<td style="text-align:center;"><code>ClassC</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<B></code></td>
<td style="text-align:center;"><code>B</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType></code></td>
<td style="text-align:center;">**<code>DynamicType</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any></code></td>
<td style="text-align:center;"><code>Any</code> or <code>All<></code></td>
</tr>
</tbody>
</table>
</li>
<li><p><code>struct B: ProtocolC</code> is analogous to <code>class B: ProtocolC</code>.</p></li>
<li><p><code>enum B: ProtocolC</code> is analogous to <code>struct B: ProtocolC</code>.</p></li>
<li><p><code>protocol B: C</code> can be applied to:</p>
<table>
<colgroup>
<col style="text-align:left;">
<col style="text-align:center;">
</colgroup>
<thead>
<tr>
<th style="text-align:left;">Type</th>
<th style="text-align:center;">Equivalent inferred <code>Type</code> (** generic)</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:left;"><code>All<Any, B></code></td>
<td style="text-align:center;"><code>B</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any, C></code></td>
<td style="text-align:center;"><code>C</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any></code></td>
<td style="text-align:center;"><code>Any</code> or <code>All<></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType, B></code></td>
<td style="text-align:center;">**<code>DynamicType: B</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType, C></code></td>
<td style="text-align:center;">**<code>DynamicType: C</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType></code></td>
<td style="text-align:center;">**<code>DynamicType</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<B, C></code></td>
<td style="text-align:center;"><code>B</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<B></code></td>
<td style="text-align:center;"><code>B</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<C></code></td>
<td style="text-align:center;"><code>C</code></td>
</tr>
</tbody>
</table>
</li>
</ul></li>
<li><code>type B</code> distinct to <code>C</code>:
<ul>
<li>The following points will produce a new <code>Type</code>:
<ul>
<li><code>class B</code> and <code>protocol C</code> can be combined to <code>All<B, C></code>.</li>
<li><code>struct B</code> and <code>protocol C</code> can be combined to <code>All<B, C></code>.</li>
<li><code>enum B</code> and <code>protocol C</code> can be combined to <code>All<B, C></code>.</li>
<li><code>protocol B</code> and <code>protocol C</code> can be combined to <code>All<B, C></code>.</li>
</ul></li>
<li>The following points should all raise an compilation error:
<ul>
<li><code>class B</code> and <code>class C</code> can NOT be combined.</li>
<li><code>struct B</code> and <code>struct C</code> can NOT be combined.</li>
<li><code>enum B</code> and <code>enum C</code> can NOT be combined.</li>
</ul></li>
</ul></li>
<li><code>type D: E, F</code> where <code>E</code> doesn’t conform to <code>F</code>:
<ul>
<li><p><code>class D: ClassE, ProtocolF</code> type can be applied to:</p>
<table>
<colgroup>
<col style="text-align:left;">
<col style="text-align:center;">
</colgroup>
<thead>
<tr>
<th style="text-align:left;">Type</th>
<th style="text-align:center;">Equivalent inferred <code>Type</code> (** generic)</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:left;"><code>All<ProtocolF></code></td>
<td style="text-align:center;"><code>ProtocolF</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any, ProtocolF></code></td>
<td style="text-align:center;"><code>ProtocolF</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any></code></td>
<td style="text-align:center;"><code>Any</code> or <code>All<></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType, ProtocolF></code></td>
<td style="text-align:center;">**<code>DynamicType: ProtocolF</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType></code></td>
<td style="text-align:center;">**<code>DynamicType</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D, ProtocolF></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<ClassE, ProtocolF></code></td>
<td style="text-align:center;"><strong>NEW:</strong> <code>All<ClassE, ProtocolF></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<ClassE></code></td>
<td style="text-align:center;"><code>ClassE</code></td>
</tr>
</tbody>
</table>
</li>
<li><p><code>class D: ProtocolE, ProtocolF</code> type can be applied to:</p>
<table>
<colgroup>
<col style="text-align:left;">
<col style="text-align:center;">
</colgroup>
<thead>
<tr>
<th style="text-align:left;">Type</th>
<th style="text-align:center;">Equivalent inferred <code>Type</code> (** generic)</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:left;"><code>All<ProtocolE, ProtocolF></code></td>
<td style="text-align:center;"><code>All<ProtocolE, ProtocolF></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<ProtocolE></code></td>
<td style="text-align:center;"><code>ProtocolE</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<ProtocolF></code></td>
<td style="text-align:center;"><code>ProtocolF</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any, ProtocolE, ProtocolF></code></td>
<td style="text-align:center;"><code>All<ProtocolE, ProtocolF></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any, ProtocolE></code></td>
<td style="text-align:center;"><code>ProtocolE</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any, ProtocolF></code></td>
<td style="text-align:center;"><code>ProtocolF</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<Any></code></td>
<td style="text-align:center;"><code>Any</code> or <code>All<></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType, ProtocolE, ProtocolF></code></td>
<td style="text-align:center;">**<code>DynamicType: All<ProtocolE, ProtocolF></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType, ProtocolE></code></td>
<td style="text-align:center;">**<code>DynamicType: ProtocolE</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType, ProtocolF></code></td>
<td style="text-align:center;">**<code>DynamicType: ProtocolF</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType></code></td>
<td style="text-align:center;">**<code>DynamicType</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D, ProtocolE, ProtocolF></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D, ProtocolE></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D, ProtocolF></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
</tbody>
</table>
</li>
<li><p><code>struct D: ProtocolE, ProtocolF</code> is analogous to <code>class D: ProtocolE, ProtocolF</code>.</p></li>
<li><p><code>enum D: ProtocolE, ProtocolF</code> is analogous to <code>struct D: ProtocolE, ProtocolF</code>.</p></li>
<li><p><code>protocol D: E, F</code> type can be applied to:</p>
<table>
<colgroup>
<col style="text-align:left;">
<col style="text-align:center;">
</colgroup>
<thead>
<tr>
<th style="text-align:left;">Type</th>
<th style="text-align:center;">Equivalent inferred <code>Type</code> (** generic)</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:left;"><code>All<GenericType, E, F></code></td>
<td style="text-align:center;">**<code>DynamicType: All<E, F></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType, E></code></td>
<td style="text-align:center;">**<code>DynamicType: E</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType, F></code></td>
<td style="text-align:center;">**<code>DynamicType: F</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<GenericType></code></td>
<td style="text-align:center;">**<code>DynamicType</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D, E, F></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D, E></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D, F></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<E, F></code></td>
<td style="text-align:center;"><code>All<E, F></code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<E></code></td>
<td style="text-align:center;"><code>E</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<F></code></td>
<td style="text-align:center;"><code>F</code></td>
</tr>
<tr>
<td style="text-align:left;"><code>All<D></code></td>
<td style="text-align:center;"><code>D</code></td>
</tr>
</tbody>
</table>
</li>
</ul></li>
</ol>
<p>Possible functions (just a few examples - solves rdar://problem/15873071 and <a href="https://openradar.appspot.com/20990743">rdar://20990743</a>):</p>
<pre><code class="swift">// with assumed generalized `class` and `AnyObject` typealias in mind
// current verion with unwanted `@objc` and possible bridging
func woo<T: AnyObject where T: SomeProtocol>(value: T)
// rewritten without generics to accept only classes that conform to `SomeProtocol`
func woo(value: All<AnyObject, SomeProtocol>)
// more specific example which accepts all subtypes of `UIView` that conform
// to `SomeProtocol` and one would drop generics here
func woo(value: All<UIView, SomeProtocol>)
</code></pre>
<h2 id="impactonexistingcode">Impact on existing code</h2>
<p>These changes will break existing code. Projects using old style <code>protocol<></code> mechanism will need to migrate to the new <code>All<></code> mechanism. The code using old style <code>protocol<></code> won’t compile until updated to the new conventions.</p>
<h2 id="alternativesconsidered">Alternatives considered</h2>
<p>This feature was orginally proposed as <code>type<></code> but was renamed to <code>All<></code> (idea provided by: <a href="https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160509/017397.html">Thorsten Seitz</a>) to dodge possible confusion and serve its main purpose to enforce multiple/<strong>all</strong> constraints. </p>
<p>This proposal was overall updated to include any possible overlap with <a href="https://github.com/apple/swift/blob/master/docs/GenericsManifesto.md">Generics Manifesto</a> for Swift 3. The reason the mechanism in this proposal is called <code>All<></code> instead of the suggested name <code>Any<></code> from the manifesto is to reserve that name for future usage explained in <strong>Future directions</strong> below.</p>
<p>The mechanism still could be named <code>Any<></code> and the described <code>Any<></code> in <strong>Future directions</strong> could be named <code>Either<></code>.</p>
<p>Any other rule changes for <code>All<></code> are not considered.</p>
<h2 id="futuredirections">Future directions</h2>
<ul>
<li>Generalize <code>class</code> constraints. This will create the possibility for <code>AnyObject</code> typealias.</li>
</ul>
<pre><code class="swift">typealias AnyObject = All<class> // @objc will be removed
// or
typealias ClassInstance = All<class>
// and ban confusion with old `AnyClass` vs. `AnyObject`
typealias ClassType = ClassInstance.Type
</code></pre>
<ul>
<li>Adding constraints for other extendable types like <code>struct</code> and <code>enum</code> and generalize these. This change will allo us to form more typealiases like:</li>
</ul>
<pre><code class="swift">typealias AnyStruct = All<struct>
typealias AnyEnum = All<enum>
// or
typealias StructInstance = All<struct>
typealias EnumInstance = All<enum>
// and
typealias StructType = StructInstance.Type
typealias EnumType = EnumInstance.Type
</code></pre>
<p>Possible functions (just a few more examples):</p>
<pre><code class="swift">// to start with we should remember that we are already to do some syntax
// magic with current`protocol<>`
protocol A { func zoo() }
// this is the base design that does not violate any rule
func boo(value: All<A>) { value.zoo() }
// this is the refined design that we all use today
func boo(value: A) { value.zoo() }
// we could constrain functions to accept only structs
// this might be seen as an enforcement to the library user to design a
// struct in this scenario
func foo(value: StructInstance)
// structs that conforms to a specific protocol (from our library?)
func foo(value: All<StructInstance, SomeProtocol>)
// one could use of ClassInstance and EnumInstance analogically
// generalized way with generics
func foo<T: struct where T: SomeProtocol>(value: T)
// or
func foo<T: StructInstance where T: SomeProtocol>(value: T)
// current only one verion for classes with unwanted `@objc` and possible bridging
func woo<T: AnyObject where T: SomeProtocol>(value: T)
// better alternative might look like
func woo<T: class where T: SomeProtocol>(value: T)
// or
func woo<T: ClassInstance where T: SomeProtocol>(value: T)
// `All<>` combine with generics
func woo<T: UIView>(value: All<T, SomeProtocol>)
// or simpler without generics
func woo(value: All<UIView, SomeProtocol>)
// non-generic approach to accept only reference-types which conforms to `SomeProtocol`
func zoo(value: All<ClassInstance, SomeProtocol>)
// or
func zoo(value: All<class, SomeProtocol>)
</code></pre>
<p>Possible scenarios:</p>
<pre><code class="swift">// constrainted to accept only structs
struct A<T: struct> {
var value: T
}
// or
struct A<T: StructInstance> {
var value: T
}
protocol SomeProtocol { /* implement something shiny */ }
// lets say this array is filled with structs, classes and enums that conforms to `SomeProtocol`
let array: [SomeProtocol] = // fill
// this would be new
var classArray: [SomeProtocol] = array.filter { $0 is All<class, SomeProtocol> }
var structArray: [SomeProtocol] = array.filter { $0 is All<struct, SomeProtocol> }
var enumArray: [SomeProtocol] = array.filter { $0 is All<enum, SomeProtocol> }
// we still would have to convert these types
</code></pre>
<p>Flattened operators or even <code>Type operators</code> for <code>All<></code>:</p>
<pre><code class="swift">class B {
var mainView: UIView & SomeProtocol
init(view: UIView & SomeProtocol) {
self. mainView = view
}
}
</code></pre>
<blockquote>
<p>The <code>&</code> type operator would produce a “flattened" <code>All<></code> with its operands. It could be overloaded to accept either a concrete type or a protocol on the lhs and would produce <code>Type</code> for an lhs that is a type and <code>all</code> when lhs is a protocol. <code>Type operators</code> would be evaluated during compile time and would produce a type that is used where the expression was present in the code. This is a long-term idea, not something that needs to be considered right now. </p>
<p>Written by: <a href="https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160509/017499.html">Matthew Johnson</a></p>
</blockquote>
<p>Adding <code>Any<></code> or <code>Either<></code> which can reduce overloading (idea provided by: <a href="https://lists.swift.org/pipermail/swift-evolution/Week-of-Mon-20160509/017397.html">Thorsten Seitz</a>). <code>Any<></code> or <code>Either<></code> will pick the first type match from angle brackets with the dynamic type at compile time and proceed. One would then need to handle the value by own desire.</p>
<pre><code class="swift">func foo(value: Any<String, Int>) {
if let v = value as? String {
// do some work
} else if let v = value as? Int {
// do some work
}
}
// flattened version for `Any<>` or `Either<>`
func foo(value: String | Int)
</code></pre>
<p>Mix different types like <code>All<></code> and <code>Any<></code>:</p>
<pre><code class="swift">// accept dynamic type constrained by
// (`ClassA` AND `SomeProtocol`) OR (`ClassB` AND `SomeProtocol`)
func foo(value: All<Any<ClassA, ClassB>, SomeProtocol>)
// flattened version
func foo(value: (ClassA | ClassB) & SomeProtocol)
</code></pre>
<p>Typealias <code>AnyValue</code> or <code>ValueInstance</code> (for extendable types only):</p>
<pre><code class="swift">typealias AnyValue = Any<All<struct>, All<enum>> // magic isn't it?
typealias AnyValue = Any<AnyStruct, AnyEnum>
// or
typealias ValueInstance = Any<All<struct>, All<enum>>
typealias ValueInstance = Any<StructInstance, EnumInstance>
// and
typealias ValueType = ValueInstance.Type
// flattened version
typealias AnyValue = All<struct> | All<enum>
typealias AnyValue = AnyStruct | AnyEnum
typealias ValueInstance = StructInstance | EnumInstance
// any value which conforms to `SomeProtocol`; reference types finally are out the way
func foo<T>(value: All<AnyValue, SomeProtocol>)
func foo<T>(value: All<ValueInstance, SomeProtocol>)
// flattened version
func foo<T>(value: AnyValue & SomeProtocol)
func foo<T>(value: ValueInstance & SomeProtocol)
</code></pre></div></body></html>