3395

1 files changed, 69 insertions, 69 deletions

diff --git a/html/057immutable.cc.html b/html/057immutable.cc.html
index 29d2ea86..b74dbcb5 100644
--- a/html/057immutable.cc.html
+++ b/html/057immutable.cc.html
@@ -55,11 +55,11 @@ $error: <span class="Constant">0</span>
 <span class="Delimiter">:(scenario can_modify_ingredients_that_are_also_products_2)</span>
 def main [
   local-scope
-  <span class="Normal">p</span>:address:point<span class="Special"> &lt;- </span><span class="Normal">new</span> point:type
+  <span class="Normal">p</span>:&amp;:point<span class="Special"> &lt;- </span><span class="Normal">new</span> point:type
   p<span class="Special"> &lt;- </span>foo p
 ]
 <span class="Comment"># mutable address to container</span>
-def foo p:address:point <span class="Delimiter">-&gt;</span> p:address:point [
+def foo p:&amp;:point <span class="Delimiter">-&gt;</span> p:&amp;:point [
   local-scope
   load-ingredients
   *p<span class="Special"> &lt;- </span>put *p<span class="Delimiter">,</span> x:offset<span class="Delimiter">,</span> <span class="Constant">34</span>
@@ -69,11 +69,11 @@ $error: <span class="Constant">0</span>
 <span class="Delimiter">:(scenario can_modify_ingredients_that_are_also_products_3)</span>
 def main [
   local-scope
-  <span class="Normal">p</span>:address:array:number<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type<span class="Delimiter">,</span> <span class="Constant">3</span>
+  <span class="Normal">p</span>:&amp;:@:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type<span class="Delimiter">,</span> <span class="Constant">3</span>
   p<span class="Special"> &lt;- </span>foo p
 ]
 <span class="Comment"># mutable address</span>
-def foo p:address:array:number <span class="Delimiter">-&gt;</span> p:address:array:number [
+def foo p:&amp;:@:num <span class="Delimiter">-&gt;</span> p:&amp;:@:num [
   local-scope
   load-ingredients
   *p<span class="Special"> &lt;- </span>put-index *p<span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">34</span>
@@ -83,19 +83,19 @@ $error: <span class="Constant">0</span>
 <span class="Delimiter">:(scenario ignore_literal_ingredients_for_immutability_checks)</span>
 def main [
   local-scope
-  <span class="Normal">p</span>:address:d1<span class="Special"> &lt;- </span><span class="Normal">new</span> d1:type
-  <span class="Normal">q</span>:number<span class="Special"> &lt;- </span>foo p
+  <span class="Normal">p</span>:&amp;:d1<span class="Special"> &lt;- </span><span class="Normal">new</span> d1:type
+  <span class="Normal">q</span>:num<span class="Special"> &lt;- </span>foo p
 ]
-def foo p:address:d1 <span class="Delimiter">-&gt;</span> q:number [
+def foo p:&amp;:d1 <span class="Delimiter">-&gt;</span> q:num [
   local-scope
   load-ingredients
-  <span class="Normal">x</span>:address:d1<span class="Special"> &lt;- </span><span class="Normal">new</span> d1:type
+  <span class="Normal">x</span>:&amp;:d1<span class="Special"> &lt;- </span><span class="Normal">new</span> d1:type
   *x<span class="Special"> &lt;- </span>put *x<span class="Delimiter">,</span> p:offset<span class="Delimiter">,</span> <span class="Constant">34</span>  <span class="Comment"># ignore this 'p'</span>
   reply <span class="Constant">36</span>
 ]
 container d1 [
-  <span class="Normal">p</span>:number
-  <span class="Normal">q</span>:number
+  <span class="Normal">p</span>:num
+  <span class="Normal">q</span>:num
 ]
 $error: <span class="Constant">0</span>
 
@@ -103,11 +103,11 @@ $error: <span class="Constant">0</span>
 <span class="Special">% Hide_errors = true;</span>
 def main [
   local-scope
-  <span class="Normal">x</span>:address:number<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
   foo x
 ]
 <span class="Comment"># immutable address to primitive</span>
-def foo x:address:number [
+def foo x:&amp;:num [
   local-scope
   load-ingredients
   *x<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
@@ -137,10 +137,10 @@ def foo x:point-number [
 <span class="Delimiter">:(scenario can_modify_immutable_pointers)</span>
 def main [
   local-scope
-  <span class="Normal">x</span>:address:number<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
   foo x
 ]
-def foo x:address:number [
+def foo x:&amp;:num [
   local-scope
   load-ingredients
   <span class="Comment"># modify the address, not the payload</span>
@@ -152,10 +152,10 @@ $error: <span class="Constant">0</span>
 <span class="Special">% Hide_errors = true;</span>
 def main [
   local-scope
-  <span class="Normal">x</span>:address:number<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
   foo x
 ]
-def foo x:address:number [
+def foo x:&amp;:num [
   local-scope
   load-ingredients
   <span class="Comment"># modify address; ok</span>
@@ -170,15 +170,15 @@ def foo x:address:number [
 <span class="Special">% Hide_errors = true;</span>
 def main [
   local-scope
-  <span class="Normal">p</span>:address:point<span class="Special"> &lt;- </span><span class="Normal">new</span> point:type
+  <span class="Normal">p</span>:&amp;:point<span class="Special"> &lt;- </span><span class="Normal">new</span> point:type
   foo p
 ]
-def foo p:address:point [
+def foo p:&amp;:point [
   local-scope
   load-ingredients
   bar p
 ]
-def bar p:address:point <span class="Delimiter">-&gt;</span> p:address:point [
+def bar p:&amp;:point <span class="Delimiter">-&gt;</span> p:&amp;:point [
   local-scope
   load-ingredients
   <span class="Comment"># p could be modified here, but it doesn't have to be, it's already marked</span>
@@ -190,13 +190,13 @@ def bar p:address:point <span class="Delimiter">-&gt;</span> p:address:point [
 <span class="Special">% Hide_errors = true;</span>
 def main [
   local-scope
-  <span class="Normal">p</span>:address:point<span class="Special"> &lt;- </span><span class="Normal">new</span> point:type
+  <span class="Normal">p</span>:&amp;:point<span class="Special"> &lt;- </span><span class="Normal">new</span> point:type
   foo p
 ]
-def foo p:address:point [
+def foo p:&amp;:point [
   local-scope
   load-ingredients
-  <span class="Normal">q</span>:address:point<span class="Special"> &lt;- </span>copy p
+  <span class="Normal">q</span>:&amp;:point<span class="Special"> &lt;- </span>copy p
   *q<span class="Special"> &lt;- </span>put *q<span class="Delimiter">,</span> x:offset<span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
 <span class="traceContains">+error: foo: cannot modify 'q' in instruction '*q &lt;- put *q, x:offset, 34' because that would modify p which is an ingredient of recipe foo but not also a product</span>
@@ -204,13 +204,13 @@ def foo p:address:point [
 <span class="Delimiter">:(scenario can_modify_copies_of_mutable_ingredients)</span>
 def main [
   local-scope
-  <span class="Normal">p</span>:address:point<span class="Special"> &lt;- </span><span class="Normal">new</span> point:type
+  <span class="Normal">p</span>:&amp;:point<span class="Special"> &lt;- </span><span class="Normal">new</span> point:type
   foo p
 ]
-def foo p:address:point <span class="Delimiter">-&gt;</span> p:address:point [
+def foo p:&amp;:point <span class="Delimiter">-&gt;</span> p:&amp;:point [
   local-scope
   load-ingredients
-  <span class="Normal">q</span>:address:point<span class="Special"> &lt;- </span>copy p
+  <span class="Normal">q</span>:&amp;:point<span class="Special"> &lt;- </span>copy p
   *q<span class="Special"> &lt;- </span>put *q<span class="Delimiter">,</span> x:offset<span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
 $error: <span class="Constant">0</span>
@@ -218,32 +218,32 @@ $error: <span class="Constant">0</span>
 <span class="Delimiter">:(scenario cannot_modify_address_inside_immutable_ingredients)</span>
 <span class="Special">% Hide_errors = true;</span>
 container foo [
-  <span class="Normal">x</span>:address:array:number  <span class="Comment"># contains an address</span>
+  <span class="Normal">x</span>:&amp;:@:num  <span class="Comment"># contains an address</span>
 ]
 def main [
   <span class="Comment"># don't run anything</span>
 ]
-def foo a:address:foo [
+def foo a:&amp;:foo [
   local-scope
   load-ingredients
-  <span class="Normal">x</span>:address:array:number<span class="Special"> &lt;- </span>get *a<span class="Delimiter">,</span> x:offset  <span class="Comment"># just a regular get of the container</span>
+  <span class="Normal">x</span>:&amp;:@:num<span class="Special"> &lt;- </span>get *a<span class="Delimiter">,</span> x:offset  <span class="Comment"># just a regular get of the container</span>
   *x<span class="Special"> &lt;- </span>put-index *x<span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">34</span>  <span class="Comment"># but then a put-index on the result</span>
 ]
 <span class="traceContains">+error: foo: cannot modify 'x' in instruction '*x &lt;- put-index *x, 0, 34' because that would modify a which is an ingredient of recipe foo but not also a product</span>
 
 <span class="Delimiter">:(scenario cannot_modify_address_inside_immutable_ingredients_2)</span>
 container foo [
-  <span class="Normal">x</span>:address:array:number  <span class="Comment"># contains an address</span>
+  <span class="Normal">x</span>:&amp;:@:num  <span class="Comment"># contains an address</span>
 ]
 def main [
   <span class="Comment"># don't run anything</span>
 ]
-def foo a:address:foo [
+def foo a:&amp;:foo [
   local-scope
   load-ingredients
   <span class="Normal">b</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">0</span>
   <span class="Comment"># modify b, completely unrelated to immutable ingredient a</span>
-  <span class="Normal">x</span>:address:array:number<span class="Special"> &lt;- </span>get b<span class="Delimiter">,</span> x:offset
+  <span class="Normal">x</span>:&amp;:@:num<span class="Special"> &lt;- </span>get b<span class="Delimiter">,</span> x:offset
   *x<span class="Special"> &lt;- </span>put-index *x<span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
 $error: <span class="Constant">0</span>
@@ -251,51 +251,51 @@ $error: <span class="Constant">0</span>
 <span class="Delimiter">:(scenario cannot_modify_address_inside_immutable_ingredients_3)</span>
 <span class="Special">% Hide_errors = true;</span>
 container foo [
-  <span class="Normal">x</span>:number
+  <span class="Normal">x</span>:num
 ]
 def main [
   <span class="Comment"># don't run anything</span>
 ]
-def foo a:address:array:address:number [
+def foo a:&amp;:@:&amp;:num [
   local-scope
   load-ingredients
-  <span class="Normal">x</span>:address:number<span class="Special"> &lt;- </span>index *a<span class="Delimiter">,</span> <span class="Constant">0</span>  <span class="Comment"># just a regular index of the array</span>
+  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span>index *a<span class="Delimiter">,</span> <span class="Constant">0</span>  <span class="Comment"># just a regular index of the array</span>
   *x<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>  <span class="Comment"># but then modify the result</span>
 ]
 <span class="traceContains">+error: foo: cannot modify 'x' in instruction '*x &lt;- copy 34' because that would modify a which is an ingredient of recipe foo but not also a product</span>
 
 <span class="Delimiter">:(scenario cannot_modify_address_inside_immutable_ingredients_4)</span>
 container foo [
-  <span class="Normal">x</span>:address:array:number  <span class="Comment"># contains an address</span>
+  <span class="Normal">x</span>:&amp;:@:num  <span class="Comment"># contains an address</span>
 ]
 def main [
   <span class="Comment"># don't run anything</span>
 ]
-def foo a:address:array:address:number [
+def foo a:&amp;:@:&amp;:num [
   local-scope
   load-ingredients
-  <span class="Normal">b</span>:address:array:address:number<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Delimiter">{(</span>address number<span class="Delimiter">)</span>: type<span class="Delimiter">},</span> <span class="Constant">3</span>
+  <span class="Normal">b</span>:&amp;:@:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Delimiter">{(</span>address number<span class="Delimiter">)</span>: type<span class="Delimiter">},</span> <span class="Constant">3</span>
   <span class="Comment"># modify b, completely unrelated to immutable ingredient a</span>
-  <span class="Normal">x</span>:address:number<span class="Special"> &lt;- </span>index *b<span class="Delimiter">,</span> <span class="Constant">0</span>
+  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span>index *b<span class="Delimiter">,</span> <span class="Constant">0</span>
   *x<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
 ]
 $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario can_traverse_immutable_ingredients)</span>
 container test-list [
-  <span class="Normal">next</span>:address:test-list
+  <span class="Normal">next</span>:&amp;:test-list
 ]
 def main [
   local-scope
-  <span class="Normal">p</span>:address:test-list<span class="Special"> &lt;- </span><span class="Normal">new</span> test-list:type
+  <span class="Normal">p</span>:&amp;:test-list<span class="Special"> &lt;- </span><span class="Normal">new</span> test-list:type
   foo p
 ]
-def foo p:address:test-list [
+def foo p:&amp;:test-list [
   local-scope
   load-ingredients
-  <span class="Normal">p2</span>:address:test-list<span class="Special"> &lt;- </span>bar p
+  <span class="Normal">p2</span>:&amp;:test-list<span class="Special"> &lt;- </span>bar p
 ]
-def bar x:address:test-list <span class="Delimiter">-&gt;</span> y:address:test-list [
+def bar x:&amp;:test-list <span class="Delimiter">-&gt;</span> y:&amp;:test-list [
   local-scope
   load-ingredients
   y<span class="Special"> &lt;- </span>get *x<span class="Delimiter">,</span> next:offset
@@ -304,11 +304,11 @@ $error: <span class="Constant">0</span>
 
 <span class="Delimiter">:(scenario treat_optional_ingredients_as_mutable)</span>
 def main [
-  <span class="Normal">k</span>:address:number<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">k</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
   test k
 ]
 <span class="Comment"># recipe taking an immutable address ingredient</span>
-def test k:address:number [
+def test k:&amp;:num [
   local-scope
   load-ingredients
   foo k
@@ -317,7 +317,7 @@ def test k:address:number [
 def foo <span class="Delimiter">-&gt;</span> [
   local-scope
   load-ingredients
-  <span class="Normal">k</span>:address:number<span class="Delimiter">,</span> found?:boolean<span class="Special"> &lt;- </span>next-ingredient
+  <span class="Normal">k</span>:&amp;:num<span class="Delimiter">,</span> found?:<span class="Normal">bool</span><span class="Special"> &lt;- </span>next-ingredient
   <span class="Comment"># we don't further check k for immutability, but assume it's mutable</span>
 ]
 $error: <span class="Constant">0</span>
@@ -326,10 +326,10 @@ $error: <span class="Constant">0</span>
 <span class="Special">% Hide_errors = true;</span>
 def main [
   local-scope
-  <span class="Normal">p</span>:address:point<span class="Special"> &lt;- </span><span class="Normal">new</span> point:type
+  <span class="Normal">p</span>:&amp;:point<span class="Special"> &lt;- </span><span class="Normal">new</span> point:type
   foo p
 ]
-def foo p:address:point [
+def foo p:&amp;:point [
   local-scope
   load-ingredients
   bar p
@@ -337,28 +337,28 @@ def foo p:address:point [
 def bar [
   local-scope
   load-ingredients
-  <span class="Normal">p</span>:address:point<span class="Special"> &lt;- </span>next-ingredient  <span class="Comment"># optional ingredient; assumed to be mutable</span>
+  <span class="Normal">p</span>:&amp;:point<span class="Special"> &lt;- </span>next-ingredient  <span class="Comment"># optional ingredient; assumed to be mutable</span>
 ]
 <span class="traceContains">+error: foo: cannot modify 'p' in instruction 'bar p' because it's an ingredient of recipe foo but not also a product</span>
 
 <span class="Comment">//: when checking for immutable ingredients, remember to take space into account</span>
 <span class="Delimiter">:(scenario check_space_of_reagents_in_immutability_checks)</span>
 def main [
-  <span class="Normal">a</span>:address:array:location<span class="Special"> &lt;- </span><span class="Normal">new</span>-closure
-  <span class="Normal">b</span>:address:number<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
-  run-closure b:address:number<span class="Delimiter">,</span> a:address:array:location
+  <span class="Normal">a</span>:space<span class="Special"> &lt;- </span><span class="Normal">new</span>-closure
+  <span class="Normal">b</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  run-closure b:&amp;:num<span class="Delimiter">,</span> a:space
 ]
 def <span class="Normal">new</span>-closure [
   <span class="Normal">new</span>-<span class="Normal">default</span>-space
-  <span class="Normal">x</span>:address:number<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
+  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> number:type
   <span class="Identifier">return</span> <span class="Normal">default</span>-space
 ]
-def run-closure x:address:number<span class="Delimiter">,</span> s:address:array:location [
+def run-closure x:&amp;:num<span class="Delimiter">,</span> s:space [
   local-scope
   load-ingredients
-  <span class="Constant">0</span>:address:array:location/names:<span class="Normal">new</span>-closure<span class="Special"> &lt;- </span>copy s
+  <span class="Constant">0</span>:space/names:<span class="Normal">new</span>-closure<span class="Special"> &lt;- </span>copy s
   <span class="Comment"># different space; always mutable</span>
-  *x:address:number/space:<span class="Constant">1</span><span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
+  *x:&amp;:num/space:<span class="Constant">1</span><span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
 ]
 $error: <span class="Constant">0</span>
 
@@ -441,21 +441,21 @@ set&lt;<span class="Normal">int</span>&gt; scan_contained_in_product_indices<spa
 <span class="Delimiter">:(scenario immutability_infects_contained_in_variables)</span>
 <span class="Special">% Hide_errors = true;</span>
 container test-list [
-  <span class="Normal">value</span>:number
-  <span class="Normal">next</span>:address:test-list
+  <span class="Normal">value</span>:num
+  <span class="Normal">next</span>:&amp;:test-list
 ]
 def main [
   local-scope
-  <span class="Normal">p</span>:address:test-list<span class="Special"> &lt;- </span><span class="Normal">new</span> test-list:type
+  <span class="Normal">p</span>:&amp;:test-list<span class="Special"> &lt;- </span><span class="Normal">new</span> test-list:type
   foo p
 ]
-def foo p:address:test-list [  <span class="Comment"># p is immutable</span>
+def foo p:&amp;:test-list [  <span class="Comment"># p is immutable</span>
   local-scope
   load-ingredients
-  <span class="Normal">p2</span>:address:test-list<span class="Special"> &lt;- </span>test-next p  <span class="Comment"># p2 is immutable</span>
+  <span class="Normal">p2</span>:&amp;:test-list<span class="Special"> &lt;- </span>test-next p  <span class="Comment"># p2 is immutable</span>
   *p2<span class="Special"> &lt;- </span>put *p2<span class="Delimiter">,</span> value:offset<span class="Delimiter">,</span> <span class="Constant">34</span>
 ]
-def test-next x:address:test-list <span class="Delimiter">-&gt;</span> y:address:test-list/contained-in:x [
+def test-next x:&amp;:test-list <span class="Delimiter">-&gt;</span> y:&amp;:test-list/contained-in:x [
   local-scope
   load-ingredients
   y<span class="Special"> &lt;- </span>get *x<span class="Delimiter">,</span> next:offset
@@ -561,26 +561,26 @@ set&lt;<span class="Normal">int</span>&gt; ingredient_indices<span class="Delimi
 <span class="Delimiter">:(scenarios transform)</span>
 <span class="Delimiter">:(scenario can_modify_contained_in_addresses)</span>
 container test-list [
-  <span class="Normal">value</span>:number
-  <span class="Normal">next</span>:address:test-list
+  <span class="Normal">value</span>:num
+  <span class="Normal">next</span>:&amp;:test-list
 ]
 def main [
   local-scope
-  <span class="Normal">p</span>:address:test-list<span class="Special"> &lt;- </span><span class="Normal">new</span> test-list:type
+  <span class="Normal">p</span>:&amp;:test-list<span class="Special"> &lt;- </span><span class="Normal">new</span> test-list:type
   foo p
 ]
-def foo p:address:test-list <span class="Delimiter">-&gt;</span> p:address:test-list [
+def foo p:&amp;:test-list <span class="Delimiter">-&gt;</span> p:&amp;:test-list [
   local-scope
   load-ingredients
-  <span class="Normal">p2</span>:address:test-list<span class="Special"> &lt;- </span>test-next p
+  <span class="Normal">p2</span>:&amp;:test-list<span class="Special"> &lt;- </span>test-next p
   p<span class="Special"> &lt;- </span>test-remove p2<span class="Delimiter">,</span> p
 ]
-def test-next x:address:test-list <span class="Delimiter">-&gt;</span> y:address:test-list [
+def test-next x:&amp;:test-list <span class="Delimiter">-&gt;</span> y:&amp;:test-list [
   local-scope
   load-ingredients
   y<span class="Special"> &lt;- </span>get *x<span class="Delimiter">,</span> next:offset
 ]
-def test-remove x:address:test-list/contained-in:from<span class="Delimiter">,</span> from:address:test-list <span class="Delimiter">-&gt;</span> from:address:test-list [
+def test-remove x:&amp;:test-list/contained-in:from<span class="Delimiter">,</span> from:&amp;:test-list <span class="Delimiter">-&gt;</span> from:&amp;:test-list [
   local-scope
   load-ingredients
   *x<span class="Special"> &lt;- </span>put *x<span class="Delimiter">,</span> value:offset<span class="Delimiter">,</span> <span class="Constant">34</span>  <span class="Comment"># can modify x</span>