Update gh-pages site for da7d7231b7f21fe1085abc569eb783590074a359

1 files changed, 1122 insertions, 63 deletions

diff --git a/api/dotty/tools/dotc/core/OrderingConstraint.html b/api/dotty/tools/dotc/core/OrderingConstraint.html
index 8be63f2ad..4008ee80a 100644
--- a/api/dotty/tools/dotc/core/OrderingConstraint.html
+++ b/api/dotty/tools/dotc/core/OrderingConstraint.html
@@ -5321,6 +5321,9 @@
 
 <div id="entity-container">
     <div id="entity-title">
+        <span id="entity-annotations">
+            
+        </span>
         <span id="entity-modifiers">
             
         </span>
@@ -5330,6 +5333,17 @@
         <span id="entity-name">
             OrderingConstraint
         </span>
+        
+        
+        <div id="super-types">
+            
+            
+            <span class="keyword">extends</span>
+            
+            <span class="entity-super-type">Constraint</span>
+            
+        </div>
+        
     </div>
 
     
@@ -5340,12 +5354,57 @@ reflect parameter orderings.</p>
     </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">OrderingConstraint</span>
+                    <span class="no-left">(</span>
+                        
+                        
+                            <span class="no-left">
+                                boundsMap:
+                            </span>
+                            ParamBounds
+                            
+                                <span class="no-left">, </span>
+                            
+                        
+                            <span class="">
+                                lowerMap:
+                            </span>
+                            ParamOrdering
+                            
+                                <span class="no-left">, </span>
+                            
+                        
+                            <span class="">
+                                upperMap:
+                            </span>
+                            ParamOrdering
+                            
+                        
+                    <span class="no-left">)</span>
+                </div>
+            </div>
+            
+        
+    </div>
+
+    <h1 class="section ">
+        Members
+    </h1>
 
     <div id="entity-members" class="entity-section ">
         
         <div id="This" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'This');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -5374,12 +5433,29 @@ reflect parameter orderings.</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                
+                <div class="member-body-short" id="short-body-This">
+                    
+                </div>
+                <div class="member-body-long" id ="long-body-This">
+                    
+                </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="boundsMap" class="member private">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'boundsMap');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -5405,12 +5481,29 @@ reflect parameter orderings.</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                
+                <div class="member-body-short" id="short-body-boundsMap">
+                    
+                </div>
+                <div class="member-body-long" id ="long-body-boundsMap">
+                    
+                </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="lowerMap" class="member private">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'lowerMap');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -5436,12 +5529,29 @@ reflect parameter orderings.</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                
+                <div class="member-body-short" id="short-body-lowerMap">
+                    
+                </div>
+                <div class="member-body-long" id ="long-body-lowerMap">
+                    
+                </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="myUninstVars" class="member private">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'myUninstVars');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -5462,17 +5572,37 @@ reflect parameter orderings.</p>
                 
 
                 
-                <span class="no-left">: ArrayBuffer</span>
+                <span class="no-left">: ArrayBuffer
+<span class="no-left no-right">[</span>
+TypeVar
+<span class="no-left">]</span></span>
                 
             </div><!-- end member-title -->
 
             <div class="member-body">
-                
+                <div class="member-body-short" id="short-body-myUninstVars">
+                    
+                </div>
+                <div class="member-body-long" id ="long-body-myUninstVars">
+                    
+                </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="upperMap" class="member private">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'upperMap');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -5498,12 +5628,29 @@ reflect parameter orderings.</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                
+                <div class="member-body-short" id="short-body-upperMap">
+                    
+                </div>
+                <div class="member-body-long" id ="long-body-upperMap">
+                    
+                </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="&(other)(ctx)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, '&(other)(ctx)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -5555,13 +5702,31 @@ reflect parameter orderings.</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>The weakest constraint that subsumes both this constraint and <code>other</code></p>
+                <div class="member-body-short" id="short-body-&(other)(ctx)">
+                    <p>The weakest constraint that subsumes both this constraint and <code>other</code></p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-&(other)(ctx)">
+                    <p>The weakest constraint that subsumes both this constraint and <code>other</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="add(poly,tvars)(ctx)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'add(poly,tvars)(ctx)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -5624,14 +5789,33 @@ TypeVar
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>A new constraint which is derived from this constraint by adding
+                <div class="member-body-short" id="short-body-add(poly,tvars)(ctx)">
+                    <p>A new constraint which is derived from this constraint by adding
+entries for all type parameters of <code>poly</code>.</p>
+
+                </div>
+                <div class="member-body-long" id ="long-body-add(poly,tvars)(ctx)">
+                    <p>A new constraint which is derived from this constraint by adding
 entries for all type parameters of <code>poly</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="addLess(param1,param2)(ctx)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'addLess(param1,param2)(ctx)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -5691,15 +5875,35 @@ entries for all type parameters of <code>poly</code>.</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>A constraint that includes the relationship <code>p1 &lt;: p2</code>.
