diff options
Diffstat (limited to 'api/dotty/tools/dotc/core/Types$/Type.html')
| -rw-r--r-- | api/dotty/tools/dotc/core/Types$/Type.html | 3593 |
1 files changed, 3401 insertions, 192 deletions
diff --git a/api/dotty/tools/dotc/core/Types$/Type.html b/api/dotty/tools/dotc/core/Types$/Type.html index 9d36c1b16..dab15d242 100644 --- a/api/dotty/tools/dotc/core/Types$/Type.html +++ b/api/dotty/tools/dotc/core/Types$/Type.html @@ -5321,6 +5321,9 @@ <div id="entity-container"> <div id="entity-title"> + <span id="entity-annotations"> + + </span> <span id="entity-modifiers"> abstract </span> @@ -5330,6 +5333,27 @@ <span id="entity-name"> Type </span> + + + <div id="super-types"> + + + <span class="keyword">extends</span> + + <span class="entity-super-type">DotClass</span> + + + <span class="keyword">with</span> + + <span class="entity-super-type">Hashable</span> + + + <span class="keyword">with</span> + + <span class="entity-super-type">Showable</span> + + </div> + </div> @@ -5372,12 +5396,71 @@ </div> - <h1 class="section ">Members</h1> + <h1 class="section "> + Constructors + </h1> + + <div id="entity-constructors" class="entity-section "> + + + <div class="member"> + <div class="member-title"> + <span class="member-name">Type</span> + <span class="no-left">(</span> + + + <span class="no-left">)</span> + </div> + </div> + + + + <div class="member"> + <div class="member-title"> + <span class="member-name">Type</span> + <span class="no-left">(</span> + + + <span class="no-left"> + self: + </span> + Type + + + <span class="no-left">)</span> + </div> + </div> + + + + <div class="member"> + <div class="member-title"> + <span class="member-name">Type</span> + <span class="no-left">(</span> + + + <span class="no-left"> + self: + </span> + Type + + + <span class="no-left">)</span> + </div> + </div> + + + </div> + + <h1 class="section "> + Members + </h1> <div id="entity-members" class="entity-section "> <div id="uniqId" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'uniqId');">[+]</span> <span class="member-annotations"> </span> @@ -5403,12 +5486,29 @@ </div><!-- end member-title --> <div class="member-body"> - + <div class="member-body-short" id="short-body-uniqId"> + + </div> + <div class="member-body-long" id ="long-body-uniqId"> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="&(that)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, '&(that)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -5460,12 +5560,29 @@ </div><!-- end member-title --> <div class="member-body"> - + <div class="member-body-short" id="short-body-&(that)(ctx)"> + + </div> + <div class="member-body-long" id ="long-body-&(that)(ctx)"> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="<:<(that)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, '<:<(that)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -5517,13 +5634,31 @@ </div><!-- end member-title --> <div class="member-body"> - <p>Is this type a subtype of that type?</p> + <div class="member-body-short" id="short-body-<:<(that)(ctx)"> + <p>Is this type a subtype of that type?</p> + </div> + <div class="member-body-long" id ="long-body-<:<(that)(ctx)"> + <p>Is this type a subtype of that type?</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="=:=(that)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, '=:=(that)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -5575,14 +5710,33 @@ </div><!-- end member-title --> <div class="member-body"> - <p>Is this type the same as that type? + <div class="member-body-short" id="short-body-=:=(that)(ctx)"> + <p>Is this type the same as that type? +This is the case iff <code>this <:< that</code> and <code>that <:< this</code>.</p> + + </div> + <div class="member-body-long" id ="long-body-=:=(that)(ctx)"> + <p>Is this type the same as that type? This is the case iff <code>this <:< that</code> and <code>that <:< this</code>.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="EtaExpand(tparams)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'EtaExpand(tparams)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -5637,17 +5791,41 @@ TypeSymbol </div><!-- end member-title --> <div class="member-body"> - <p>Convert a type constructor <code>TC</code> which has type parameters <code>T1, ..., Tn</code> + <div class="member-body-short" id="short-body-EtaExpand(tparams)(ctx)"> + <p>Convert a type constructor <code>TC</code> which has type parameters <code>T1, ..., Tn</code> in a context where type parameters <code>U1,...,Un</code> are expected to</p> <p>LambdaXYZ { Apply = TCh...</p> <p> </p> + </div> + <div class="member-body-long" id ="long-body-EtaExpand(tparams)(ctx)"> + <p>Convert a type constructor <code>TC</code> which has type parameters <code>T1, ..., Tn</code> +in a context where type parameters <code>U1,...,Un</code> are expected to</p> +<p>LambdaXYZ { Apply = TC[hk$0, ..., hk$n] }</p> +<p>Here, XYZ corresponds to the variances of +- <code>U1,...,Un</code> if the variances of <code>T1,...,Tn</code> are pairwise compatible with <code>U1,...,Un</code>, +- <code>T1,...,Tn</code> otherwise. +v1 is compatible with v2, if v1 = v2 or v2 is non-variant.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="EtaExpandIfHK(bound)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'EtaExpandIfHK(bound)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -5699,13 +5877,31 @@ in a context where type parameters <code>U1,...,Un</code> are expected to</p> </div><!-- end member-title --> <div class="member-body"> - <p>Eta expand if <code>self</code> is a (non-lambda) class reference and <code>bound</code> is a higher-kinded type</p> + <div class="member-body-short" id="short-body-EtaExpandIfHK(bound)(ctx)"> + <p>Eta expand if <code>self</code> is a (non-lambda) class reference and <code>bound</code> is a higher-kinded type</p> + </div> + <div class="member-body-long" id ="long-body-EtaExpandIfHK(bound)(ctx)"> + <p>Eta expand if <code>self</code> is a (non-lambda) class reference and <code>bound</code> is a higher-kinded type</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="LambdaAbstract(tparams)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'LambdaAbstract(tparams)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -5760,17 +5956,39 @@ TypeParamInfo </div><!-- end member-title --> <div class="member-body"> - <p>Lambda abstract <code>self</code> with given type parameters. Examples:</p> + <div class="member-body-short" id="short-body-LambdaAbstract(tparams)(ctx)"> + <p>Lambda abstract <code>self</code> with given type parameters. Examples:</p> +<pre><code>type T[X] = U becomes type T = [X] -> U +type T[X] >: L <: U becomes type T >: L <: ([X] -> U) +</code></pre> +<p>TODO: Handle parameterized lower bounds</p> + + </div> + <div class="member-body-long" id ="long-body-LambdaAbstract(tparams)(ctx)"> + <p>Lambda abstract <code>self</code> with given type parameters. Examples:</p> <pre><code>type T[X] = U becomes type T = [X] -> U type T[X] >: L <: U becomes type T >: L <: ([X] -> U) </code></pre> <p>TODO: Handle parameterized lower bounds</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="abstractTermMembers(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'abstractTermMembers(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -5806,18 +6024,39 @@ type T[X] >: L <: U becomes type T >: L <: ([X] -> U) - <span class="no-left">: Seq</span> + <span class="no-left">: Seq +<span class="no-left no-right">[</span> +SingleDenotation +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The set of abstract term members of this type.</p> + <div class="member-body-short" id="short-body-abstractTermMembers(ctx)"> + <p>The set of abstract term members of this type.</p> + </div> + <div class="member-body-long" id ="long-body-abstractTermMembers(ctx)"> + <p>The set of abstract term members of this type.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="abstractTypeMembers(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'abstractTypeMembers(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -5853,18 +6092,39 @@ type T[X] >: L <: U becomes type T >: L <: ([X] -> U) - <span class="no-left">: Seq</span> + <span class="no-left">: Seq +<span class="no-left no-right">[</span> +SingleDenotation +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The set of abstract type members of this type.</p> + <div class="member-body-short" id="short-body-abstractTypeMembers(ctx)"> + <p>The set of abstract type members of this type.</p> + + </div> + <div class="member-body-long" id ="long-body-abstractTypeMembers(ctx)"> + <p>The set of abstract type members of this type.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="adaptHkVariances(bound)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'adaptHkVariances(bound)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -5916,7 +6176,8 @@ type T[X] >: L <: U becomes type T >: L <: ([X] -> U) </div><!-- end member-title --> <div class="member-body"> - <p>If argument A and type parameter P are higher-kinded, adapt the variances + <div class="member-body-short" id="short-body-adaptHkVariances(bound)(ctx)"> + <p>If argument A and type parameter P are higher-kinded, adapt the variances of A to those of P, ensuring that the variances of the type lambda A agree wit...</p> <p>[X] @@ -5935,11 +6196,48 @@ agree wit...</p> <p> </p> + </div> + <div class="member-body-long" id ="long-body-adaptHkVariances(bound)(ctx)"> + <p>If argument A and type parameter P are higher-kinded, adapt the variances +of A to those of P, ensuring that the variances of the type lambda A +agree with the variances of corresponding higher-kinded type parameters of P. Example:</p> +<p>class GenericCompanion[+CC[X]] +GenericCompanion[List]</p> +<p>with adaptHkVariances, the argument <code>List</code> will expand to</p> +<p>[X] => List[X]</p> +<p>instead of</p> +<p>[+X] => List[X]</p> +<p>even though <code>List</code> is covariant. This adaptation is necessary to ignore conflicting +variances in overriding members that have types of hk-type parameters such as +<code>GenericCompanion[GenTraversable]</code> or <code>GenericCompanion[ListBuffer]</code>. +When checking overriding, we need to validate the subtype relationship</p> +<pre><code>GenericCompanion[[X] -> ListBuffer[X]] <: GenericCompanion[[+X] -> GenTraversable[X]] +</code></pre> +<p>Without adaptation, this would be false, and hence an overriding error would +result. But with adaptation, the rhs argument will be adapted to</p> +<p>[X] -> GenTraversable[X]</p> +<p>which makes the subtype test succeed. The crucial point here is that, since +GenericCompanion only expects a non-variant CC, the fact that GenTraversable +is covariant is irrelevant, so can be ignored.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="appliedTo(arg1,arg2)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'appliedTo(arg1,arg2)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -5999,12 +6297,29 @@ agree wit...</p> </div><!-- end member-title --> <div class="member-body"> - + <div class="member-body-short" id="short-body-appliedTo(arg1,arg2)(ctx)"> + + </div> + <div class="member-body-long" id ="long-body-appliedTo(arg1,arg2)(ctx)"> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="appliedTo(args)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'appliedTo(args)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -6059,15 +6374,35 @@ Type </div><!-- end member-title --> <div class="member-body"> - <p>The type representing</p> + <div class="member-body-short" id="short-body-appliedTo(args)(ctx)"> + <p>The type representing</p> <p>T[U1, ..., Un]</p> <p>where</p> + </div> + <div class="member-body-long" id ="long-body-appliedTo(args)(ctx)"> + <p>The type representing</p> +<p>T[U1, ..., Un]</p> +<p>where</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="appliedTo(arg)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'appliedTo(arg)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -6119,12 +6454,29 @@ Type </div><!-- end member-title --> <div class="member-body"> - + <div class="member-body-short" id="short-body-appliedTo(arg)(ctx)"> + + </div> + <div class="member-body-long" id ="long-body-appliedTo(arg)(ctx)"> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="applyIfParameterized(args)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'applyIfParameterized(args)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -6179,12 +6531,29 @@ Type </div><!-- end member-title --> <div class="member-body"> - + <div class="member-body-short" id="short-body-applyIfParameterized(args)(ctx)"> + + </div> + <div class="member-body-long" id ="long-body-applyIfParameterized(args)(ctx)"> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="argInfo(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'argInfo(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -6225,14 +6594,33 @@ Type </div><!-- end member-title --> <div class="member-body"> - <p>If this is the image of a type argument; recover the type argument, + <div class="member-body-short" id="short-body-argInfo(ctx)"> + <p>If this is the image of a type argument; recover the type argument, otherwise NoType.</p> + </div> + <div class="member-body-long" id ="long-body-argInfo(ctx)"> + <p>If this is the image of a type argument; recover the type argument, +otherwise NoType.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="argInfos(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'argInfos(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -6268,20 +6656,43 @@ otherwise NoType.</p> - <span class="no-left">: List</span> + <span class="no-left">: List +<span class="no-left no-right">[</span> +Type +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>If this is an encoding of a (partially) applied type, return its arguments, + <div class="member-body-short" id="short-body-argInfos(ctx)"> + <p>If this is an encoding of a (partially) applied type, return its arguments, otherwise return Nil. Existential types in arguments are returned as TypeBou...</p> + </div> + <div class="member-body-long" id ="long-body-argInfos(ctx)"> + <p>If this is an encoding of a (partially) applied type, return its arguments, +otherwise return Nil. +Existential types in arguments are returned as TypeBounds instances.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="argTypes(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'argTypes(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -6317,18 +6728,39 @@ Existential types in arguments are returned as TypeBou...</p> - <span class="no-left">: List</span> + <span class="no-left">: List +<span class="no-left no-right">[</span> +Type +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>Argument types where existential types in arguments are disallowed</p> + <div class="member-body-short" id="short-body-argTypes(ctx)"> + <p>Argument types where existential types in arguments are disallowed</p> + </div> + <div class="member-body-long" id ="long-body-argTypes(ctx)"> + <p>Argument types where existential types in arguments are disallowed</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="argTypesHi(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'argTypesHi(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -6364,18 +6796,39 @@ Existential types in arguments are returned as TypeBou...</p> - <span class="no-left">: List</span> + <span class="no-left">: List +<span class="no-left no-right">[</span> +Type +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>Argument types where existential types in arguments are approximated by their upper bound</p> + <div class="member-body-short" id="short-body-argTypesHi(ctx)"> + <p>Argument types where existential types in arguments are approximated by their upper bound</p> + + </div> + <div class="member-body-long" id ="long-body-argTypesHi(ctx)"> + <p>Argument types where existential types in arguments are approximated by their upper bound</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="argTypesLo(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'argTypesLo(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -6411,18 +6864,39 @@ Existential types in arguments are returned as TypeBou...</p> - <span class="no-left">: List</span> + <span class="no-left">: List +<span class="no-left no-right">[</span> +Type +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>Argument types where existential types in arguments are approximated by their lower bound</p> + <div class="member-body-short" id="short-body-argTypesLo(ctx)"> + <p>Argument types where existential types in arguments are approximated by their lower bound</p> + + </div> + <div class="member-body-long" id ="long-body-argTypesLo(ctx)"> + <p>Argument types where existential types in arguments are approximated by their lower bound</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="asSeenFrom(pre,cls)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'asSeenFrom(pre,cls)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -6482,14 +6956,33 @@ Existential types in arguments are returned as TypeBou...</p> </div><!-- end member-title --> <div class="member-body"> - <p>This type seen as if it were the type of a member of prefix type <code>pre</code> + <div class="member-body-short" id="short-body-asSeenFrom(pre,cls)(ctx)"> + <p>This type seen as if it were the type of a member of prefix type <code>pre</code> declared in class <code>cls</code>.</p> + </div> + <div class="member-body-long" id ="long-body-asSeenFrom(pre,cls)(ctx)"> + <p>This type seen as if it were the type of a member of prefix type <code>pre</code> +declared in class <code>cls</code>.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="baseArgInfos(base)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'baseArgInfos(base)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -6536,19 +7029,41 @@ declared in class <code>cls</code>.</p> - <span class="no-left">: List</span> + <span class="no-left">: List +<span class="no-left no-right">[</span> +Type +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The type arguments of this type's base type instance wrt. <code>base</code>. + <div class="member-body-short" id="short-body-baseArgInfos(base)(ctx)"> + <p>The type arguments of this type's base type instance wrt. <code>base</code>. Existential types in arguments are returned as TypeBounds instances.</p> + </div> + <div class="member-body-long" id ="long-body-baseArgInfos(base)(ctx)"> + <p>The type arguments of this type's base type instance wrt. <code>base</code>. +Existential types in arguments are returned as TypeBounds instances.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="baseArgTypes(base)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'baseArgTypes(base)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -6595,19 +7110,41 @@ Existential types in arguments are returned as TypeBounds instances.</p> - <span class="no-left">: List</span> + <span class="no-left">: List +<span class="no-left no-right">[</span> +Type +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The type arguments of this type's base type instance wrt.<code>base</code>. + <div class="member-body-short" id="short-body-baseArgTypes(base)(ctx)"> + <p>The type arguments of this type's base type instance wrt.<code>base</code>. Existential types in arguments are disallowed.</p> + </div> + <div class="member-body-long" id ="long-body-baseArgTypes(base)(ctx)"> + <p>The type arguments of this type's base type instance wrt.<code>base</code>. +Existential types in arguments are disallowed.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="baseArgTypesHi(base)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'baseArgTypesHi(base)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -6654,19 +7191,41 @@ Existential types in arguments are disallowed.</p> - <span class="no-left">: List</span> + <span class="no-left">: List +<span class="no-left no-right">[</span> +Type +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The type arguments of this type's base type instance wrt.<code>base</code>. + <div class="member-body-short" id="short-body-baseArgTypesHi(base)(ctx)"> + <p>The type arguments of this type's base type instance wrt.<code>base</code>. +Existential types in arguments are approximated by their upper bound.</p> + + </div> + <div class="member-body-long" id ="long-body-baseArgTypesHi(base)(ctx)"> + <p>The type arguments of this type's base type instance wrt.<code>base</code>. Existential types in arguments are approximated by their upper bound.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="baseArgTypesLo(base)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'baseArgTypesLo(base)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -6713,19 +7272,41 @@ Existential types in arguments are approximated by their upper bound.</p> - <span class="no-left">: List</span> + <span class="no-left">: List +<span class="no-left no-right">[</span> +Type +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The type arguments of this type's base type instance wrt.<code>base</code>. + <div class="member-body-short" id="short-body-baseArgTypesLo(base)(ctx)"> + <p>The type arguments of this type's base type instance wrt.<code>base</code>. Existential types in arguments are approximated by their lower bound.</p> + </div> + <div class="member-body-long" id ="long-body-baseArgTypesLo(base)(ctx)"> + <p>The type arguments of this type's base type instance wrt.<code>base</code>. +Existential types in arguments are approximated by their lower bound.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="baseClasses(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'baseClasses(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -6761,21 +7342,45 @@ Existential types in arguments are approximated by their lower bound.</p> - <span class="no-left">: List</span> + <span class="no-left">: List +<span class="no-left no-right">[</span> +ClassSymbol +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The base classes of this type as determined by ClassDenotation + <div class="member-body-short" id="short-body-baseClasses(ctx)"> + <p>The base classes of this type as determined by ClassDenotation in linearization order, with the class itself as first element. For AndTypes/OrTypes, the... </p> + </div> + <div class="member-body-long" id ="long-body-baseClasses(ctx)"> + <p>The base classes of this type as determined by ClassDenotation +in linearization order, with the class itself as first element. +For AndTypes/OrTypes, the union/intersection of the operands' baseclasses. +Inherited by all type proxies. <code>Nil</code> for all other types.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="baseTypeRef(base)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'baseTypeRef(base)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -6827,14 +7432,33 @@ For AndTypes/OrTypes, the... </div><!-- end member-title --> <div class="member-body"> - <p>The basetype TypeRef of this type with given class symbol, + <div class="member-body-short" id="short-body-baseTypeRef(base)(ctx)"> + <p>The basetype TypeRef of this type with given class symbol, but without including any type arguments</p> + </div> + <div class="member-body-long" id ="long-body-baseTypeRef(base)(ctx)"> + <p>The basetype TypeRef of this type with given class symbol, +but without including any type arguments</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="baseTypeWithArgs(base)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'baseTypeWithArgs(base)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -6886,16 +7510,37 @@ but without including any type arguments</p> </div><!-- end member-title --> <div class="member-body"> - <p>The base type including all type arguments and applicable refinements + <div class="member-body-short" id="short-body-baseTypeWithArgs(base)(ctx)"> + <p>The base type including all type arguments and applicable refinements of this type. Refinements are applicable if they refine a member of the parent typ... </p> + </div> + <div class="member-body-long" id ="long-body-baseTypeWithArgs(base)(ctx)"> + <p>The base type including all type arguments and applicable refinements +of this type. Refinements are applicable if they refine a member of +the parent type which furthermore is not a name-mangled type parameter. +Existential types in arguments are returned as TypeBounds instances.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="bounds(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'bounds(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -6936,13 +7581,31 @@ the parent typ... </div><!-- end member-title --> <div class="member-body"> - <p>This type seen as a TypeBounds</p> + <div class="member-body-short" id="short-body-bounds(ctx)"> + <p>This type seen as a TypeBounds</p> + + </div> + <div class="member-body-long" id ="long-body-bounds(ctx)"> + <p>This type seen as a TypeBounds</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="classSymbol(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'classSymbol(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -6983,15 +7646,35 @@ the parent typ... </div><!-- end member-title --> <div class="member-body"> - <p>The least class or trait of which this type is a subtype or parameterized + <div class="member-body-short" id="short-body-classSymbol(ctx)"> + <p>The least class or trait of which this type is a subtype or parameterized instance, or NoSymbol if none exists (either because this type is not a value...</p> + </div> + <div class="member-body-long" id ="long-body-classSymbol(ctx)"> + <p>The least class or trait of which this type is a subtype or parameterized +instance, or NoSymbol if none exists (either because this type is not a +value type, or because superclasses are ambiguous).</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="classSymbols(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'classSymbols(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -7027,18 +7710,39 @@ value...</p> - <span class="no-left">: List</span> + <span class="no-left">: List +<span class="no-left no-right">[</span> +ClassSymbol +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The least (wrt <:<) set of class symbols of which this type is a subtype</p> + <div class="member-body-short" id="short-body-classSymbols(ctx)"> + <p>The least (wrt <:<) set of class symbols of which this type is a subtype</p> + + </div> + <div class="member-body-long" id ="long-body-classSymbols(ctx)"> + <p>The least (wrt <:<) set of class symbols of which this type is a subtype</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="deAnonymize(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'deAnonymize(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -7079,13 +7783,31 @@ value...</p> </div><!-- end member-title --> <div class="member-body"> - <p>Eliminate anonymous classes</p> + <div class="member-body-short" id="short-body-deAnonymize(ctx)"> + <p>Eliminate anonymous classes</p> + + </div> + <div class="member-body-long" id ="long-body-deAnonymize(ctx)"> + <p>Eliminate anonymous classes</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="dealias(keepAnnots)(ctx)" class="member private"> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'dealias(keepAnnots)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -7137,12 +7859,29 @@ value...</p> </div><!-- end member-title --> <div class="member-body"> - + <div class="member-body-short" id="short-body-dealias(keepAnnots)(ctx)"> + + </div> + <div class="member-body-long" id ="long-body-dealias(keepAnnots)(ctx)"> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="dealias(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'dealias(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -7183,15 +7922,35 @@ value...</p> </div><!-- end member-title --> <div class="member-body"> - <p>Follow aliases and dereferences LazyRefs, annotated types and instantiated + <div class="member-body-short" id="short-body-dealias(ctx)"> + <p>Follow aliases and dereferences LazyRefs, annotated types and instantiated TypeVars until type is no longer alias type, annotated type, LazyRef, or inst...</p> + </div> + <div class="member-body-long" id ="long-body-dealias(ctx)"> + <p>Follow aliases and dereferences LazyRefs, annotated types and instantiated +TypeVars until type is no longer alias type, annotated type, LazyRef, +or instantiated type variable.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="dealiasKeepAnnots(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'dealiasKeepAnnots(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -7232,15 +7991,35 @@ or inst...</p> </div><!-- end member-title --> <div class="member-body"> - <p>Follow aliases and dereferences LazyRefs and instantiated TypeVars until type + <div class="member-body-short" id="short-body-dealiasKeepAnnots(ctx)"> + <p>Follow aliases and dereferences LazyRefs and instantiated TypeVars until type is no longer alias type, LazyRef, or instantiated type variable. Goes thro...</p> + </div> + <div class="member-body-long" id ="long-body-dealiasKeepAnnots(ctx)"> + <p>Follow aliases and dereferences LazyRefs and instantiated TypeVars until type +is no longer alias type, LazyRef, or instantiated type variable. +Goes through annotated types and rewraps annotations on the result.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="decl(name)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'decl(name)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -7292,15 +8071,35 @@ Goes thro...</p> </div><!-- end member-title --> <div class="member-body"> - <p>A denotation containing the declaration(s) in this type with the given name. + <div class="member-body-short" id="short-body-decl(name)(ctx)"> + <p>A denotation containing the declaration(s) in this type with the given name. The result is either a SymDenotation or a MultiDenotation of SymDenotation... </p> + </div> + <div class="member-body-long" id ="long-body-decl(name)(ctx)"> + <p>A denotation containing the declaration(s) in this type with the given name. +The result is either a SymDenotation or a MultiDenotation of SymDenotations. +The info(s) are the original symbol infos, no translation takes place.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="decls(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'decls(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -7341,15 +8140,35 @@ The result is either a SymDenotation or a MultiDenotation of SymDenotation... </div><!-- end member-title --> <div class="member-body"> - <p>The scope of all declarations of this type. + <div class="member-body-short" id="short-body-decls(ctx)"> + <p>The scope of all declarations of this type. +Defined by ClassInfo, inherited by type proxies. +Empty scope for all other types.</p> + + </div> + <div class="member-body-long" id ="long-body-decls(ctx)"> + <p>The scope of all declarations of this type. Defined by ClassInfo, inherited by type proxies. Empty scope for all other types.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="deconst(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'deconst(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -7390,14 +8209,33 @@ Empty scope for all other types.</p> </div><!-- end member-title --> <div class="member-body"> - <p>Widen from constant type to its underlying non-constant + <div class="member-body-short" id="short-body-deconst(ctx)"> + <p>Widen from constant type to its underlying non-constant base type.</p> + </div> + <div class="member-body-long" id ="long-body-deconst(ctx)"> + <p>Widen from constant type to its underlying non-constant +base type.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="deepenProto(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'deepenProto(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -7438,14 +8276,33 @@ base type.</p> </div><!-- end member-title --> <div class="member-body"> - <p>If this is a prototype with some ignored component, reveal one more + <div class="member-body-short" id="short-body-deepenProto(ctx)"> + <p>If this is a prototype with some ignored component, reveal one more +layer of it. Otherwise the type itself.</p> + + </div> + <div class="member-body-long" id ="long-body-deepenProto(ctx)"> + <p>If this is a prototype with some ignored component, reveal one more layer of it. Otherwise the type itself.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="derivesFrom(cls)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'derivesFrom(cls)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -7497,13 +8354,31 @@ layer of it. Otherwise the type itself.</p> </div><!-- end member-title --> <div class="member-body"> - <p>Is this type an instance of a non-bottom subclass of the given class <code>cls</code>?</p> + <div class="member-body-short" id="short-body-derivesFrom(cls)(ctx)"> + <p>Is this type an instance of a non-bottom subclass of the given class <code>cls</code>?</p> + </div> + <div class="member-body-long" id ="long-body-derivesFrom(cls)(ctx)"> + <p>Is this type an instance of a non-bottom subclass of the given class <code>cls</code>?</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="dropAlias(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'dropAlias(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -7544,13 +8419,31 @@ layer of it. Otherwise the type itself.</p> </div><!-- end member-title --> <div class="member-body"> - <p>If this is a type alias, its underlying type, otherwise the type itself</p> + <div class="member-body-short" id="short-body-dropAlias(ctx)"> + <p>If this is a type alias, its underlying type, otherwise the type itself</p> + </div> + <div class="member-body-long" id ="long-body-dropAlias(ctx)"> + <p>If this is a type alias, its underlying type, otherwise the type itself</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="elemType(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'elemType(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -7591,13 +8484,31 @@ layer of it. Otherwise the type itself.</p> </div><!-- end member-title --> <div class="member-body"> - <p>The element type of a sequence or array</p> + <div class="member-body-short" id="short-body-elemType(ctx)"> + <p>The element type of a sequence or array</p> + </div> + <div class="member-body-long" id ="long-body-elemType(ctx)"> + <p>The element type of a sequence or array</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="ensureHK(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'ensureHK(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -7638,13 +8549,31 @@ layer of it. Otherwise the type itself.</p> </div><!-- end member-title --> <div class="member-body"> - <p>If self is not higher-kinded, eta expand it.</p> + <div class="member-body-short" id="short-body-ensureHK(ctx)"> + <p>If self is not higher-kinded, eta expand it.</p> + + </div> + <div class="member-body-long" id ="long-body-ensureHK(ctx)"> + <p>If self is not higher-kinded, eta expand it.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="ensureMethodic(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'ensureMethodic(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -7685,12 +8614,29 @@ layer of it. Otherwise the type itself.</p> </div><!-- end member-title --> <div class="member-body"> - + <div class="member-body-short" id="short-body-ensureMethodic(ctx)"> + + </div> + <div class="member-body-long" id ="long-body-ensureMethodic(ctx)"> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="exists" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'exists');">[+]</span> <span class="member-annotations"> </span> @@ -7716,13 +8662,31 @@ layer of it. Otherwise the type itself.</p> </div><!-- end member-title --> <div class="member-body"> - <p>Is this type different from NoType?</p> + <div class="member-body-short" id="short-body-exists"> + <p>Is this type different from NoType?</p> + </div> + <div class="member-body-long" id ="long-body-exists"> + <p>Is this type different from NoType?</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="existsPart(p,forceLazy)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'existsPart(p,forceLazy)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -7782,13 +8746,31 @@ layer of it. Otherwise the type itself.</p> </div><!-- end member-title --> <div class="member-body"> - <p>Returns true if there is a part of this type that satisfies predicate <code>p</code>.</p> + <div class="member-body-short" id="short-body-existsPart(p,forceLazy)(ctx)"> + <p>Returns true if there is a part of this type that satisfies predicate <code>p</code>.</p> + + </div> + <div class="member-body-long" id ="long-body-existsPart(p,forceLazy)(ctx)"> + <p>Returns true if there is a part of this type that satisfies predicate <code>p</code>.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="existsPart$default$2" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'existsPart$default$2');">[+]</span> <span class="member-annotations"> </span> @@ -7814,13 +8796,31 @@ layer of it. Otherwise the type itself.</p> </div><!-- end member-title --> <div class="member-body"> - <p>Returns true if there is a part of this type that satisfies predicate <code>p</code>.</p> + <div class="member-body-short" id="short-body-existsPart$default$2"> + <p>Returns true if there is a part of this type that satisfies predicate <code>p</code>.</p> + + </div> + <div class="member-body-long" id ="long-body-existsPart$default$2"> + <p>Returns true if there is a part of this type that satisfies predicate <code>p</code>.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="fields(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'fields(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -7856,17 +8856,37 @@ layer of it. Otherwise the type itself.</p> - <span class="no-left">: Seq</span> + <span class="no-left">: Seq +<span class="no-left no-right">[</span> +SingleDenotation +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - + <div class="member-body-short" id="short-body-fields(ctx)"> + + </div> + <div class="member-body-long" id ="long-body-fields(ctx)"> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="finalResultType(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'finalResultType(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -7907,14 +8927,33 @@ layer of it. Otherwise the type itself.</p> </div><!-- end member-title --> <div class="member-body"> - <p>The final result type of a PolyType, MethodType, or ExprType, after skipping + <div class="member-body-short" id="short-body-finalResultType(ctx)"> + <p>The final result type of a PolyType, MethodType, or ExprType, after skipping +all parameter sections, the type itself for all others.</p> + + </div> + <div class="member-body-long" id ="long-body-finalResultType(ctx)"> + <p>The final result type of a PolyType, MethodType, or ExprType, after skipping all parameter sections, the type itself for all others.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="findDecl(name,excluded)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'findDecl(name,excluded)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -7974,15 +9013,35 @@ all parameter sections, the type itself for all others.</p> </div><!-- end member-title --> <div class="member-body"> - <p>A denotation containing the declaration(s) in this type with the given + <div class="member-body-short" id="short-body-findDecl(name,excluded)(ctx)"> + <p>A denotation containing the declaration(s) in this type with the given name, as seen from prefix type <code>pre</code>. Declarations that have a flag in <code>excluded</code> are...</p> + </div> + <div class="member-body-long" id ="long-body-findDecl(name,excluded)(ctx)"> + <p>A denotation containing the declaration(s) in this type with the given +name, as seen from prefix type <code>pre</code>. Declarations that have a flag +in <code>excluded</code> are omitted.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="findMember(name,pre,excluded)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'findMember(name,pre,excluded)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -8050,16 +9109,37 @@ in <code>excluded</code> are...</p> </div><!-- end member-title --> <div class="member-body"> - <p>Find member of this type with given name and + <div class="member-body-short" id="short-body-findMember(name,pre,excluded)(ctx)"> + <p>Find member of this type with given name and produce a denotation that contains the type of the member as seen from given prefix <code>pre</code>. Exclude all member... </p> + </div> + <div class="member-body-long" id ="long-body-findMember(name,pre,excluded)(ctx)"> + <p>Find member of this type with given name and +produce a denotation that contains the type of the member +as seen from given prefix <code>pre</code>. Exclude all members that have +flags in <code>excluded</code> from consideration.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="firstParamTypes(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'firstParamTypes(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -8095,18 +9175,39 @@ as seen from given prefix <code>pre</code>. Exclude all member... - <span class="no-left">: List</span> + <span class="no-left">: List +<span class="no-left no-right">[</span> +Type +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The parameter types in the first parameter section of a generic type or MethodType, Empty list for others</p> + <div class="member-body-short" id="short-body-firstParamTypes(ctx)"> + <p>The parameter types in the first parameter section of a generic type or MethodType, Empty list for others</p> + + </div> + <div class="member-body-long" id ="long-body-firstParamTypes(ctx)"> + <p>The parameter types in the first parameter section of a generic type or MethodType, Empty list for others</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="firstParent(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'firstParent(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -8147,13 +9248,31 @@ as seen from given prefix <code>pre</code>. Exclude all member... </div><!-- end member-title --> <div class="member-body"> - <p>The first parent of this type, AnyRef if list of parents is empty</p> + <div class="member-body-short" id="short-body-firstParent(ctx)"> + <p>The first parent of this type, AnyRef if list of parents is empty</p> + + </div> + <div class="member-body-long" id ="long-body-firstParent(ctx)"> + <p>The first parent of this type, AnyRef if list of parents is empty</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="forallParts(p)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'forallParts(p)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -8205,13 +9324,31 @@ as seen from given prefix <code>pre</code>. Exclude all member... </div><!-- end member-title --> <div class="member-body"> - <p>Returns true if all parts of this type satisfy predicate <code>p</code>.</p> + <div class="member-body-short" id="short-body-forallParts(p)(ctx)"> + <p>Returns true if all parts of this type satisfy predicate <code>p</code>.</p> + + </div> + <div class="member-body-long" id ="long-body-forallParts(p)(ctx)"> + <p>Returns true if all parts of this type satisfy predicate <code>p</code>.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="foreachPart(p,stopAtStatic)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'foreachPart(p,stopAtStatic)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -8271,13 +9408,31 @@ as seen from given prefix <code>pre</code>. Exclude all member... </div><!-- end member-title --> <div class="member-body"> - <p>Performs operation on all parts of this type</p> + <div class="member-body-short" id="short-body-foreachPart(p,stopAtStatic)(ctx)"> + <p>Performs operation on all parts of this type</p> + + </div> + <div class="member-body-long" id ="long-body-foreachPart(p,stopAtStatic)(ctx)"> + <p>Performs operation on all parts of this type</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="foreachPart$default$2" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'foreachPart$default$2');">[+]</span> <span class="member-annotations"> </span> @@ -8303,13 +9458,31 @@ as seen from given prefix <code>pre</code>. Exclude all member... </div><!-- end member-title --> <div class="member-body"> - <p>Performs operation on all parts of this type</p> + <div class="member-body-short" id="short-body-foreachPart$default$2"> + <p>Performs operation on all parts of this type</p> + + </div> + <div class="member-body-long" id ="long-body-foreachPart$default$2"> + <p>Performs operation on all parts of this type</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="frozen_<:<(that)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'frozen_<:<(that)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -8361,13 +9534,31 @@ as seen from given prefix <code>pre</code>. Exclude all member... </div><!-- end member-title --> <div class="member-body"> - <p>Is this type a subtype of that type?</p> + <div class="member-body-short" id="short-body-frozen_<:<(that)(ctx)"> + <p>Is this type a subtype of that type?</p> + </div> + <div class="member-body-long" id ="long-body-frozen_<:<(that)(ctx)"> + <p>Is this type a subtype of that type?</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="givenSelfType(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'givenSelfType(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -8408,13 +9599,31 @@ as seen from given prefix <code>pre</code>. Exclude all member... </div><!-- end member-title --> <div class="member-body"> - <p>the self type of the underlying classtype</p> + <div class="member-body-short" id="short-body-givenSelfType(ctx)"> + <p>the self type of the underlying classtype</p> + </div> + <div class="member-body-long" id ="long-body-givenSelfType(ctx)"> + <p>the self type of the underlying classtype</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="hasAnnotation(cls)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'hasAnnotation(cls)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -8466,13 +9675,31 @@ as seen from given prefix <code>pre</code>. Exclude all member... </div><!-- end member-title --> <div class="member-body"> - <p>Does the type carry an annotation that is an instance of <code>cls</code>?</p> + <div class="member-body-short" id="short-body-hasAnnotation(cls)(ctx)"> + <p>Does the type carry an annotation that is an instance of <code>cls</code>?</p> + + </div> + <div class="member-body-long" id ="long-body-hasAnnotation(cls)(ctx)"> + <p>Does the type carry an annotation that is an instance of <code>cls</code>?</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="hasUnsafeNonvariant(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'hasUnsafeNonvariant(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -8513,13 +9740,31 @@ as seen from given prefix <code>pre</code>. Exclude all member... </div><!-- end member-title --> <div class="member-body"> - <p>Does this type have an UnsafeNonvariant annotation on one of its parts?</p> + <div class="member-body-short" id="short-body-hasUnsafeNonvariant(ctx)"> + <p>Does this type have an UnsafeNonvariant annotation on one of its parts?</p> + + </div> + <div class="member-body-long" id ="long-body-hasUnsafeNonvariant(ctx)"> + <p>Does this type have an UnsafeNonvariant annotation on one of its parts?</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="hash" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'hash');">[+]</span> <span class="member-annotations"> </span> @@ -8545,15 +9790,35 @@ as seen from given prefix <code>pre</code>. Exclude all member... </div><!-- end member-title --> <div class="member-body"> - <p>customized hash code of this type. + <div class="member-body-short" id="short-body-hash"> + <p>customized hash code of this type. +NotCached for uncached types. Cached types +compute hash and use it as the type's hashCode.</p> + + </div> + <div class="member-body-long" id ="long-body-hash"> + <p>customized hash code of this type. NotCached for uncached types. Cached types compute hash and use it as the type's hashCode.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="hkTypeParams(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'hkTypeParams(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -8589,18 +9854,39 @@ compute hash and use it as the type's hashCode.</p> - <span class="no-left">: List</span> + <span class="no-left">: List +<span class="no-left no-right">[</span> +TypeParamInfo +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>If <code>self</code> is a higher-kinded type, its type parameters, otherwise Nil</p> + <div class="member-body-short" id="short-body-hkTypeParams(ctx)"> + <p>If <code>self</code> is a higher-kinded type, its type parameters, otherwise Nil</p> + </div> + <div class="member-body-long" id ="long-body-hkTypeParams(ctx)"> + <p>If <code>self</code> is a higher-kinded type, its type parameters, otherwise Nil</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="implicitMembers(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'implicitMembers(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -8636,18 +9922,39 @@ compute hash and use it as the type's hashCode.</p> - <span class="no-left">: List</span> + <span class="no-left">: List +<span class="no-left no-right">[</span> +TermRef +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The set of implicit members of this type</p> + <div class="member-body-short" id="short-body-implicitMembers(ctx)"> + <p>The set of implicit members of this type</p> + + </div> + <div class="member-body-long" id ="long-body-implicitMembers(ctx)"> + <p>The set of implicit members of this type</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="isAlias" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'isAlias');">[+]</span> <span class="member-annotations"> </span> @@ -8673,13 +9980,31 @@ compute hash and use it as the type's hashCode.</p> </div><!-- end member-title --> <div class="member-body"> - <p>Is this an alias TypeBounds?</p> + <div class="member-body-short" id="short-body-isAlias"> + <p>Is this an alias TypeBounds?</p> + + </div> + <div class="member-body-long" id ="long-body-isAlias"> + <p>Is this an alias TypeBounds?</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="isDirectRef(sym)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'isDirectRef(sym)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -8731,13 +10056,31 @@ compute hash and use it as the type's hashCode.</p> </div><!-- end member-title --> <div class="member-body"> - <p>Is this type a (neither aliased nor applied) reference to class <code>sym</code>?</p> + <div class="member-body-short" id="short-body-isDirectRef(sym)(ctx)"> + <p>Is this type a (neither aliased nor applied) reference to class <code>sym</code>?</p> + + </div> + <div class="member-body-long" id ="long-body-isDirectRef(sym)(ctx)"> + <p>Is this type a (neither aliased nor applied) reference to class <code>sym</code>?</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="isErasedValueType(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'isErasedValueType(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -8778,12 +10121,29 @@ compute hash and use it as the type's hashCode.</p> </div><!-- end member-title --> <div class="member-body"> - + <div class="member-body-short" id="short-body-isErasedValueType(ctx)"> + + </div> + <div class="member-body-long" id ="long-body-isErasedValueType(ctx)"> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="isErroneous(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'isErroneous(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -8824,13 +10184,31 @@ compute hash and use it as the type's hashCode.</p> </div><!-- end member-title --> <div class="member-body"> - <p>Is some part of this type produced as a repair for an error?</p> + <div class="member-body-short" id="short-body-isErroneous(ctx)"> + <p>Is some part of this type produced as a repair for an error?</p> + + </div> + <div class="member-body-long" id ="long-body-isErroneous(ctx)"> + <p>Is some part of this type produced as a repair for an error?</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="isError(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'isError(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -8871,13 +10249,31 @@ compute hash and use it as the type's hashCode.</p> </div><!-- end member-title --> <div class="member-body"> - <p>Is this type produced as a repair for an error?</p> + <div class="member-body-short" id="short-body-isError(ctx)"> + <p>Is this type produced as a repair for an error?</p> + + </div> + <div class="member-body-long" id ="long-body-isError(ctx)"> + <p>Is this type produced as a repair for an error?</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="isHK(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'isHK(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -8918,13 +10314,31 @@ compute hash and use it as the type's hashCode.</p> </div><!-- end member-title --> <div class="member-body"> - <p>Is self type higher-kinded (i.e. of kind != "*")?</p> + <div class="member-body-short" id="short-body-isHK(ctx)"> + <p>Is self type higher-kinded (i.e. of kind != "*")?</p> + </div> + <div class="member-body-long" id ="long-body-isHK(ctx)"> + <p>Is self type higher-kinded (i.e. of kind != "*")?</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="isNotNull(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'isNotNull(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -8965,15 +10379,35 @@ compute hash and use it as the type's hashCode.</p> </div><!-- end member-title --> <div class="member-body"> - <p>Is this type guaranteed not to have <code>null</code> as a value? + <div class="member-body-short" id="short-body-isNotNull(ctx)"> + <p>Is this type guaranteed not to have <code>null</code> as a value? +For the moment this is only true for modules, but it could +be refined later.</p> + + </div> + <div class="member-body-long" id ="long-body-isNotNull(ctx)"> + <p>Is this type guaranteed not to have <code>null</code> as a value? For the moment this is only true for modules, but it could be refined later.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="isNullaryMethod(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'isNullaryMethod(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -9014,13 +10448,31 @@ be refined later.</p> </div><!-- end member-title --> <div class="member-body"> - <p>Is this the type of a method with a leading empty parameter list?</p> + <div class="member-body-short" id="short-body-isNullaryMethod(ctx)"> + <p>Is this the type of a method with a leading empty parameter list?</p> + </div> + <div class="member-body-long" id ="long-body-isNullaryMethod(ctx)"> + <p>Is this the type of a method with a leading empty parameter list?</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="isParameterless(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'isParameterless(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -9061,13 +10513,31 @@ be refined later.</p> </div><!-- end member-title --> <div class="member-body"> - <p>Is this either not a method at all, or a parameterless method?</p> + <div class="member-body-short" id="short-body-isParameterless(ctx)"> + <p>Is this either not a method at all, or a parameterless method?</p> + + </div> + <div class="member-body-long" id ="long-body-isParameterless(ctx)"> + <p>Is this either not a method at all, or a parameterless method?</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="isPrimitiveValueType(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'isPrimitiveValueType(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -9108,12 +10578,29 @@ be refined later.</p> </div><!-- end member-title --> <div class="member-body"> - + <div class="member-body-short" id="short-body-isPrimitiveValueType(ctx)"> + + </div> + <div class="member-body-long" id ="long-body-isPrimitiveValueType(ctx)"> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="isRef(sym)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'isRef(sym)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -9165,14 +10652,33 @@ be refined later.</p> </div><!-- end member-title --> <div class="member-body"> - <p>Is this type a (possibly refined or applied or aliased) type reference + <div class="member-body-short" id="short-body-isRef(sym)(ctx)"> + <p>Is this type a (possibly refined or applied or aliased) type reference +to the given type symbol?</p> + + </div> + <div class="member-body-long" id ="long-body-isRef(sym)(ctx)"> + <p>Is this type a (possibly refined or applied or aliased) type reference to the given type symbol?</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="isRepeatedParam(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'isRepeatedParam(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -9213,13 +10719,31 @@ to the given type symbol?</p> </div><!-- end member-title --> <div class="member-body"> - <p>Is this a type of a repeated parameter?</p> + <div class="member-body-short" id="short-body-isRepeatedParam(ctx)"> + <p>Is this a type of a repeated parameter?</p> + + </div> + <div class="member-body-long" id ="long-body-isRepeatedParam(ctx)"> + <p>Is this a type of a repeated parameter?</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="isStable(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'isStable(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -9260,13 +10784,31 @@ to the given type symbol?</p> </div><!-- end member-title --> <div class="member-body"> - <p>Does this type denote a stable reference (i.e. singleton type)?</p> + <div class="member-body-short" id="short-body-isStable(ctx)"> + <p>Does this type denote a stable reference (i.e. singleton type)?</p> + + </div> + <div class="member-body-long" id ="long-body-isStable(ctx)"> + <p>Does this type denote a stable reference (i.e. singleton type)?</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="isTightPrefix(sym)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'isTightPrefix(sym)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -9318,14 +10860,33 @@ to the given type symbol?</p> </div><!-- end member-title --> <div class="member-body"> - <p>Does this type refer exactly to class symbol <code>sym</code>, instead of to a subclass of <code>sym</code>? + <div class="member-body-short" id="short-body-isTightPrefix(sym)(ctx)"> + <p>Does this type refer exactly to class symbol <code>sym</code>, instead of to a subclass of <code>sym</code>? Implemented like <code>isRef</code>, but follows more types: all type proxies as...</p> + </div> + <div class="member-body-long" id ="long-body-isTightPrefix(sym)(ctx)"> + <p>Does this type refer exactly to class symbol <code>sym</code>, instead of to a subclass of <code>sym</code>? +Implemented like <code>isRef</code>, but follows more types: all type proxies as well as and- and or-types</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="isUnsafeNonvariant(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'isUnsafeNonvariant(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -9366,13 +10927,31 @@ Implemented like <code>isRef</code>, but follows more types: all type proxies as </div><!-- end member-title --> <div class="member-body"> - <p>Does this type carry an UnsafeNonvariant annotation?</p> + <div class="member-body-short" id="short-body-isUnsafeNonvariant(ctx)"> + <p>Does this type carry an UnsafeNonvariant annotation?</p> + </div> + <div class="member-body-long" id ="long-body-isUnsafeNonvariant(ctx)"> + <p>Does this type carry an UnsafeNonvariant annotation?</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="isValueSubType(that)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'isValueSubType(that)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -9424,13 +11003,31 @@ Implemented like <code>isRef</code>, but follows more types: all type proxies as </div><!-- end member-title --> <div class="member-body"> - <p>Is this type a primitive value type which can be widened to the primitive value type <code>that</code>?</p> + <div class="member-body-short" id="short-body-isValueSubType(that)(ctx)"> + <p>Is this type a primitive value type which can be widened to the primitive value type <code>that</code>?</p> + </div> + <div class="member-body-long" id ="long-body-isValueSubType(that)(ctx)"> + <p>Is this type a primitive value type which can be widened to the primitive value type <code>that</code>?</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="isValueType" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'isValueType');">[+]</span> <span class="member-annotations"> </span> @@ -9456,13 +11053,31 @@ Implemented like <code>isRef</code>, but follows more types: all type proxies as </div><!-- end member-title --> <div class="member-body"> - <p>Is this type a value type?</p> + <div class="member-body-short" id="short-body-isValueType"> + <p>Is this type a value type?</p> + </div> + <div class="member-body-long" id ="long-body-isValueType"> + <p>Is this type a value type?</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="isValueTypeOrLambda" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'isValueTypeOrLambda');">[+]</span> <span class="member-annotations"> </span> @@ -9488,13 +11103,31 @@ Implemented like <code>isRef</code>, but follows more types: all type proxies as </div><!-- end member-title --> <div class="member-body"> - <p>Is the is value type or type lambda?</p> + <div class="member-body-short" id="short-body-isValueTypeOrLambda"> + <p>Is the is value type or type lambda?</p> + </div> + <div class="member-body-long" id ="long-body-isValueTypeOrLambda"> + <p>Is the is value type or type lambda?</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="isVarArgsMethod(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'isVarArgsMethod(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -9535,14 +11168,33 @@ Implemented like <code>isRef</code>, but follows more types: all type proxies as </div><!-- end member-title --> <div class="member-body"> - <p>Is this the type of a method that has a repeated parameter type as + <div class="member-body-short" id="short-body-isVarArgsMethod(ctx)"> + <p>Is this the type of a method that has a repeated parameter type as +last parameter type?</p> + + </div> + <div class="member-body-long" id ="long-body-isVarArgsMethod(ctx)"> + <p>Is this the type of a method that has a repeated parameter type as last parameter type?</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="lookupRefined(name)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'lookupRefined(name)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -9594,7 +11246,8 @@ last parameter type?</p> </div><!-- end member-title --> <div class="member-body"> - <p>If this normalizes* to a refinement type that has a refinement for <code>name</code> (which might be followed + <div class="member-body-short" id="short-body-lookupRefined(name)(ctx)"> + <p>If this normalizes* to a refinement type that has a refinement for <code>name</code> (which might be followed by other refinements), and the refined info is a type... </p> <p></p> @@ -9605,11 +11258,37 @@ by other refinements), and the refined info is a type... </code></pre> <p></p> + </div> + <div class="member-body-long" id ="long-body-lookupRefined(name)(ctx)"> + <p>If this normalizes* to a refinement type that has a refinement for <code>name</code> (which might be followed +by other refinements), and the refined info is a type alias, return the alias, +otherwise return NoType. Used to reduce types of the form</p> +<p>P { ... type T = / += / -= U ... } # T</p> +<p>to just U. Does not perform the reduction if the resulting type would contain +a reference to the "this" of the current refined type, except in the following situation</p> +<p>(1) The "this" reference can be avoided by following an alias. Example:</p> +<pre><code>P { type T = String, type R = P{...}.T } # R --> String +</code></pre> +<p>(*) normalizes means: follow instantiated typevars and aliases.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="mapReduceAnd(f)(g)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'mapReduceAnd(f)(g)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -9672,13 +11351,31 @@ by other refinements), and the refined info is a type... </div><!-- end member-title --> <div class="member-body"> - <p>Map function <code>f</code> over elements of an AndType, rebuilding with function <code>g</code></p> + <div class="member-body-short" id="short-body-mapReduceAnd(f)(g)(ctx)"> + <p>Map function <code>f</code> over elements of an AndType, rebuilding with function <code>g</code></p> + + </div> + <div class="member-body-long" id ="long-body-mapReduceAnd(f)(g)(ctx)"> + <p>Map function <code>f</code> over elements of an AndType, rebuilding with function <code>g</code></p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="mapReduceOr(f)(g)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'mapReduceOr(f)(g)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -9741,13 +11438,31 @@ by other refinements), and the refined info is a type... </div><!-- end member-title --> <div class="member-body"> - <p>Map function <code>f</code> over elements of an OrType, rebuilding with function <code>g</code></p> + <div class="member-body-short" id="short-body-mapReduceOr(f)(g)(ctx)"> + <p>Map function <code>f</code> over elements of an OrType, rebuilding with function <code>g</code></p> + + </div> + <div class="member-body-long" id ="long-body-mapReduceOr(f)(g)(ctx)"> + <p>Map function <code>f</code> over elements of an OrType, rebuilding with function <code>g</code></p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="matches(that)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'matches(that)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -9799,7 +11514,8 @@ by other refinements), and the refined info is a type... </div><!-- end member-title --> <div class="member-body"> - <p>Is this type close enough to that type so that members + <div class="member-body-short" id="short-body-matches(that)(ctx)"> + <p>Is this type close enough to that type so that members with the two types would override each other? This means: - Either both types are polytypes with t... @@ -9807,11 +11523,41 @@ This means: <p> </p> + </div> + <div class="member-body-long" id ="long-body-matches(that)(ctx)"> + <p>Is this type close enough to that type so that members +with the two types would override each other? +This means: +- Either both types are polytypes with the same number of +type parameters and their result types match after renaming +corresponding type parameters +- Or both types are method types with =:=-equivalent(*) parameter types +and matching result types after renaming corresponding parameter types +if the method types are dependent. +- Or both types are =:=-equivalent +- Or phase.erasedTypes is false, and neither type takes +term or type parameters.</p> +<p>(*) when matching with a Java method, we also regard Any and Object as equivalent +parameter types.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="matchesLoosely(that)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'matchesLoosely(that)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -9863,14 +11609,33 @@ This means: </div><!-- end member-title --> <div class="member-body"> - <p>This is the same as <code>matches</code> except that it also matches => T with T and + <div class="member-body-short" id="short-body-matchesLoosely(that)(ctx)"> + <p>This is the same as <code>matches</code> except that it also matches => T with T and +vice versa.</p> + + </div> + <div class="member-body-long" id ="long-body-matchesLoosely(that)(ctx)"> + <p>This is the same as <code>matches</code> except that it also matches => T with T and vice versa.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="member(name)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'member(name)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -9922,13 +11687,31 @@ vice versa.</p> </div><!-- end member-title --> <div class="member-body"> - <p>The member of this type with the given name</p> + <div class="member-body-short" id="short-body-member(name)(ctx)"> + <p>The member of this type with the given name</p> + + </div> + <div class="member-body-long" id ="long-body-member(name)(ctx)"> + <p>The member of this type with the given name</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="memberClasses(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'memberClasses(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -9964,18 +11747,39 @@ vice versa.</p> - <span class="no-left">: Seq</span> + <span class="no-left">: Seq +<span class="no-left no-right">[</span> +SingleDenotation +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The set of member classes of this type</p> + <div class="member-body-short" id="short-body-memberClasses(ctx)"> + <p>The set of member classes of this type</p> + + </div> + <div class="member-body-long" id ="long-body-memberClasses(ctx)"> + <p>The set of member classes of this type</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="memberDenots(keepOnly,f)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'memberDenots(keepOnly,f)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -10033,17 +11837,37 @@ SingleDenotation - <span class="no-left">: Seq</span> + <span class="no-left">: Seq +<span class="no-left no-right">[</span> +SingleDenotation +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - + <div class="member-body-short" id="short-body-memberDenots(keepOnly,f)(ctx)"> + + </div> + <div class="member-body-long" id ="long-body-memberDenots(keepOnly,f)(ctx)"> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="memberExcluding(name,excluding)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'memberExcluding(name,excluding)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -10103,12 +11927,29 @@ SingleDenotation </div><!-- end member-title --> <div class="member-body"> - + <div class="member-body-short" id="short-body-memberExcluding(name,excluding)(ctx)"> + + </div> + <div class="member-body-long" id ="long-body-memberExcluding(name,excluding)(ctx)"> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="memberInfo(sym)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'memberInfo(sym)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -10160,13 +12001,31 @@ SingleDenotation </div><!-- end member-title --> <div class="member-body"> - <p>The info of <code>sym</code>, seen as a member of this type.</p> + <div class="member-body-short" id="short-body-memberInfo(sym)(ctx)"> + <p>The info of <code>sym</code>, seen as a member of this type.</p> + </div> + <div class="member-body-long" id ="long-body-memberInfo(sym)(ctx)"> + <p>The info of <code>sym</code>, seen as a member of this type.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="memberNames(keepOnly,pre)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'memberNames(keepOnly,pre)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -10221,20 +12080,43 @@ SingleDenotation - <span class="no-left">: Set</span> + <span class="no-left">: Set +<span class="no-left no-right">[</span> +Name +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The set of names of members of this type that pass the given name filter + <div class="member-body-short" id="short-body-memberNames(keepOnly,pre)(ctx)"> + <p>The set of names of members of this type that pass the given name filter when seen as members of <code>pre</code>. More precisely, these are all of members <code>name</code> such...</p> + </div> + <div class="member-body-long" id ="long-body-memberNames(keepOnly,pre)(ctx)"> + <p>The set of names of members of this type that pass the given name filter +when seen as members of <code>pre</code>. More precisely, these are all +of members <code>name</code> such that <code>keepOnly(pre, name)</code> is <code>true</code>.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="memberNames$default$2" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'memberNames$default$2');">[+]</span> <span class="member-annotations"> </span> @@ -10260,15 +12142,35 @@ of members <code>name</code> such...</p> </div><!-- end member-title --> <div class="member-body"> - <p>The set of names of members of this type that pass the given name filter + <div class="member-body-short" id="short-body-memberNames$default$2"> + <p>The set of names of members of this type that pass the given name filter when seen as members of <code>pre</code>. More precisely, these are all of members <code>name</code> such...</p> + </div> + <div class="member-body-long" id ="long-body-memberNames$default$2"> + <p>The set of names of members of this type that pass the given name filter +when seen as members of <code>pre</code>. More precisely, these are all +of members <code>name</code> such that <code>keepOnly(pre, name)</code> is <code>true</code>.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="membersBasedOnFlags(requiredFlags,excludedFlags)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'membersBasedOnFlags(requiredFlags,excludedFlags)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -10323,18 +12225,39 @@ of members <code>name</code> such...</p> - <span class="no-left">: Seq</span> + <span class="no-left">: Seq +<span class="no-left no-right">[</span> +SingleDenotation +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The set of members of this type having at least one of <code>requiredFlags</code> but none of <code>excludedFlags</code> set</p> + <div class="member-body-short" id="short-body-membersBasedOnFlags(requiredFlags,excludedFlags)(ctx)"> + <p>The set of members of this type having at least one of <code>requiredFlags</code> but none of <code>excludedFlags</code> set</p> + + </div> + <div class="member-body-long" id ="long-body-membersBasedOnFlags(requiredFlags,excludedFlags)(ctx)"> + <p>The set of members of this type having at least one of <code>requiredFlags</code> but none of <code>excludedFlags</code> set</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="namedParts(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'namedParts(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -10370,18 +12293,39 @@ of members <code>name</code> such...</p> - <span class="no-left">: Set</span> + <span class="no-left">: Set +<span class="no-left no-right">[</span> +NamedType +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The parts of this type which are type or term refs</p> + <div class="member-body-short" id="short-body-namedParts(ctx)"> + <p>The parts of this type which are type or term refs</p> + + </div> + <div class="member-body-long" id ="long-body-namedParts(ctx)"> + <p>The parts of this type which are type or term refs</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="namedPartsWith(p,excludeLowerBounds)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'namedPartsWith(p,excludeLowerBounds)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -10436,19 +12380,41 @@ of members <code>name</code> such...</p> - <span class="no-left">: Set</span> + <span class="no-left">: Set +<span class="no-left no-right">[</span> +NamedType +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The parts of this type which are type or term refs and which + <div class="member-body-short" id="short-body-namedPartsWith(p,excludeLowerBounds)(ctx)"> + <p>The parts of this type which are type or term refs and which +satisfy predicate <code>p</code>.</p> + + </div> + <div class="member-body-long" id ="long-body-namedPartsWith(p,excludeLowerBounds)(ctx)"> + <p>The parts of this type which are type or term refs and which satisfy predicate <code>p</code>.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="namedPartsWith$default$2" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'namedPartsWith$default$2');">[+]</span> <span class="member-annotations"> </span> @@ -10474,14 +12440,33 @@ satisfy predicate <code>p</code>.</p> </div><!-- end member-title --> <div class="member-body"> - <p>The parts of this type which are type or term refs and which + <div class="member-body-short" id="short-body-namedPartsWith$default$2"> + <p>The parts of this type which are type or term refs and which satisfy predicate <code>p</code>.</p> + </div> + <div class="member-body-long" id ="long-body-namedPartsWith$default$2"> + <p>The parts of this type which are type or term refs and which +satisfy predicate <code>p</code>.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="namedTypeParams(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'namedTypeParams(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -10517,20 +12502,43 @@ satisfy predicate <code>p</code>.</p> - <span class="no-left">: Set</span> + <span class="no-left">: Set +<span class="no-left no-right">[</span> +TypeSymbol +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The named type parameters declared or inherited by this type. + <div class="member-body-short" id="short-body-namedTypeParams(ctx)"> + <p>The named type parameters declared or inherited by this type. These are all uninstantiated named type parameters of this type or one of its base types.</p> + </div> + <div class="member-body-long" id ="long-body-namedTypeParams(ctx)"> + <p>The named type parameters declared or inherited by this type. +These are all uninstantiated named type parameters of this type or one +of its base types.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="narrow(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'narrow(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -10571,14 +12579,33 @@ of its base types.</p> </div><!-- end member-title --> <div class="member-body"> - <p>A prefix-less refined this or a termRef to a new skolem symbol + <div class="member-body-short" id="short-body-narrow(ctx)"> + <p>A prefix-less refined this or a termRef to a new skolem symbol that has the given type as info.</p> + </div> + <div class="member-body-long" id ="long-body-narrow(ctx)"> + <p>A prefix-less refined this or a termRef to a new skolem symbol +that has the given type as info.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="nonClassTypeMembers(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'nonClassTypeMembers(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -10614,18 +12641,39 @@ that has the given type as info.</p> - <span class="no-left">: Seq</span> + <span class="no-left">: Seq +<span class="no-left no-right">[</span> +SingleDenotation +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The set of abstract type members of this type.</p> + <div class="member-body-short" id="short-body-nonClassTypeMembers(ctx)"> + <p>The set of abstract type members of this type.</p> + </div> + <div class="member-body-long" id ="long-body-nonClassTypeMembers(ctx)"> + <p>The set of abstract type members of this type.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="nonPrivateDecl(name)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'nonPrivateDecl(name)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -10677,13 +12725,31 @@ that has the given type as info.</p> </div><!-- end member-title --> <div class="member-body"> - <p>A denotation containing the non-private declaration(s) in this type with the given name</p> + <div class="member-body-short" id="short-body-nonPrivateDecl(name)(ctx)"> + <p>A denotation containing the non-private declaration(s) in this type with the given name</p> + </div> + <div class="member-body-long" id ="long-body-nonPrivateDecl(name)(ctx)"> + <p>A denotation containing the non-private declaration(s) in this type with the given name</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="nonPrivateMember(name)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'nonPrivateMember(name)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -10735,13 +12801,31 @@ that has the given type as info.</p> </div><!-- end member-title --> <div class="member-body"> - <p>The non-private member of this type with the given name.</p> + <div class="member-body-short" id="short-body-nonPrivateMember(name)(ctx)"> + <p>The non-private member of this type with the given name.</p> + + </div> + <div class="member-body-long" id ="long-body-nonPrivateMember(name)(ctx)"> + <p>The non-private member of this type with the given name.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="normalizedPrefix(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'normalizedPrefix(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -10782,17 +12866,39 @@ that has the given type as info.</p> </div><!-- end member-title --> <div class="member-body"> - <p>The normalized prefix of this type is: + <div class="member-body-short" id="short-body-normalizedPrefix(ctx)"> + <p>The normalized prefix of this type is: For an alias type, the normalized prefix of its alias For all other named type and class infos: the prefix. Inheri... </p> + </div> + <div class="member-body-long" id ="long-body-normalizedPrefix(ctx)"> + <p>The normalized prefix of this type is: +For an alias type, the normalized prefix of its alias +For all other named type and class infos: the prefix. +Inherited by all other type proxies. +<code>NoType</code> for all other types.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="notApplied" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'notApplied');">[+]</span> <span class="member-annotations"> </span> @@ -10818,13 +12924,31 @@ Inheri... </div><!-- end member-title --> <div class="member-body"> - <p>If this is a FunProto or PolyProto, WildcardType, otherwise this.</p> + <div class="member-body-short" id="short-body-notApplied"> + <p>If this is a FunProto or PolyProto, WildcardType, otherwise this.</p> + + </div> + <div class="member-body-long" id ="long-body-notApplied"> + <p>If this is a FunProto or PolyProto, WildcardType, otherwise this.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="occursIn(that)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'occursIn(that)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -10876,13 +13000,31 @@ Inheri... </div><!-- end member-title --> <div class="member-body"> - <p>Does this type occur as a part of type <code>that</code>?</p> + <div class="member-body-short" id="short-body-occursIn(that)(ctx)"> + <p>Does this type occur as a part of type <code>that</code>?</p> + + </div> + <div class="member-body-long" id ="long-body-occursIn(that)(ctx)"> + <p>Does this type occur as a part of type <code>that</code>?</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="orElse(that)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'orElse(that)');">[+]</span> <span class="member-annotations"> </span> @@ -10921,13 +13063,31 @@ Inheri... </div><!-- end member-title --> <div class="member-body"> - <p>This type, if it exists, otherwise <code>that</code> type</p> + <div class="member-body-short" id="short-body-orElse(that)"> + <p>This type, if it exists, otherwise <code>that</code> type</p> + + </div> + <div class="member-body-long" id ="long-body-orElse(that)"> + <p>This type, if it exists, otherwise <code>that</code> type</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="overrides(that)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'overrides(that)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -10979,16 +13139,37 @@ Inheri... </div><!-- end member-title --> <div class="member-body"> - <p>Is this type a legal type for a member that overrides another + <div class="member-body-short" id="short-body-overrides(that)(ctx)"> + <p>Is this type a legal type for a member that overrides another member of type <code>that</code>? This is the same as <code><:<</code>, except that the types ()T and => T are ident... </p> + </div> + <div class="member-body-long" id ="long-body-overrides(that)(ctx)"> + <p>Is this type a legal type for a member that overrides another +member of type <code>that</code>? This is the same as <code><:<</code>, except that +the types ()T and => T are identified, and T is seen as overriding +either type.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="paramNamess(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'paramNamess(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -11024,18 +13205,42 @@ the types ()T and => T are ident... - <span class="no-left">: List</span> + <span class="no-left">: List +<span class="no-left no-right">[</span> +List +<span class="no-left no-right">[</span> +TermName +<span class="no-left">]</span> +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The parameter names of a PolyType or MethodType, Empty list for others</p> + <div class="member-body-short" id="short-body-paramNamess(ctx)"> + <p>The parameter names of a PolyType or MethodType, Empty list for others</p> + </div> + <div class="member-body-long" id ="long-body-paramNamess(ctx)"> + <p>The parameter names of a PolyType or MethodType, Empty list for others</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="paramTypess(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'paramTypess(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -11071,18 +13276,42 @@ the types ()T and => T are ident... - <span class="no-left">: List</span> + <span class="no-left">: List +<span class="no-left no-right">[</span> +List +<span class="no-left no-right">[</span> +Type +<span class="no-left">]</span> +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The parameter types of a PolyType or MethodType, Empty list for others</p> + <div class="member-body-short" id="short-body-paramTypess(ctx)"> + <p>The parameter types of a PolyType or MethodType, Empty list for others</p> + + </div> + <div class="member-body-long" id ="long-body-paramTypess(ctx)"> + <p>The parameter types of a PolyType or MethodType, Empty list for others</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="parents(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'parents(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -11118,20 +13347,43 @@ the types ()T and => T are ident... - <span class="no-left">: List</span> + <span class="no-left">: List +<span class="no-left no-right">[</span> +TypeRef +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>For a ClassInfo type, its parents, + <div class="member-body-short" id="short-body-parents(ctx)"> + <p>For a ClassInfo type, its parents, Inherited by all type proxies. Empty for all other types. Overwritten in ClassInfo, where parents is cached.</p> + </div> + <div class="member-body-long" id ="long-body-parents(ctx)"> + <p>For a ClassInfo type, its parents, +Inherited by all type proxies. Empty for all other types. +Overwritten in ClassInfo, where parents is cached.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="parentsWithArgs(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'parentsWithArgs(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -11167,18 +13419,39 @@ Overwritten in ClassInfo, where parents is cached.</p> - <span class="no-left">: List</span> + <span class="no-left">: List +<span class="no-left no-right">[</span> +Type +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The full parent types, including all type arguments</p> + <div class="member-body-short" id="short-body-parentsWithArgs(ctx)"> + <p>The full parent types, including all type arguments</p> + </div> + <div class="member-body-long" id ="long-body-parentsWithArgs(ctx)"> + <p>The full parent types, including all type arguments</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="relaxed_<:<(that)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'relaxed_<:<(that)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -11230,12 +13503,29 @@ Overwritten in ClassInfo, where parents is cached.</p> </div><!-- end member-title --> <div class="member-body"> - + <div class="member-body-short" id="short-body-relaxed_<:<(that)(ctx)"> + + </div> + <div class="member-body-long" id ="long-body-relaxed_<:<(that)(ctx)"> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="resultType(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'resultType(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -11276,13 +13566,31 @@ Overwritten in ClassInfo, where parents is cached.</p> </div><!-- end member-title --> <div class="member-body"> - <p>The resultType of a PolyType, MethodType, or ExprType, the type itself for others</p> + <div class="member-body-short" id="short-body-resultType(ctx)"> + <p>The resultType of a PolyType, MethodType, or ExprType, the type itself for others</p> + </div> + <div class="member-body-long" id ="long-body-resultType(ctx)"> + <p>The resultType of a PolyType, MethodType, or ExprType, the type itself for others</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="safeAppliedTo(args)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'safeAppliedTo(args)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -11337,15 +13645,36 @@ Type </div><!-- end member-title --> <div class="member-body"> - <p>A cycle-safe version of <code>appliedTo</code> where computing type parameters do not force + <div class="member-body-short" id="short-body-safeAppliedTo(args)(ctx)"> + <p>A cycle-safe version of <code>appliedTo</code> where computing type parameters do not force the typeconstructor. Instead, if the type constructor is completing, we... </p> + </div> + <div class="member-body-long" id ="long-body-safeAppliedTo(args)(ctx)"> + <p>A cycle-safe version of <code>appliedTo</code> where computing type parameters do not force +the typeconstructor. Instead, if the type constructor is completing, we make +up hk type parameters matching the arguments. This is needed when unpickling +Scala2 files such as <code>scala.collection.generic.Mapfactory</code>.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="safeDealias(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'safeDealias(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -11386,13 +13715,31 @@ the typeconstructor. Instead, if the type constructor is completing, we... </div><!-- end member-title --> <div class="member-body"> - <p>Dealias type if it can be done without forcing the TypeRef's info</p> + <div class="member-body-short" id="short-body-safeDealias(ctx)"> + <p>Dealias type if it can be done without forcing the TypeRef's info</p> + </div> + <div class="member-body-long" id ="long-body-safeDealias(ctx)"> + <p>Dealias type if it can be done without forcing the TypeRef's info</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="safe_&(that)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'safe_&(that)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -11444,16 +13791,39 @@ the typeconstructor. Instead, if the type constructor is completing, we... </div><!-- end member-title --> <div class="member-body"> - <p>Safer version of <code>&</code>.</p> + <div class="member-body-short" id="short-body-safe_&(that)(ctx)"> + <p>Safer version of <code>&</code>.</p> <p>This version does not simplify the upper bound of the intersection of two TypeBounds. The simplification done by <code>&</code> requires subtypin... </p> + </div> + <div class="member-body-long" id ="long-body-safe_&(that)(ctx)"> + <p>Safer version of <code>&</code>.</p> +<p>This version does not simplify the upper bound of the intersection of +two TypeBounds. The simplification done by <code>&</code> requires subtyping checks +which may end up calling <code>&</code> again, in most cases this should be safe +but because of F-bounded types, this can result in an infinite loop +(which will be masked unless <code>-Yno-deep-subtypes</code> is enabled).</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="select(name)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'select(name)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -11505,13 +13875,31 @@ two TypeBounds. The simplification done by <code>&</code> requires subtypin. </div><!-- end member-title --> <div class="member-body"> - <p>The type <this . name> , reduced if possible</p> + <div class="member-body-short" id="short-body-select(name)(ctx)"> + <p>The type <this . name> , reduced if possible</p> + + </div> + <div class="member-body-long" id ="long-body-select(name)(ctx)"> + <p>The type <this . name> , reduced if possible</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="select(name,denot)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'select(name,denot)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -11571,13 +13959,31 @@ two TypeBounds. The simplification done by <code>&</code> requires subtypin. </div><!-- end member-title --> <div class="member-body"> - <p>The type <this . name> , reduced if possible, with given denotation if unreduced</p> + <div class="member-body-short" id="short-body-select(name,denot)(ctx)"> + <p>The type <this . name> , reduced if possible, with given denotation if unreduced</p> + + </div> + <div class="member-body-long" id ="long-body-select(name,denot)(ctx)"> + <p>The type <this . name> , reduced if possible, with given denotation if unreduced</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="select(sym)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'select(sym)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -11629,13 +14035,31 @@ two TypeBounds. The simplification done by <code>&</code> requires subtypin. </div><!-- end member-title --> <div class="member-body"> - <p>The type <this . name> with given symbol, reduced if possible</p> + <div class="member-body-short" id="short-body-select(sym)(ctx)"> + <p>The type <this . name> with given symbol, reduced if possible</p> + </div> + <div class="member-body-long" id ="long-body-select(sym)(ctx)"> + <p>The type <this . name> with given symbol, reduced if possible</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="showWithUnderlying(n)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'showWithUnderlying(n)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -11687,14 +14111,33 @@ two TypeBounds. The simplification done by <code>&</code> requires subtypin. </div><!-- end member-title --> <div class="member-body"> - <p>Utility method to show the underlying type of a TypeProxy chain together + <div class="member-body-short" id="short-body-showWithUnderlying(n)(ctx)"> + <p>Utility method to show the underlying type of a TypeProxy chain together with the proxy type itself.</p> + </div> + <div class="member-body-long" id ="long-body-showWithUnderlying(n)(ctx)"> + <p>Utility method to show the underlying type of a TypeProxy chain together +with the proxy type itself.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="showWithUnderlying$default$1" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'showWithUnderlying$default$1');">[+]</span> <span class="member-annotations"> </span> @@ -11720,14 +14163,33 @@ with the proxy type itself.</p> </div><!-- end member-title --> <div class="member-body"> - <p>Utility method to show the underlying type of a TypeProxy chain together + <div class="member-body-short" id="short-body-showWithUnderlying$default$1"> + <p>Utility method to show the underlying type of a TypeProxy chain together +with the proxy type itself.</p> + + </div> + <div class="member-body-long" id ="long-body-showWithUnderlying$default$1"> + <p>Utility method to show the underlying type of a TypeProxy chain together with the proxy type itself.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="signature(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'signature(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -11768,16 +14230,38 @@ with the proxy type itself.</p> </div><!-- end member-title --> <div class="member-body"> - <p>The signature of this type. This is by default NotAMethod, + <div class="member-body-short" id="short-body-signature(ctx)"> + <p>The signature of this type. This is by default NotAMethod, but is overridden for PolyTypes, MethodTypes, and TermRefWithSignature types. (the reason why... </p> + </div> + <div class="member-body-long" id ="long-body-signature(ctx)"> + <p>The signature of this type. This is by default NotAMethod, +but is overridden for PolyTypes, MethodTypes, and TermRefWithSignature types. +(the reason why we deviate from the "final-method-with-pattern-match-in-base-class" +pattern is that method signatures use caching, so encapsulation +is improved using an OO scheme).</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="simplified(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'simplified(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -11818,16 +14302,40 @@ but is overridden for PolyTypes, MethodTypes, and TermRefWithSignature types. </div><!-- end member-title --> <div class="member-body"> - <p>A simplified version of this type which is equivalent wrt =:= to this type. + <div class="member-body-short" id="short-body-simplified(ctx)"> + <p>A simplified version of this type which is equivalent wrt =:= to this type. This applies a typemap to the type which (as all typemaps) follows type vari... </p> + </div> + <div class="member-body-long" id ="long-body-simplified(ctx)"> + <p>A simplified version of this type which is equivalent wrt =:= to this type. +This applies a typemap to the type which (as all typemaps) follows type +variable instances and reduces typerefs over refined types. It also +re-evaluates all occurrences of And/OrType with &/| because +what was a union or intersection of type variables might be a simpler type +after the type variables are instantiated. Finally, it +maps poly params in the current constraint set back to their type vars.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="stripAnnots(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'stripAnnots(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -11868,13 +14376,31 @@ vari... </div><!-- end member-title --> <div class="member-body"> - <p>Remove all AnnotatedTypes wrapping this type.</p> + <div class="member-body-short" id="short-body-stripAnnots(ctx)"> + <p>Remove all AnnotatedTypes wrapping this type.</p> + + </div> + <div class="member-body-long" id ="long-body-stripAnnots(ctx)"> + <p>Remove all AnnotatedTypes wrapping this type.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="stripTypeVar(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'stripTypeVar(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -11915,14 +14441,33 @@ vari... </div><!-- end member-title --> <div class="member-body"> - <p>Map a TypeVar to either its instance if it is instantiated, or its origin, + <div class="member-body-short" id="short-body-stripTypeVar(ctx)"> + <p>Map a TypeVar to either its instance if it is instantiated, or its origin, if not, until the result is no longer a TypeVar. Identity on all other types...</p> + </div> + <div class="member-body-long" id ="long-body-stripTypeVar(ctx)"> + <p>Map a TypeVar to either its instance if it is instantiated, or its origin, +if not, until the result is no longer a TypeVar. Identity on all other types.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="subst(from,to)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'subst(from,to)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -11988,14 +14533,33 @@ Type </div><!-- end member-title --> <div class="member-body"> - <p>Substitute all types that refer in their symbol attribute to + <div class="member-body-short" id="short-body-subst(from,to)(ctx)"> + <p>Substitute all types that refer in their symbol attribute to one of the symbols in <code>from</code> by the corresponding types in <code>to</code>.</p> + </div> + <div class="member-body-long" id ="long-body-subst(from,to)(ctx)"> + <p>Substitute all types that refer in their symbol attribute to +one of the symbols in <code>from</code> by the corresponding types in <code>to</code>.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="subst(from,to)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'subst(from,to)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -12055,14 +14619,33 @@ one of the symbols in <code>from</code> by the corresponding types in <code>to</ </div><!-- end member-title --> <div class="member-body"> - <p>Substitute all types of the form <code>PolyParam(from, N)</code> by + <div class="member-body-short" id="short-body-subst(from,to)(ctx)"> + <p>Substitute all types of the form <code>PolyParam(from, N)</code> by +<code>PolyParam(to, N)</code>.</p> + + </div> + <div class="member-body-long" id ="long-body-subst(from,to)(ctx)"> + <p>Substitute all types of the form <code>PolyParam(from, N)</code> by <code>PolyParam(to, N)</code>.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="substDealias(from,to)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'substDealias(from,to)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -12128,15 +14711,39 @@ Type </div><!-- end member-title --> <div class="member-body"> - <p>Same as <code>subst</code> but follows aliases as a fallback. When faced with a reference + <div class="member-body-short" id="short-body-substDealias(from,to)(ctx)"> + <p>Same as <code>subst</code> but follows aliases as a fallback. When faced with a reference to an alias type, where normal substitution does not yield a new type, the </p> + </div> + <div class="member-body-long" id ="long-body-substDealias(from,to)(ctx)"> + <p>Same as <code>subst</code> but follows aliases as a fallback. When faced with a reference +to an alias type, where normal substitution does not yield a new type, the +substitution is instead applied to the alias. If that yields a new type, +this type is returned, otherwise the original type (not the alias) is returned. +A use case for this method is if one wants to substitute the type parameters +of a class and also wants to substitute any parameter accessors that alias +the type parameters.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="substParam(from,to)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'substParam(from,to)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -12196,13 +14803,31 @@ to an alias type, where normal substitution does not yield a new type, the </div><!-- end member-title --> <div class="member-body"> - <p>Substitute a bound type by some other type</p> + <div class="member-body-short" id="short-body-substParam(from,to)(ctx)"> + <p>Substitute a bound type by some other type</p> + + </div> + <div class="member-body-long" id ="long-body-substParam(from,to)(ctx)"> + <p>Substitute a bound type by some other type</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="substParams(from,to)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'substParams(from,to)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -12265,13 +14890,31 @@ Type </div><!-- end member-title --> <div class="member-body"> - <p>Substitute bound types by some other types</p> + <div class="member-body-short" id="short-body-substParams(from,to)(ctx)"> + <p>Substitute bound types by some other types</p> + + </div> + <div class="member-body-long" id ="long-body-substParams(from,to)(ctx)"> + <p>Substitute bound types by some other types</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="substRecThis(binder,tp)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'substRecThis(binder,tp)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -12331,13 +14974,31 @@ Type </div><!-- end member-title --> <div class="member-body"> - <p>Substitute all occurrences of <code>RecThis(binder)</code> by <code>tp</code></p> + <div class="member-body-short" id="short-body-substRecThis(binder,tp)(ctx)"> + <p>Substitute all occurrences of <code>RecThis(binder)</code> by <code>tp</code></p> + + </div> + <div class="member-body-long" id ="long-body-substRecThis(binder,tp)(ctx)"> + <p>Substitute all occurrences of <code>RecThis(binder)</code> by <code>tp</code></p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="substSym(from,to)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'substSym(from,to)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -12403,13 +15064,31 @@ Symbol </div><!-- end member-title --> <div class="member-body"> - <p>Substitute all occurrences of symbols in <code>from</code> by references to corresponding symbols in <code>to</code></p> + <div class="member-body-short" id="short-body-substSym(from,to)(ctx)"> + <p>Substitute all occurrences of symbols in <code>from</code> by references to corresponding symbols in <code>to</code></p> + + </div> + <div class="member-body-long" id ="long-body-substSym(from,to)(ctx)"> + <p>Substitute all occurrences of symbols in <code>from</code> by references to corresponding symbols in <code>to</code></p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="substThis(cls,tp)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'substThis(cls,tp)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -12469,13 +15148,31 @@ Symbol </div><!-- end member-title --> <div class="member-body"> - <p>Substitute all occurrences of <code>This(cls)</code> by <code>tp</code></p> + <div class="member-body-short" id="short-body-substThis(cls,tp)(ctx)"> + <p>Substitute all occurrences of <code>This(cls)</code> by <code>tp</code></p> + + </div> + <div class="member-body-long" id ="long-body-substThis(cls,tp)(ctx)"> + <p>Substitute all occurrences of <code>This(cls)</code> by <code>tp</code></p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="substThisUnlessStatic(cls,tp)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'substThisUnlessStatic(cls,tp)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -12535,13 +15232,31 @@ Symbol </div><!-- end member-title --> <div class="member-body"> - <p>As substThis, but only is class is a static owner (i.e. a globally accessible object)</p> + <div class="member-body-short" id="short-body-substThisUnlessStatic(cls,tp)(ctx)"> + <p>As substThis, but only is class is a static owner (i.e. a globally accessible object)</p> + + </div> + <div class="member-body-long" id ="long-body-substThisUnlessStatic(cls,tp)(ctx)"> + <p>As substThis, but only is class is a static owner (i.e. a globally accessible object)</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="termSymbol(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'termSymbol(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -12582,13 +15297,31 @@ Symbol </div><!-- end member-title --> <div class="member-body"> - <p>The term symbol associated with the type</p> + <div class="member-body-short" id="short-body-termSymbol(ctx)"> + <p>The term symbol associated with the type</p> + </div> + <div class="member-body-long" id ="long-body-termSymbol(ctx)"> + <p>The term symbol associated with the type</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="toBounds(tparam)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'toBounds(tparam)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -12640,14 +15373,33 @@ Symbol </div><!-- end member-title --> <div class="member-body"> - <p>Turn this type, which is used as an argument for + <div class="member-body-short" id="short-body-toBounds(tparam)(ctx)"> + <p>Turn this type, which is used as an argument for +type parameter <code>tparam</code>, into a TypeBounds RHS</p> + + </div> + <div class="member-body-long" id ="long-body-toBounds(tparam)(ctx)"> + <p>Turn this type, which is used as an argument for type parameter <code>tparam</code>, into a TypeBounds RHS</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="toFunctionType(dropLast)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'toFunctionType(dropLast)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -12699,13 +15451,31 @@ type parameter <code>tparam</code>, into a TypeBounds RHS</p> </div><!-- end member-title --> <div class="member-body"> - <p>Turn type into a function type.</p> + <div class="member-body-short" id="short-body-toFunctionType(dropLast)(ctx)"> + <p>Turn type into a function type.</p> + + </div> + <div class="member-body-long" id ="long-body-toFunctionType(dropLast)(ctx)"> + <p>Turn type into a function type.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="toFunctionType$default$1" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'toFunctionType$default$1');">[+]</span> <span class="member-annotations"> </span> @@ -12731,13 +15501,31 @@ type parameter <code>tparam</code>, into a TypeBounds RHS</p> </div><!-- end member-title --> <div class="member-body"> - <p>Turn type into a function type.</p> + <div class="member-body-short" id="short-body-toFunctionType$default$1"> + <p>Turn type into a function type.</p> + </div> + <div class="member-body-long" id ="long-body-toFunctionType$default$1"> + <p>Turn type into a function type.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="toText(printer)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'toText(printer)');">[+]</span> <span class="member-annotations"> </span> @@ -12776,13 +15564,31 @@ type parameter <code>tparam</code>, into a TypeBounds RHS</p> </div><!-- end member-title --> <div class="member-body"> - <p>Convert to text</p> + <div class="member-body-short" id="short-body-toText(printer)"> + <p>Convert to text</p> + </div> + <div class="member-body-long" id ="long-body-toText(printer)"> + <p>Convert to text</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="translateParameterized(from,to)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'translateParameterized(from,to)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -12842,15 +15648,35 @@ type parameter <code>tparam</code>, into a TypeBounds RHS</p> </div><!-- end member-title --> <div class="member-body"> - <p>Translate a type of the form From[T] to To[T], keep other types as they are. + <div class="member-body-short" id="short-body-translateParameterized(from,to)(ctx)"> + <p>Translate a type of the form From[T] to To[T], keep other types as they are. <code>from</code> and <code>to</code> must be static classes, both with one type parameter, and the same... [T][T]</p> + </div> + <div class="member-body-long" id ="long-body-translateParameterized(from,to)(ctx)"> + <p>Translate a type of the form From[T] to To[T], keep other types as they are. +<code>from</code> and <code>to</code> must be static classes, both with one type parameter, and the same variance. +Do the same for by name types => From[T] and => To[T]</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="typeMembers(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'typeMembers(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -12886,18 +15712,39 @@ type parameter <code>tparam</code>, into a TypeBounds RHS</p> - <span class="no-left">: Seq</span> + <span class="no-left">: Seq +<span class="no-left no-right">[</span> +SingleDenotation +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The set of type members of this type</p> + <div class="member-body-short" id="short-body-typeMembers(ctx)"> + <p>The set of type members of this type</p> + </div> + <div class="member-body-long" id ="long-body-typeMembers(ctx)"> + <p>The set of type members of this type</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="typeParamNamed(name)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'typeParamNamed(name)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -12949,15 +15796,35 @@ type parameter <code>tparam</code>, into a TypeBounds RHS</p> </div><!-- end member-title --> <div class="member-body"> - <p>The type parameter with given <code>name</code>. This tries first <code>decls</code> + <div class="member-body-short" id="short-body-typeParamNamed(name)(ctx)"> + <p>The type parameter with given <code>name</code>. This tries first <code>decls</code> in order not to provoke a cycle by forcing the info. If that yields no symbol it tries <code>member</code></p> + </div> + <div class="member-body-long" id ="long-body-typeParamNamed(name)(ctx)"> + <p>The type parameter with given <code>name</code>. This tries first <code>decls</code> +in order not to provoke a cycle by forcing the info. If that yields +no symbol it tries <code>member</code> as an alternative.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="typeParamSymbols(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'typeParamSymbols(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -12993,18 +15860,39 @@ no symbol it tries <code>member</code></p> - <span class="no-left">: List</span> + <span class="no-left">: List +<span class="no-left no-right">[</span> +TypeSymbol +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>If <code>self</code> is a generic class, its type parameter symbols, otherwise Nil</p> + <div class="member-body-short" id="short-body-typeParamSymbols(ctx)"> + <p>If <code>self</code> is a generic class, its type parameter symbols, otherwise Nil</p> + </div> + <div class="member-body-long" id ="long-body-typeParamSymbols(ctx)"> + <p>If <code>self</code> is a generic class, its type parameter symbols, otherwise Nil</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="typeParams(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'typeParams(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -13040,21 +15928,53 @@ no symbol it tries <code>member</code></p> - <span class="no-left">: List</span> + <span class="no-left">: List +<span class="no-left no-right">[</span> +TypeParamInfo +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The type parameters of this type are: + <div class="member-body-short" id="short-body-typeParams(ctx)"> + <p>The type parameters of this type are: For a ClassInfo type, the type parameters of its class. For a typeref referring to a class, the type parameters of... </p> + </div> + <div class="member-body-long" id ="long-body-typeParams(ctx)"> + <p>The type parameters of this type are: +For a ClassInfo type, the type parameters of its class. +For a typeref referring to a class, the type parameters of the class. +For a typeref referring to a Lambda class, the type parameters of +its right hand side or upper bound. +For a refinement type, the type parameters of its parent, dropping +any type parameter that is-rebound by the refinement. "Re-bind" means: +The refinement contains a TypeAlias for the type parameter, or +it introduces bounds for the type parameter, and we are not in the +special case of a type Lambda, where a LambdaTrait gets refined +with the bounds on its hk args. See <code>LambdaAbstract</code>, where these +types get introduced, and see <code>isBoundedLambda</code> below for the test.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="typeSymbol(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'typeSymbol(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -13095,13 +16015,31 @@ For a typeref referring to a class, the type parameters of... </div><!-- end member-title --> <div class="member-body"> - <p>The type symbol associated with the type</p> + <div class="member-body-short" id="short-body-typeSymbol(ctx)"> + <p>The type symbol associated with the type</p> + </div> + <div class="member-body-long" id ="long-body-typeSymbol(ctx)"> + <p>The type symbol associated with the type</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="underlyingClassRef(refinementOK)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'underlyingClassRef(refinementOK)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -13153,14 +16091,33 @@ For a typeref referring to a class, the type parameters of... </div><!-- end member-title --> <div class="member-body"> - <p>If this is a (possibly aliased, annotated, and/or parameterized) reference to + <div class="member-body-short" id="short-body-underlyingClassRef(refinementOK)(ctx)"> + <p>If this is a (possibly aliased, annotated, and/or parameterized) reference to +a class, the class type ref, otherwise NoType.</p> + + </div> + <div class="member-body-long" id ="long-body-underlyingClassRef(refinementOK)(ctx)"> + <p>If this is a (possibly aliased, annotated, and/or parameterized) reference to a class, the class type ref, otherwise NoType.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="underlyingIfProxy(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'underlyingIfProxy(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -13201,14 +16158,33 @@ a class, the class type ref, otherwise NoType.</p> </div><!-- end member-title --> <div class="member-body"> - <p>Useful for diagnostics: The underlying type if this type is a type proxy, + <div class="member-body-short" id="short-body-underlyingIfProxy(ctx)"> + <p>Useful for diagnostics: The underlying type if this type is a type proxy, otherwise NoType</p> + </div> + <div class="member-body-long" id ="long-body-underlyingIfProxy(ctx)"> + <p>Useful for diagnostics: The underlying type if this type is a type proxy, +otherwise NoType</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="underlyingIfRepeated(isJava)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'underlyingIfRepeated(isJava)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -13260,14 +16236,33 @@ otherwise NoType</p> </div><!-- end member-title --> <div class="member-body"> - <p>If this is repeated parameter type, its underlying Seq type, + <div class="member-body-short" id="short-body-underlyingIfRepeated(isJava)(ctx)"> + <p>If this is repeated parameter type, its underlying Seq type, +or, if isJava is true, Array type, else the type itself.</p> + + </div> + <div class="member-body-long" id ="long-body-underlyingIfRepeated(isJava)(ctx)"> + <p>If this is repeated parameter type, its underlying Seq type, or, if isJava is true, Array type, else the type itself.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="underlyingIterator(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'underlyingIterator(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -13303,19 +16298,41 @@ or, if isJava is true, Array type, else the type itself.</p> - <span class="no-left">: Iterator</span> + <span class="no-left">: Iterator +<span class="no-left no-right">[</span> +Type +<span class="no-left">]</span></span> </div><!-- end member-title --> <div class="member-body"> - <p>The iterator of underlying types as long as type is a TypeProxy. + <div class="member-body-short" id="short-body-underlyingIterator(ctx)"> + <p>The iterator of underlying types as long as type is a TypeProxy. +Useful for diagnostics</p> + + </div> + <div class="member-body-long" id ="long-body-underlyingIterator(ctx)"> + <p>The iterator of underlying types as long as type is a TypeProxy. Useful for diagnostics</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="widen(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'widen(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -13356,18 +16373,42 @@ Useful for diagnostics</p> </div><!-- end member-title --> <div class="member-body"> - <p>Widen from singleton type to its underlying non-singleton + <div class="member-body-short" id="short-body-widen(ctx)"> + <p>Widen from singleton type to its underlying non-singleton base type by applying one or more <code>underlying</code> dereferences, Also go from => T to T. Identity for...</p> <p> </p> + </div> + <div class="member-body-long" id ="long-body-widen(ctx)"> + <p>Widen from singleton type to its underlying non-singleton +base type by applying one or more <code>underlying</code> dereferences, +Also go from => T to T. +Identity for all other types. Example:</p> +<p>class Outer { class C ; val x: C } +def o: Outer +<o.x.type>.widen = o.C</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="widenDealias(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'widenDealias(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -13408,13 +16449,31 @@ Identity for...</p> </div><!-- end member-title --> <div class="member-body"> - <p>Perform successive widenings and dealiasings until none can be applied anymore</p> + <div class="member-body-short" id="short-body-widenDealias(ctx)"> + <p>Perform successive widenings and dealiasings until none can be applied anymore</p> + </div> + <div class="member-body-long" id ="long-body-widenDealias(ctx)"> + <p>Perform successive widenings and dealiasings until none can be applied anymore</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="widenExpr" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'widenExpr');">[+]</span> <span class="member-annotations"> </span> @@ -13440,14 +16499,33 @@ Identity for...</p> </div><!-- end member-title --> <div class="member-body"> - <p>Widen from ExprType type to its result type. + <div class="member-body-short" id="short-body-widenExpr"> + <p>Widen from ExprType type to its result type. (Note: no stripTypeVar needed because TypeVar's can't refer to ExprTypes.)</p> + </div> + <div class="member-body-long" id ="long-body-widenExpr"> + <p>Widen from ExprType type to its result type. +(Note: no stripTypeVar needed because TypeVar's can't refer to ExprTypes.)</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="widenIfUnstable(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'widenIfUnstable(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -13488,13 +16566,31 @@ Identity for...</p> </div><!-- end member-title --> <div class="member-body"> - <p>Widen type if it is unstable (i.e. an ExprType, or TermRef to unstable symbol</p> + <div class="member-body-short" id="short-body-widenIfUnstable(ctx)"> + <p>Widen type if it is unstable (i.e. an ExprType, or TermRef to unstable symbol</p> + + </div> + <div class="member-body-long" id ="long-body-widenIfUnstable(ctx)"> + <p>Widen type if it is unstable (i.e. an ExprType, or TermRef to unstable symbol</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="widenSingleton(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'widenSingleton(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -13535,14 +16631,33 @@ Identity for...</p> </div><!-- end member-title --> <div class="member-body"> - <p>Widen from singleton type to its underlying non-singleton + <div class="member-body-short" id="short-body-widenSingleton(ctx)"> + <p>Widen from singleton type to its underlying non-singleton base type by applying one or more <code>underlying</code> dereferences.</p> + </div> + <div class="member-body-long" id ="long-body-widenSingleton(ctx)"> + <p>Widen from singleton type to its underlying non-singleton +base type by applying one or more <code>underlying</code> dereferences.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="widenSkolem(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'widenSkolem(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -13583,13 +16698,31 @@ base type by applying one or more <code>underlying</code> dereferences.</p> </div><!-- end member-title --> <div class="member-body"> - <p>If this is a skolem, its underlying type, otherwise the type itself</p> + <div class="member-body-short" id="short-body-widenSkolem(ctx)"> + <p>If this is a skolem, its underlying type, otherwise the type itself</p> + </div> + <div class="member-body-long" id ="long-body-widenSkolem(ctx)"> + <p>If this is a skolem, its underlying type, otherwise the type itself</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="widenTermRefExpr(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'widenTermRefExpr(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -13630,14 +16763,33 @@ base type by applying one or more <code>underlying</code> dereferences.</p> </div><!-- end member-title --> <div class="member-body"> - <p>Widen from TermRef to its underlying non-termref + <div class="member-body-short" id="short-body-widenTermRefExpr(ctx)"> + <p>Widen from TermRef to its underlying non-termref base type, while also skipping Expr types.</p> + </div> + <div class="member-body-long" id ="long-body-widenTermRefExpr(ctx)"> + <p>Widen from TermRef to its underlying non-termref +base type, while also skipping Expr types.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="widenToNamedTypeParams(params)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'widenToNamedTypeParams(params)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -13692,15 +16844,38 @@ TypeSymbol </div><!-- end member-title --> <div class="member-body"> - <p>The smallest supertype of this type that instantiated none of the named type parameters + <div class="member-body-short" id="short-body-widenToNamedTypeParams(params)(ctx)"> + <p>The smallest supertype of this type that instantiated none of the named type parameters in <code>params</code>. That is, for each named type parameter <code>p</code> in <code>params</code>,... </p> + </div> + <div class="member-body-long" id ="long-body-widenToNamedTypeParams(params)(ctx)"> + <p>The smallest supertype of this type that instantiated none of the named type parameters +in <code>params</code>. That is, for each named type parameter <code>p</code> in <code>params</code>, either there is +no type field named <code>p</code> in this type, or <code>p</code> is a named type parameter of this type. +The first case is important for the recursive case of AndTypes, because some of their operands might +be missing the named parameter altogether, but the AndType as a whole can still +contain it.</p> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="withoutArgs(typeArgs)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, 'withoutArgs(typeArgs)');">[+]</span> <span class="member-annotations"> </span> @@ -13742,13 +16917,31 @@ Type </div><!-- end member-title --> <div class="member-body"> - <p>The core type without any type arguments.</p> + <div class="member-body-short" id="short-body-withoutArgs(typeArgs)"> + <p>The core type without any type arguments.</p> + + </div> + <div class="member-body-long" id ="long-body-withoutArgs(typeArgs)"> + <p>The core type without any type arguments.</p> + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> <div id="|(that)(ctx)" class="member "> <div class="member-title"> + <span class="expand-button" onclick="toggleMemberBody(this, '|(that)(ctx)');">[+]</span> <span class="member-annotations"> </span> @@ -13800,8 +16993,24 @@ Type </div><!-- end member-title --> <div class="member-body"> - + <div class="member-body-short" id="short-body-|(that)(ctx)"> + + </div> + <div class="member-body-long" id ="long-body-|(that)(ctx)"> + + </div> </div> + <script> + function toggleMemberBody(span, sig) { + var shortBody = document.getElementById("short-body-" + sig); + var longBody = document.getElementById("long-body-" + sig); + + shortBody.classList.toggle("toggled") + longBody.classList.toggle("toggled") + + span.innerHTML = (span.innerHTML == "[+]") ? "[-]" : "[+]"; + } + </script> </div><!-- end member --> </div> |