+                <div class="member-body-short" id="short-body-addLess(param1,param2)(ctx)">
+                    <p>A constraint that includes the relationship <code>p1 &lt;: p2</code>.
 <code>&lt;:</code> relationships between parameters (&quot;edges&quot;) are propagated, but
 non-parameter bounds are left al...</p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-addLess(param1,param2)(ctx)">
+                    <p>A constraint that includes the relationship <code>p1 &lt;: p2</code>.
+<code>&lt;:</code> relationships between parameters (&quot;edges&quot;) are propagated, but
+non-parameter bounds are left alone.</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="checkClosed()(ctx)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'checkClosed()(ctx)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -5745,13 +5949,31 @@ non-parameter bounds are left al...</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>Check that constraint only refers to PolyParams bound by itself</p>
+                <div class="member-body-short" id="short-body-checkClosed()(ctx)">
+                    <p>Check that constraint only refers to PolyParams bound by itself</p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-checkClosed()(ctx)">
+                    <p>Check that constraint only refers to PolyParams bound by 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="checkNonCyclic()(ctx)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'checkNonCyclic()(ctx)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -5797,13 +6019,31 @@ non-parameter bounds are left al...</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>Check that no constrained parameter contains itself as a bound</p>
+                <div class="member-body-short" id="short-body-checkNonCyclic()(ctx)">
+                    <p>Check that no constrained parameter contains itself as a bound</p>
+
+                </div>
+                <div class="member-body-long" id ="long-body-checkNonCyclic()(ctx)">
+                    <p>Check that no constrained parameter contains itself as a 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="checkNonCyclic(param)(ctx)" class="member private">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'checkNonCyclic(param)(ctx)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -5855,12 +6095,29 @@ non-parameter bounds are left al...</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                
+                <div class="member-body-short" id="short-body-checkNonCyclic(param)(ctx)">
+                    
+                </div>
+                <div class="member-body-long" id ="long-body-checkNonCyclic(param)(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="contains(pt)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'contains(pt)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -5899,13 +6156,31 @@ non-parameter bounds are left al...</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>Does the constraint's domain contain the type parameters of <code>pt</code>?</p>
+                <div class="member-body-short" id="short-body-contains(pt)">
+                    <p>Does the constraint's domain contain the type parameters of <code>pt</code>?</p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-contains(pt)">
+                    <p>Does the constraint's domain contain the type parameters of <code>pt</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="contains(param)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'contains(param)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -5944,13 +6219,31 @@ non-parameter bounds are left al...</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>Does the constraint's domain contain the type parameter <code>param</code>?</p>
+                <div class="member-body-short" id="short-body-contains(param)">
+                    <p>Does the constraint's domain contain the type parameter <code>param</code>?</p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-contains(param)">
+                    <p>Does the constraint's domain contain the type parameter <code>param</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="contains(tvar)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'contains(tvar)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -5989,13 +6282,31 @@ non-parameter bounds are left al...</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>Does this constraint contain the type variable <code>tvar</code> and is it uninstantiated?</p>
+                <div class="member-body-short" id="short-body-contains(tvar)">
+                    <p>Does this constraint contain the type variable <code>tvar</code> and is it uninstantiated?</p>
+
+                </div>
+                <div class="member-body-long" id ="long-body-contains(tvar)">
+                    <p>Does this constraint contain the type variable <code>tvar</code> and is it uninstantiated?</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="dependentParams(tp,isUpper)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'dependentParams(tp,isUpper)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6037,20 +6348,43 @@ non-parameter bounds are left al...</p>
                 
 
                 
-                <span class="no-left">: List</span>
+                <span class="no-left">: List
+<span class="no-left no-right">[</span>
+PolyParam
+<span class="no-left">]</span></span>
                 
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>The list of parameters P such that, for a fresh type parameter Q:</p>
+                <div class="member-body-short" id="short-body-dependentParams(tp,isUpper)">
+                    <p>The list of parameters P such that, for a fresh type parameter Q:</p>
 <p>Q &lt;: tp  implies  Q &lt;: P      and isUpper = true, or
 tp &lt;: Q  implies  P &lt;: Q      and...</p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-dependentParams(tp,isUpper)">
+                    <p>The list of parameters P such that, for a fresh type parameter Q:</p>
+<p>Q &lt;: tp  implies  Q &lt;: P      and isUpper = true, or
+tp &lt;: Q  implies  P &lt;: Q      and isUpper = false</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="domainParams" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'domainParams');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6071,18 +6405,39 @@ tp &lt;: Q  implies  P &lt;: Q      and...</p>
                 
 
                 
-                <span class="no-left">: List</span>
+                <span class="no-left">: List
+<span class="no-left no-right">[</span>
+PolyParam
+<span class="no-left">]</span></span>
                 
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>The polytype parameters constrained by this constraint</p>
+                <div class="member-body-short" id="short-body-domainParams">
+                    <p>The polytype parameters constrained by this constraint</p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-domainParams">
+                    <p>The polytype parameters constrained by this constraint</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="domainPolys" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'domainPolys');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6103,18 +6458,39 @@ tp &lt;: Q  implies  P &lt;: Q      and...</p>
                 
 
                 
-                <span class="no-left">: List</span>
+                <span class="no-left">: List
+<span class="no-left no-right">[</span>
+PolyType
+<span class="no-left">]</span></span>
                 
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>The polytypes constrained by this constraint</p>
+                <div class="member-body-short" id="short-body-domainPolys">
+                    <p>The polytypes constrained by this constraint</p>
+
+                </div>
+                <div class="member-body-long" id ="long-body-domainPolys">
+                    <p>The polytypes constrained by this constraint</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="entry(param)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'entry(param)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6153,13 +6529,31 @@ tp &lt;: Q  implies  P &lt;: Q      and...</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>The <code>boundsMap</code> entry corresponding to <code>param</code></p>
+                <div class="member-body-short" id="short-body-entry(param)">
+                    <p>The <code>boundsMap</code> entry corresponding to <code>param</code></p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-entry(param)">
+                    <p>The <code>boundsMap</code> entry corresponding to <code>param</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="exclusiveLower(param,butNot)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'exclusiveLower(param,butNot)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6201,18 +6595,39 @@ tp &lt;: Q  implies  P &lt;: Q      and...</p>
                 
 
                 
-                <span class="no-left">: List</span>
+                <span class="no-left">: List
+<span class="no-left no-right">[</span>
+PolyParam
+<span class="no-left">]</span></span>
                 
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>lower(param) \ lower(butNot)</p>
+                <div class="member-body-short" id="short-body-exclusiveLower(param,butNot)">
+                    <p>lower(param) \ lower(butNot)</p>
+
+                </div>
+                <div class="member-body-long" id ="long-body-exclusiveLower(param,butNot)">
+                    <p>lower(param) \ lower(butNot)</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="exclusiveUpper(param,butNot)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'exclusiveUpper(param,butNot)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6254,18 +6669,39 @@ tp &lt;: Q  implies  P &lt;: Q      and...</p>
                 
 
                 
-                <span class="no-left">: List</span>
+                <span class="no-left">: List
+<span class="no-left no-right">[</span>
+PolyParam
+<span class="no-left">]</span></span>
                 
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>upper(param) \ upper(butNot)</p>
+                <div class="member-body-short" id="short-body-exclusiveUpper(param,butNot)">
+                    <p>upper(param) \ upper(butNot)</p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-exclusiveUpper(param,butNot)">
+                    <p>upper(param) \ upper(butNot)</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="forallParams(p)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'forallParams(p)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6304,13 +6740,31 @@ tp &lt;: Q  implies  P &lt;: Q      and...</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>Check whether predicate holds for all parameters in constraint</p>
+                <div class="member-body-short" id="short-body-forallParams(p)">
+                    <p>Check whether predicate holds for all parameters in constraint</p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-forallParams(p)">
+                    <p>Check whether predicate holds for all parameters in constraint</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="foreachParam(p)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'foreachParam(p)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6349,12 +6803,29 @@ tp &lt;: Q  implies  P &lt;: Q      and...</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                
+                <div class="member-body-short" id="short-body-foreachParam(p)">
+                    
+                </div>
+                <div class="member-body-long" id ="long-body-foreachParam(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="foreachTypeVar(op)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'foreachTypeVar(op)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6393,14 +6864,33 @@ tp &lt;: Q  implies  P &lt;: Q      and...</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>Perform operation <code>op</code> on all typevars, or only on uninstantiated
+                <div class="member-body-short" id="short-body-foreachTypeVar(op)">
+                    <p>Perform operation <code>op</code> on all typevars, or only on uninstantiated
+typevars, depending on whether <code>uninstOnly</code> is set or not.</p>
+
+                </div>
+                <div class="member-body-long" id ="long-body-foreachTypeVar(op)">
+                    <p>Perform operation <code>op</code> on all typevars, or only on uninstantiated
 typevars, depending on whether <code>uninstOnly</code> is set or not.</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="fullBounds(param)(ctx)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'fullBounds(param)(ctx)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6452,13 +6942,31 @@ typevars, depending on whether <code>uninstOnly</code> is set or not.</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>The bounds of <code>param</code> including all known-to-be-smaller and -greater parameters</p>
+                <div class="member-body-short" id="short-body-fullBounds(param)(ctx)">
+                    <p>The bounds of <code>param</code> including all known-to-be-smaller and -greater parameters</p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-fullBounds(param)(ctx)">
+                    <p>The bounds of <code>param</code> including all known-to-be-smaller and -greater 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="fullLowerBound(param)(ctx)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'fullLowerBound(param)(ctx)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6510,13 +7018,31 @@ typevars, depending on whether <code>uninstOnly</code> is set or not.</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>The lower bound of <code>param</code> including all known-to-be-smaller parameters</p>
+                <div class="member-body-short" id="short-body-fullLowerBound(param)(ctx)">
+                    <p>The lower bound of <code>param</code> including all known-to-be-smaller parameters</p>
+
+                </div>
+                <div class="member-body-long" id ="long-body-fullLowerBound(param)(ctx)">
+                    <p>The lower bound of <code>param</code> including all known-to-be-smaller 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="fullUpperBound(param)(ctx)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'fullUpperBound(param)(ctx)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6568,13 +7094,31 @@ typevars, depending on whether <code>uninstOnly</code> is set or not.</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>The upper bound of <code>param</code> including all known-to-be-greater parameters</p>
+                <div class="member-body-short" id="short-body-fullUpperBound(param)(ctx)">
+                    <p>The upper bound of <code>param</code> including all known-to-be-greater parameters</p>
+
+                </div>
+                <div class="member-body-long" id ="long-body-fullUpperBound(param)(ctx)">
+                    <p>The upper bound of <code>param</code> including all known-to-be-greater 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="init(poly)(ctx)" class="member private">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'init(poly)(ctx)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6626,15 +7170,35 @@ typevars, depending on whether <code>uninstOnly</code> is set or not.</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>Split dependent parameters off the bounds for parameters in <code>poly</code>.
+                <div class="member-body-short" id="short-body-init(poly)(ctx)">
+                    <p>Split dependent parameters off the bounds for parameters in <code>poly</code>.
 Update all bounds to be normalized and update ordering to account for
 dependent parame...</p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-init(poly)(ctx)">
+                    <p>Split dependent parameters off the bounds for parameters in <code>poly</code>.
+Update all bounds to be normalized and update ordering to account for
+dependent 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="isBounds(tp)" class="member private">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'isBounds(tp)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6673,12 +7237,29 @@ dependent parame...</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                
+                <div class="member-body-short" id="short-body-isBounds(tp)">
+                    
+                </div>
+                <div class="member-body-long" id ="long-body-isBounds(tp)">
+                    
+                </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="isLess(param1,param2)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'isLess(param1,param2)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6725,13 +7306,31 @@ dependent parame...</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>Is it known that <code>param1 &lt;:&lt; param2</code>?</p>
+                <div class="member-body-short" id="short-body-isLess(param1,param2)">
+                    <p>Is it known that <code>param1 &lt;:&lt; param2</code>?</p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-isLess(param1,param2)">
+                    <p>Is it known that <code>param1 &lt;:&lt; param2</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="isRemovable(pt)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'isRemovable(pt)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6770,15 +7369,35 @@ dependent parame...</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>Is entry associated with <code>pt</code> removable? This is the case if
+                <div class="member-body-short" id="short-body-isRemovable(pt)">
+                    <p>Is entry associated with <code>pt</code> removable? This is the case if
 all type parameters of the entry are associated with type variables
 which have their <code>inst</code> fie...</p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-isRemovable(pt)">
+                    <p>Is entry associated with <code>pt</code> removable? This is the case if
+all type parameters of the entry are associated with type variables
+which have their <code>inst</code> fields 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="lower(param)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'lower(param)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6812,18 +7431,39 @@ which have their <code>inst</code> fie...</p>
                 
 
                 
-                <span class="no-left">: List</span>
+                <span class="no-left">: List
+<span class="no-left no-right">[</span>
+PolyParam
+<span class="no-left">]</span></span>
                 
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>The parameters that are known to be smaller wrt &lt;: than <code>param</code></p>
+                <div class="member-body-short" id="short-body-lower(param)">
+                    <p>The parameters that are known to be smaller wrt &lt;: than <code>param</code></p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-lower(param)">
+                    <p>The parameters that are known to be smaller wrt &lt;: than <code>param</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="minLower(param)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'minLower(param)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6857,17 +7497,37 @@ which have their <code>inst</code> fie...</p>
                 
 
                 
-                <span class="no-left">: List</span>
+                <span class="no-left">: List
+<span class="no-left no-right">[</span>
+PolyParam
+<span class="no-left">]</span></span>
                 
             </div><!-- end member-title -->
 
             <div class="member-body">
-                
+                <div class="member-body-short" id="short-body-minLower(param)">
+                    
+                </div>
+                <div class="member-body-long" id ="long-body-minLower(param)">
+                    
+                </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="minUpper(param)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'minUpper(param)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6901,17 +7561,37 @@ which have their <code>inst</code> fie...</p>
                 
 
                 
-                <span class="no-left">: List</span>
+                <span class="no-left">: List
+<span class="no-left no-right">[</span>
+PolyParam
+<span class="no-left">]</span></span>
                 
             </div><!-- end member-title -->
 
             <div class="member-body">
-                
+                <div class="member-body-short" id="short-body-minUpper(param)">
+                    
+                </div>
+                <div class="member-body-long" id ="long-body-minUpper(param)">
+                    
+                </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="myUninstVars_=(x$1)" class="member private">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'myUninstVars_=(x$1)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -6953,12 +7633,29 @@ TypeVar
             </div><!-- end member-title -->
 
             <div class="member-body">
-                
+                <div class="member-body-short" id="short-body-myUninstVars_=(x$1)">
+                    
+                </div>
+                <div class="member-body-long" id ="long-body-myUninstVars_=(x$1)">
+                    
+                </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="narrowBound(param,bound,isUpper)(ctx)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'narrowBound(param,bound,isUpper)(ctx)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -7026,14 +7723,33 @@ TypeVar
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>Narrow one of the bounds of type parameter <code>param</code>
+                <div class="member-body-short" id="short-body-narrowBound(param,bound,isUpper)(ctx)">
+                    <p>Narrow one of the bounds of type parameter <code>param</code>
+If <code>isUpper</code> is true, ensure that <code>param &lt;:</code>bound<code>, otherwise ensure that</code>param &gt;: bound`.</p>
+
+                </div>
+                <div class="member-body-long" id ="long-body-narrowBound(param,bound,isUpper)(ctx)">
+                    <p>Narrow one of the bounds of type parameter <code>param</code>
 If <code>isUpper</code> is true, ensure that <code>param &lt;:</code>bound<code>, otherwise ensure that</code>param &gt;: 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="nonParamBounds(param)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'nonParamBounds(param)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -7072,15 +7788,35 @@ If <code>isUpper</code> is true, ensure that <code>param &lt;:</code>bound<code>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>The constraint bounds for given type parameter <code>param</code>.
+                <div class="member-body-short" id="short-body-nonParamBounds(param)">
+                    <p>The constraint bounds for given type parameter <code>param</code>.
 Poly params that are known to be smaller or greater than <code>param</code>
 are not contained in the return bou...</p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-nonParamBounds(param)">
+                    <p>The constraint bounds for given type parameter <code>param</code>.
+Poly params that are known to be smaller or greater than <code>param</code>
+are not contained in the return 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="normalizedType(tp,paramBuf,isUpper)(ctx)" class="member private">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'normalizedType(tp,paramBuf,isUpper)(ctx)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -7151,14 +7887,33 @@ PolyParam
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>The bound type <code>tp</code> without clearly dependent parameters.
+                <div class="member-body-short" id="short-body-normalizedType(tp,paramBuf,isUpper)(ctx)">
+                    <p>The bound type <code>tp</code> without clearly dependent parameters.
+A top or bottom type if type consists only of dependent parameters.</p>
+
+                </div>
+                <div class="member-body-long" id ="long-body-normalizedType(tp,paramBuf,isUpper)(ctx)">
+                    <p>The bound type <code>tp</code> without clearly dependent parameters.
 A top or bottom type if type consists only of dependent 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="order(current,param1,param2)(ctx)" class="member private">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'order(current,param1,param2)(ctx)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -7226,14 +7981,33 @@ A top or bottom type if type consists only of dependent parameters.</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>Add the fact <code>param1 &lt;: param2</code> to the constraint <code>current</code> and propagate
+                <div class="member-body-short" id="short-body-order(current,param1,param2)(ctx)">
+                    <p>Add the fact <code>param1 &lt;: param2</code> to the constraint <code>current</code> and propagate
+<code>&lt;:&lt;</code> relationships between parameters (&quot;edges&quot;) but not bounds.</p>
+
+                </div>
+                <div class="member-body-long" id ="long-body-order(current,param1,param2)(ctx)">
+                    <p>Add the fact <code>param1 &lt;: param2</code> to the constraint <code>current</code> and propagate
 <code>&lt;:&lt;</code> relationships between parameters (&quot;edges&quot;) but not 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="paramCount(entries)" class="member private">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'paramCount(entries)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -7275,13 +8049,31 @@ Type
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>The number of type parameters in the given entry array</p>
+                <div class="member-body-short" id="short-body-paramCount(entries)">
+                    <p>The number of type parameters in the given entry array</p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-paramCount(entries)">
+                    <p>The number of type parameters in the given entry 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="remove(pt)(ctx)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'remove(pt)(ctx)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -7333,13 +8125,31 @@ Type
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>A new constraint with all entries coming from <code>pt</code> removed.</p>
+                <div class="member-body-short" id="short-body-remove(pt)(ctx)">
+                    <p>A new constraint with all entries coming from <code>pt</code> removed.</p>
+
+                </div>
+                <div class="member-body-long" id ="long-body-remove(pt)(ctx)">
+                    <p>A new constraint with all entries coming from <code>pt</code> removed.</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="replace(param,tp)(ctx)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'replace(param,tp)(ctx)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -7399,7 +8209,8 @@ Type
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>A new constraint which is derived from this constraint by removing
+                <div class="member-body-short" id="short-body-replace(param,tp)(ctx)">
+                    <p>A new constraint which is derived from this constraint by removing
 the type parameter <code>param</code> from the domain and replacing all top-level occurrences
 of t...
 </p>
@@ -7418,11 +8229,47 @@ Q
 <p>
 </p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-replace(param,tp)(ctx)">
+                    <p>A new constraint which is derived from this constraint by removing
+the type parameter <code>param</code> from the domain and replacing all top-level occurrences
+of the parameter elsewhere in the constraint by type <code>tp</code>, or a conservative
+approximation of it if that is needed to avoid cycles.
+Occurrences nested inside a refinement or prefix are not affected.</p>
+<p>The reason we need to substitute top-level occurrences of the parameter
+is to deal with situations like the following. Say we have in the constraint</p>
+<pre><code>P &lt;: Q &amp; String
+Q
+</code></pre>
+<p>and we replace Q with P. Then substitution gives</p>
+<pre><code>P &lt;: P &amp; String
+</code></pre>
+<p>this would be a cyclic constraint is therefore changed by <code>normalize</code> and
+<code>recombine</code> below to</p>
+<pre><code>P &lt;: String
+</code></pre>
+<p>approximating the RHS occurrence of P with Any. Without the substitution we
+would not find out where we need to approximate. Occurrences of parameters
+that are not top-level are not affected.</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="stripParams(tp,paramBuf,isUpper)(ctx)" class="member private">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'stripParams(tp,paramBuf,isUpper)(ctx)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -7493,7 +8340,8 @@ PolyParam
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>The bound type <code>tp</code> without constrained parameters which are clearly
+                <div class="member-body-short" id="short-body-stripParams(tp,paramBuf,isUpper)(ctx)">
+                    <p>The bound type <code>tp</code> without constrained parameters which are clearly
 dependent. A parameter in an upper bound is clearly dependent if it appears
 in a hole...</p>
 <pre><code>H = []
@@ -7509,11 +8357,47 @@ in a hole...</p>
 <p>
 </p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-stripParams(tp,paramBuf,isUpper)(ctx)">
+                    <p>The bound type <code>tp</code> without constrained parameters which are clearly
+dependent. A parameter in an upper bound is clearly dependent if it appears
+in a hole of a context H given by:</p>
+<pre><code>H = []
+    H &amp; T
+    T &amp; H
+</code></pre>
+<p>(the idea is that a parameter P in a H context is guaranteed to be a supertype of the
+bounded parameter.)
+Analogously, a parameter in a lower bound is clearly dependent if it appears
+in a hole of a context H given by:</p>
+<pre><code>L = []
+    L | T
+    T | L
+</code></pre>
+<p>&quot;Clearly dependent&quot; is not synonymous with &quot;dependent&quot; in the sense
+it is defined in <code>dependentParams</code>. Dependent parameters are handled
+in <code>updateEntry</code>. The idea of stripping off clearly dependent parameters
+and to handle them separately is for efficiency, so that type expressions
+used as bounds become smaller.</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="toString" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'toString');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -7539,12 +8423,29 @@ in a hole...</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                
+                <div class="member-body-short" id="short-body-toString">
+                    
+                </div>
+                <div class="member-body-long" id ="long-body-toString">
+                    
+                </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>
@@ -7583,15 +8484,35 @@ in a hole...</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>The text representation of this showable element.
+                <div class="member-body-short" id="short-body-toText(printer)">
+                    <p>The text representation of this showable element.
+This normally dispatches to a pattern matching
+method in Printers.</p>
+
+                </div>
+                <div class="member-body-long" id ="long-body-toText(printer)">
+                    <p>The text representation of this showable element.
 This normally dispatches to a pattern matching
 method in Printers.</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="typeVar(entries,n)" class="member private">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'typeVar(entries,n)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -7641,13 +8562,31 @@ Type
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>The type variable corresponding to parameter numbered <code>n</code>, null if none was created</p>
+                <div class="member-body-short" id="short-body-typeVar(entries,n)">
+                    <p>The type variable corresponding to parameter numbered <code>n</code>, null if none was created</p>
+
+                </div>
+                <div class="member-body-long" id ="long-body-typeVar(entries,n)">
+                    <p>The type variable corresponding to parameter numbered <code>n</code>, null if none was created</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="typeVarOfParam(param)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'typeVarOfParam(param)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -7686,14 +8625,33 @@ Type
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>The type variable corresponding to parameter <code>param</code>, or
+                <div class="member-body-short" id="short-body-typeVarOfParam(param)">
+                    <p>The type variable corresponding to parameter <code>param</code>, or
 NoType, if <code>param</code> is not in constrained or is not paired with a type variable.</p>
 
+                </div>
+                <div class="member-body-long" id ="long-body-typeVarOfParam(param)">
+                    <p>The type variable corresponding to parameter <code>param</code>, or
+NoType, if <code>param</code> is not in constrained or is not paired with a 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="unify(p1,p2)(ctx)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'unify(p1,p2)(ctx)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -7753,14 +8711,33 @@ NoType, if <code>param</code> is not in constrained or is not paired with a type
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>A constraint resulting from adding p2 = p1 to this constraint, and at the same
+                <div class="member-body-short" id="short-body-unify(p1,p2)(ctx)">
+                    <p>A constraint resulting from adding p2 = p1 to this constraint, and at the same
+time transferring all bounds of p2 to p1</p>
+
+                </div>
+                <div class="member-body-long" id ="long-body-unify(p1,p2)(ctx)">
+                    <p>A constraint resulting from adding p2 = p1 to this constraint, and at the same
 time transferring all bounds of p2 to p1</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="uninstVars" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'uninstVars');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -7781,18 +8758,39 @@ time transferring all bounds of p2 to p1</p>
                 
 
                 
-                <span class="no-left">: Seq</span>
+                <span class="no-left">: Seq
+<span class="no-left no-right">[</span>
+TypeVar
+<span class="no-left">]</span></span>
                 
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>The uninstantiated typevars of this constraint</p>
+                <div class="member-body-short" id="short-body-uninstVars">
+                    <p>The uninstantiated typevars of this constraint</p>
+
+                </div>
+                <div class="member-body-long" id ="long-body-uninstVars">
+                    <p>The uninstantiated typevars of this constraint</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="updateEntry(current,param,tp)(ctx)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'updateEntry(current,param,tp)(ctx)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -7860,12 +8858,29 @@ time transferring all bounds of p2 to p1</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                
+                <div class="member-body-short" id="short-body-updateEntry(current,param,tp)(ctx)">
+                    
+                </div>
+                <div class="member-body-long" id ="long-body-updateEntry(current,param,tp)(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="updateEntry(param,tp)(ctx)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'updateEntry(param,tp)(ctx)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -7925,7 +8940,8 @@ time transferring all bounds of p2 to p1</p>
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>A new constraint which is derived from this constraint by updating
+                <div class="member-body-short" id="short-body-updateEntry(param,tp)(ctx)">
+                    <p>A new constraint which is derived from this constraint by updating
 the entry for parameter <code>param</code> to <code>tp</code>.
 <code>tp</code> can be one of the following:</p>
 <ul>
@@ -7933,11 +8949,34 @@ the entry for parameter <code>param</code> to <code>tp</code>.
 <li>Another type, indicating a solution for the parameter</li>
 </ul>
 
+                </div>
+                <div class="member-body-long" id ="long-body-updateEntry(param,tp)(ctx)">
+                    <p>A new constraint which is derived from this constraint by updating
+the entry for parameter <code>param</code> to <code>tp</code>.
+<code>tp</code> can be one of the following:</p>
+<ul>
+<li>A TypeBounds value, indicating new constraint bounds</li>
+<li>Another type, indicating a solution for the parameter</li>
+</ul>
+
+                </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="upper(param)" class="member ">
             <div class="member-title">
+                <span class="expand-button" onclick="toggleMemberBody(this, 'upper(param)');">[+]</span>
                 <span class="member-annotations">
                     
                 </span>
@@ -7971,14 +9010,34 @@ the entry for parameter <code>param</code> to <code>tp</code>.
                 
 
                 
-                <span class="no-left">: List</span>
+                <span class="no-left">: List
+<span class="no-left no-right">[</span>
+PolyParam
+<span class="no-left">]</span></span>
                 
             </div><!-- end member-title -->
 
             <div class="member-body">
-                <p>The parameters that are known to be greater wrt &lt;: than <code>param</code></p>
+                <div class="member-body-short" id="short-body-upper(param)">
+                    <p>The parameters that are known to be greater wrt &lt;: than <code>param</code></p>
+
+                </div>
+                <div class="member-body-long" id ="long-body-upper(param)">
+                    <p>The parameters that are known to be greater wrt &lt;: than <code>param</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>