1778

author: Kartik K. Agaram <vc@akkartik.com> 2015-07-13 20:53:41 -0700
committer: Kartik K. Agaram <vc@akkartik.com> 2015-07-13 20:53:41 -0700
commit: 83fcebf3210b638d9f8248e0007e9f0c9804980a (patch)
tree: 95c4855bef341e1d46eb4725b54a3eaaf6858f08 /html
parent: 8b9f1750c74c7d3cca99d6949a90cd61eb8e0218 (diff)
download: mu-83fcebf3210b638d9f8248e0007e9f0c9804980a.tar.gz
36 files changed, 361 insertions, 166 deletions
diff --git a/html/025trace.cc.html b/html/027trace.cc.html
index 3ff21726..a0823ce3 100644
--- a/html/025trace.cc.html
+++ b/html/027trace.cc.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 <meta http-equiv="content-type" content="text/html; charset=UTF-8">
-<title>Mu - 025trace.cc</title>
+<title>Mu - 027trace.cc</title>
 <meta name="Generator" content="Vim/7.4">
 <meta name="plugin-version" content="vim7.4_v1">
 <meta name="syntax" content="cpp">
diff --git a/html/026assert.cc.html b/html/028assert.cc.html
index af3588b4..68951156 100644
--- a/html/026assert.cc.html
+++ b/html/028assert.cc.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 <meta http-equiv="content-type" content="text/html; charset=UTF-8">
-<title>Mu - 026assert.cc</title>
+<title>Mu - 028assert.cc</title>
 <meta name="Generator" content="Vim/7.4">
 <meta name="plugin-version" content="vim7.4_v1">
 <meta name="syntax" content="cpp">
diff --git a/html/027debug.cc.html b/html/029debug.cc.html
index 4035f006..85f82582 100644
--- a/html/027debug.cc.html
+++ b/html/029debug.cc.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 <meta http-equiv="content-type" content="text/html; charset=UTF-8">
-<title>Mu - 027debug.cc</title>
+<title>Mu - 029debug.cc</title>
 <meta name="Generator" content="Vim/7.4">
 <meta name="plugin-version" content="vim7.4_v1">
 <meta name="syntax" content="cpp">
diff --git a/html/034call.cc.html b/html/034call.cc.html
index 291dfeb9..97bd4039 100644
--- a/html/034call.cc.html
+++ b/html/034call.cc.html
@@ -149,7 +149,7 @@ while <span class="Delimiter">(</span>current_step_index<span class="Delimiter">
   Current_routine<span class="Delimiter">-&gt;</span>calls<span class="Delimiter">.</span>pop_front<span class="Delimiter">();</span>
   if <span class="Delimiter">(</span>Current_routine<span class="Delimiter">-&gt;</span>calls<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Identifier">return</span><span class="Delimiter">;</span>
   <span class="Comment">// Complete Call Fallthrough</span>
-  <span class="Comment">// todo: no results returned warning</span>
+  <span class="Comment">// todo: no products returned warning</span>
   ++current_step_index<span class="Delimiter">();</span>
 <span class="Delimiter">}</span>
 
diff --git a/html/036call_reply.cc.html b/html/036call_reply.cc.html
index 2738d935..ab73fdb7 100644
--- a/html/036call_reply.cc.html
+++ b/html/036call_reply.cc.html
@@ -64,7 +64,7 @@ case REPLY: <span class="Delimiter">{</span>
   <span class="Comment">// just in case 'main' returns a value, drop it for now</span>
   if <span class="Delimiter">(</span>Current_routine<span class="Delimiter">-&gt;</span>calls<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Identifier">goto</span> stop_running_current_routine<span class="Delimiter">;</span>
   const instruction&amp; caller_instruction = current_instruction<span class="Delimiter">();</span>
-  <span class="Comment">// make reply results available to caller</span>
+  <span class="Comment">// make reply products available to caller</span>
   copy<span class="Delimiter">(</span>ingredients<span class="Delimiter">.</span>begin<span class="Delimiter">(),</span> ingredients<span class="Delimiter">.</span>end<span class="Delimiter">(),</span> inserter<span class="Delimiter">(</span>products<span class="Delimiter">,</span> products<span class="Delimiter">.</span>begin<span class="Delimiter">()));</span>
   <span class="Comment">// check that any reply ingredients with /same-as-ingredient connect up</span>
   <span class="Comment">// the corresponding ingredient and product in the caller.</span>
@@ -105,7 +105,7 @@ recipe f [
 <span class="Comment">//: In mu we'd like to assume that any instruction doesn't modify its</span>
 <span class="Comment">//: ingredients unless they're also products. The /same-as-ingredient inside</span>
 <span class="Comment">//: the recipe's 'reply' will help catch accidental misuse of such</span>
-<span class="Comment">//: 'ingredient-results' (sometimes called in-out parameters in other languages).</span>
+<span class="Comment">//: 'ingredient-products' (sometimes called in-out parameters in other languages).</span>
 
 <span class="Delimiter">:(scenario reply_same_as_ingredient)</span>
 <span class="Special">% Hide_warnings = true;</span>
diff --git a/html/047jump_label.cc.html b/html/041jump_label.cc.html
index 0573ff3c..9d5e0e4d 100644
--- a/html/047jump_label.cc.html
+++ b/html/041jump_label.cc.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 <meta http-equiv="content-type" content="text/html; charset=UTF-8">
-<title>Mu - 047jump_label.cc</title>
+<title>Mu - 041jump_label.cc</title>
 <meta name="Generator" content="Vim/7.4">
 <meta name="plugin-version" content="vim7.4_v1">
 <meta name="syntax" content="cpp">
diff --git a/html/041name.cc.html b/html/042name.cc.html
index a019f954..097b0c9f 100644
--- a/html/041name.cc.html
+++ b/html/042name.cc.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 <meta http-equiv="content-type" content="text/html; charset=UTF-8">
-<title>Mu - 041name.cc</title>
+<title>Mu - 042name.cc</title>
 <meta name="Generator" content="Vim/7.4">
 <meta name="plugin-version" content="vim7.4_v1">
 <meta name="syntax" content="cpp">
diff --git a/html/042new.cc.html b/html/043new.cc.html
index ec3963ed..a34f46fc 100644
--- a/html/042new.cc.html
+++ b/html/043new.cc.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 <meta http-equiv="content-type" content="text/html; charset=UTF-8">
-<title>Mu - 042new.cc</title>
+<title>Mu - 043new.cc</title>
 <meta name="Generator" content="Vim/7.4">
 <meta name="plugin-version" content="vim7.4_v1">
 <meta name="syntax" content="cpp">
diff --git a/html/043space.cc.html b/html/044space.cc.html
index f6d61fba..ca3a7bec 100644
--- a/html/043space.cc.html
+++ b/html/044space.cc.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 <meta http-equiv="content-type" content="text/html; charset=UTF-8">
-<title>Mu - 043space.cc</title>
+<title>Mu - 044space.cc</title>
 <meta name="Generator" content="Vim/7.4">
 <meta name="plugin-version" content="vim7.4_v1">
 <meta name="syntax" content="cpp">
@@ -85,17 +85,12 @@ default_space = <span class="Constant">0</span><span class="Delimiter">;</span>
 reagent r = absolutize<span class="Delimiter">(</span>x<span class="Delimiter">);</span>
 <span class="Delimiter">:(code)</span>
 reagent absolutize<span class="Delimiter">(</span>reagent x<span class="Delimiter">)</span> <span class="Delimiter">{</span>
-<span class="CommentedCode">//?   if (Recipe_ordinal.find(&quot;increment-counter&quot;) != Recipe_ordinal.end()) //? 1</span>
-<span class="CommentedCode">//?     cout &lt;&lt; &quot;AAA &quot; &lt;&lt; &quot;increment-counter/2: &quot; &lt;&lt; Recipe[Recipe_ordinal[&quot;increment-counter&quot;]].steps.at(2).products.at(0).to_string() &lt;&lt; '\n'; //? 1</span>
 <span class="CommentedCode">//?   cout &lt;&lt; &quot;absolutize &quot; &lt;&lt; x.to_string() &lt;&lt; '\n'; //? 4</span>
-<span class="CommentedCode">//?   cout &lt;&lt; is_raw(x) &lt;&lt; '\n'; //? 1</span>
   if <span class="Delimiter">(</span>is_raw<span class="Delimiter">(</span>x<span class="Delimiter">)</span> || is_dummy<span class="Delimiter">(</span>x<span class="Delimiter">))</span> <span class="Identifier">return</span> x<span class="Delimiter">;</span>
-<span class="CommentedCode">//?   cout &lt;&lt; &quot;not raw: &quot; &lt;&lt; x.to_string() &lt;&lt; '\n'; //? 1</span>
   if <span class="Delimiter">(</span>!x<span class="Delimiter">.</span>initialized<span class="Delimiter">)</span>
     raise &lt;&lt; current_instruction<span class="Delimiter">().</span>to_string<span class="Delimiter">()</span> &lt;&lt; <span class="Constant">&quot;: reagent not initialized: &quot;</span> &lt;&lt; x<span class="Delimiter">.</span>to_string<span class="Delimiter">()</span> &lt;&lt; die<span class="Delimiter">();</span>
   reagent r = x<span class="Delimiter">;</span>
   r<span class="Delimiter">.</span>set_value<span class="Delimiter">(</span>address<span class="Delimiter">(</span>r<span class="Delimiter">.</span>value<span class="Delimiter">,</span> space_base<span class="Delimiter">(</span>r<span class="Delimiter">)));</span>
-<span class="CommentedCode">//?   cout &lt;&lt; &quot;after absolutize: &quot; &lt;&lt; r.value &lt;&lt; '\n'; //? 1</span>
   r<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>pair&lt;string<span class="Delimiter">,</span> vector&lt;string&gt; &gt;<span class="Delimiter">(</span><span class="Constant">&quot;raw&quot;</span><span class="Delimiter">,</span> vector&lt;string&gt;<span class="Delimiter">()));</span>
   assert<span class="Delimiter">(</span>is_raw<span class="Delimiter">(</span>r<span class="Delimiter">));</span>
   <span class="Identifier">return</span> r<span class="Delimiter">;</span>
@@ -142,6 +137,53 @@ recipe main [
 <span class="Delimiter">:(after &quot;reagent tmp&quot; following &quot;case INDEX:&quot;)</span>
 tmp<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>pair&lt;string<span class="Delimiter">,</span> vector&lt;string&gt; &gt;<span class="Delimiter">(</span><span class="Constant">&quot;raw&quot;</span><span class="Delimiter">,</span> vector&lt;string&gt;<span class="Delimiter">()));</span>
 
+<span class="SalientComment">//:: convenience operation to automatically deduce the amount of space to</span>
+<span class="SalientComment">//:: allocate in a default space with names</span>
+
+<span class="Delimiter">:(scenario new_default_space)</span>
+recipe main [
+  new-default-space
+  x:number<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>:literal
+  y:number<span class="Special"> &lt;- </span>copy <span class="Constant">3</span>:literal
+]
+<span class="Comment"># allocate space for x and y, as well as the chaining slot at 0</span>
+<span class="traceContains">+mem: array size is 3</span>
+
+<span class="Delimiter">:(before &quot;End Disqualified Reagents&quot;)</span>
+if <span class="Delimiter">(</span>x<span class="Delimiter">.</span>name == <span class="Constant">&quot;number-of-locals&quot;</span><span class="Delimiter">)</span>
+  x<span class="Delimiter">.</span>initialized = <span class="Constant">true</span><span class="Delimiter">;</span>
+<span class="Delimiter">:(before &quot;End is_special_name Cases&quot;)</span>
+if <span class="Delimiter">(</span>s == <span class="Constant">&quot;number-of-locals&quot;</span><span class="Delimiter">)</span> <span class="Identifier">return</span> <span class="Constant">true</span><span class="Delimiter">;</span>
+
+<span class="Delimiter">:(before &quot;End Rewrite Instruction(curr)&quot;)</span>
+<span class="Comment">// rewrite `new-default-space` to</span>
+<span class="Comment">//   `default-space:address:array:location &lt;- new location:type, number-of-locals:literal`</span>
+<span class="Comment">// where N is Name[recipe][&quot;&quot;]</span>
+if <span class="Delimiter">(</span>curr<span class="Delimiter">.</span>name == <span class="Constant">&quot;new-default-space&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
+  curr<span class="Delimiter">.</span>operation = Recipe_ordinal[<span class="Constant">&quot;new&quot;</span>]<span class="Delimiter">;</span>
+  if <span class="Delimiter">(</span>!curr<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>empty<span class="Delimiter">())</span>
+    raise &lt;&lt; <span class="Constant">&quot;new-default-space can't take any ingredients</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span><span class="Delimiter">;</span>
+  curr<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>reagent<span class="Delimiter">(</span><span class="Constant">&quot;location:type&quot;</span><span class="Delimiter">));</span>
+  curr<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>reagent<span class="Delimiter">(</span><span class="Constant">&quot;number-of-locals:literal&quot;</span><span class="Delimiter">));</span>
+  if <span class="Delimiter">(</span>!curr<span class="Delimiter">.</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">())</span>
+    raise &lt;&lt; <span class="Constant">&quot;new-default-space can't take any results</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span><span class="Delimiter">;</span>
+  curr<span class="Delimiter">.</span>products<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>reagent<span class="Delimiter">(</span><span class="Constant">&quot;default-space:address:array:location&quot;</span><span class="Delimiter">));</span>
+<span class="Delimiter">}</span>
+<span class="Delimiter">:(after &quot;vector&lt;double&gt; read_memory(reagent x)&quot;)</span>
+  if <span class="Delimiter">(</span>x<span class="Delimiter">.</span>name == <span class="Constant">&quot;number-of-locals&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
+    vector&lt;double&gt; result<span class="Delimiter">;</span>
+    result<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>Name[Recipe_ordinal[current_recipe_name<span class="Delimiter">()</span>]][<span class="Constant">&quot;&quot;</span>]<span class="Delimiter">);</span>
+    if <span class="Delimiter">(</span>result<span class="Delimiter">.</span>back<span class="Delimiter">()</span> == <span class="Constant">0</span><span class="Delimiter">)</span>
+      raise &lt;&lt; <span class="Constant">&quot;no space allocated for default-space in recipe &quot;</span> &lt;&lt; current_recipe_name<span class="Delimiter">()</span> &lt;&lt; <span class="Constant">&quot;; are you using names</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span><span class="Delimiter">;</span>
+    <span class="Identifier">return</span> result<span class="Delimiter">;</span>
+  <span class="Delimiter">}</span>
+<span class="Delimiter">:(after &quot;void write_memory(reagent x, vector&lt;double&gt; data)&quot;)</span>
+  if <span class="Delimiter">(</span>x<span class="Delimiter">.</span>name == <span class="Constant">&quot;number-of-locals&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
+    assert<span class="Delimiter">(</span>scalar<span class="Delimiter">(</span>data<span class="Delimiter">));</span>
+    raise &lt;&lt; <span class="Constant">&quot;can't write to special variable number-of-locals</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span><span class="Delimiter">;</span>
+    <span class="Identifier">return</span><span class="Delimiter">;</span>
+  <span class="Delimiter">}</span>
+
 <span class="SalientComment">//:: helpers</span>
 
 <span class="Delimiter">:(code)</span>
@@ -163,7 +205,6 @@ long long int address<span class="Delimiter">(</span>long long int offset<span c
   if <span class="Delimiter">(</span>x<span class="Delimiter">.</span>name == <span class="Constant">&quot;default-space&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
     assert<span class="Delimiter">(</span>scalar<span class="Delimiter">(</span>data<span class="Delimiter">));</span>
     Current_routine<span class="Delimiter">-&gt;</span>calls<span class="Delimiter">.</span>front<span class="Delimiter">().</span>default_space = data<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">);</span>
-<span class="CommentedCode">//?     cout &lt;&lt; &quot;AAA &quot; &lt;&lt; Current_routine-&gt;calls.front().default_space &lt;&lt; '\n'; //? 1</span>
     <span class="Identifier">return</span><span class="Delimiter">;</span>
   <span class="Delimiter">}</span>
 
diff --git a/html/044space_surround.cc.html b/html/045space_surround.cc.html
index d39091d9..a01f4094 100644
--- a/html/044space_surround.cc.html
+++ b/html/045space_surround.cc.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 <meta http-equiv="content-type" content="text/html; charset=UTF-8">
-<title>Mu - 044space_surround.cc</title>
+<title>Mu - 045space_surround.cc</title>
 <meta name="Generator" content="Vim/7.4">
 <meta name="plugin-version" content="vim7.4_v1">
 <meta name="syntax" content="cpp">
@@ -18,7 +18,6 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #a04060; }
 .Special { color: #ff6060; }
-.CommentedCode { color: #6c6c6c; }
 .Identifier { color: #804000; }
 -->
 </style>
@@ -60,24 +59,18 @@ recipe main [
 
 <span class="Delimiter">:(replace{} &quot;long long int space_base(const reagent&amp; x)&quot;)</span>
 long long int space_base<span class="Delimiter">(</span>const reagent&amp; x<span class="Delimiter">)</span> <span class="Delimiter">{</span>
-<span class="CommentedCode">//?   cerr &lt;&lt; &quot;space_base: &quot; &lt;&lt; x.to_string() &lt;&lt; '\n'; //? 1</span>
   <span class="Identifier">return</span> space_base<span class="Delimiter">(</span>x<span class="Delimiter">,</span> space_index<span class="Delimiter">(</span>x<span class="Delimiter">),</span> Current_routine<span class="Delimiter">-&gt;</span>calls<span class="Delimiter">.</span>front<span class="Delimiter">().</span>default_space<span class="Delimiter">);</span>
 <span class="Delimiter">}</span>
 
 long long int space_base<span class="Delimiter">(</span>const reagent&amp; x<span class="Delimiter">,</span> long long int space_index<span class="Delimiter">,</span> long long int base<span class="Delimiter">)</span> <span class="Delimiter">{</span>
-<span class="CommentedCode">//?   trace(&quot;foo&quot;) &lt;&lt; &quot;base of space &quot; &lt;&lt; space_index &lt;&lt; '\n'; //? 1</span>
-<span class="CommentedCode">//?   cerr &lt;&lt; &quot;space_base sub: &quot; &lt;&lt; x.to_string() &lt;&lt; '\n'; //? 1</span>
   if <span class="Delimiter">(</span>space_index == <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
-<span class="CommentedCode">//?     trace(&quot;foo&quot;) &lt;&lt; &quot;base of space &quot; &lt;&lt; space_index &lt;&lt; &quot; is &quot; &lt;&lt; base &lt;&lt; '\n'; //? 1</span>
     <span class="Identifier">return</span> base<span class="Delimiter">;</span>
   <span class="Delimiter">}</span>
-<span class="CommentedCode">//?   trace(&quot;foo&quot;) &lt;&lt; &quot;base of space &quot; &lt;&lt; space_index &lt;&lt; &quot; is &quot; &lt;&lt; Memory[base+1] &lt;&lt; '\n'; //? 1</span>
   long long int result = space_base<span class="Delimiter">(</span>x<span class="Delimiter">,</span> space_index-<span class="Constant">1</span><span class="Delimiter">,</span> Memory[base+<span class="Constant">1</span>]<span class="Delimiter">);</span>
   <span class="Identifier">return</span> result<span class="Delimiter">;</span>
 <span class="Delimiter">}</span>
 
 long long int space_index<span class="Delimiter">(</span>const reagent&amp; x<span class="Delimiter">)</span> <span class="Delimiter">{</span>
-<span class="CommentedCode">//?   cerr &lt;&lt; &quot;space_index: &quot; &lt;&lt; x.to_string() &lt;&lt; '\n'; //? 1</span>
   for <span class="Delimiter">(</span>long long int i = <span class="Comment">/*</span><span class="Comment">skip name:type</span><span class="Comment">*/</span><span class="Constant">1</span><span class="Delimiter">;</span> i &lt; SIZE<span class="Delimiter">(</span>x<span class="Delimiter">.</span>properties<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
     if <span class="Delimiter">(</span>x<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>first == <span class="Constant">&quot;space&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
       assert<span class="Delimiter">(</span>SIZE<span class="Delimiter">(</span>x<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>second<span class="Delimiter">)</span> == <span class="Constant">1</span><span class="Delimiter">);</span>
diff --git a/html/045closure_name.cc.html b/html/046closure_name.cc.html
index 892495e8..9052fee1 100644
--- a/html/045closure_name.cc.html
+++ b/html/046closure_name.cc.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 <meta http-equiv="content-type" content="text/html; charset=UTF-8">
-<title>Mu - 045closure_name.cc</title>
+<title>Mu - 046closure_name.cc</title>
 <meta name="Generator" content="Vim/7.4">
 <meta name="plugin-version" content="vim7.4_v1">
 <meta name="syntax" content="cpp">
diff --git a/html/047global.cc.html b/html/047global.cc.html
new file mode 100644
index 00000000..da036490
--- /dev/null
+++ b/html/047global.cc.html
@@ -0,0 +1,113 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+<html>
+<head>
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
+<title>Mu - 047global.cc</title>
+<meta name="Generator" content="Vim/7.4">
+<meta name="plugin-version" content="vim7.4_v1">
+<meta name="syntax" content="cpp">
+<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy=">
+<meta name="colorscheme" content="minimal">
+<style type="text/css">
+<!--
+pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
+body { font-family: monospace; color: #eeeeee; background-color: #080808; }
+* { font-size: 1.05em; }
+.traceContains { color: #008000; }
+.cSpecial { color: #008000; }
+.Constant { color: #00a0a0; }
+.Comment { color: #9090ff; }
+.Delimiter { color: #a04060; }
+.Special { color: #ff6060; }
+.Identifier { color: #804000; }
+.CommentedCode { color: #6c6c6c; }
+-->
+</style>
+
+<script type='text/javascript'>
+<!--
+
+-->
+</script>
+</head>
+<body>
+<pre id='vimCodeElement'>
+<span class="Comment">// So far we have local variables, and we can nest local variables of short</span>
+<span class="Comment">// lifetimes inside longer ones. Now let's support 'global' variables that</span>
+<span class="Comment">// last for the life of a routine. If we create multiple routines they won't</span>
+<span class="Comment">// have access to each other's globals.</span>
+
+<span class="Delimiter">:(scenario global_space)</span>
+recipe main [
+  <span class="Comment"># pretend arrays; in practice we'll use new</span>
+  <span class="Constant">10</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">5</span>:literal
+  <span class="Constant">20</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">5</span>:literal
+  <span class="Comment"># actual start of this recipe</span>
+  global-space:address:array:location<span class="Special"> &lt;- </span>copy <span class="Constant">20</span>:literal
+  default-space:address:array:location<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>:literal
+  <span class="Constant">1</span>:number<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>:literal
+  <span class="Constant">1</span>:number/space:global<span class="Special"> &lt;- </span>copy <span class="Constant">24</span>:literal
+]
+<span class="traceContains">+mem: storing 23 in location 12</span>
+<span class="traceContains">+mem: storing 24 in location 22</span>
+
+<span class="Comment">//: to support it, create another special variable called global space</span>
+<span class="Delimiter">:(before &quot;End Disqualified Reagents&quot;)</span>
+if <span class="Delimiter">(</span>x<span class="Delimiter">.</span>name == <span class="Constant">&quot;global-space&quot;</span><span class="Delimiter">)</span>
+  x<span class="Delimiter">.</span>initialized = <span class="Constant">true</span><span class="Delimiter">;</span>
+<span class="Delimiter">:(before &quot;End is_special_name Cases&quot;)</span>
+if <span class="Delimiter">(</span>s == <span class="Constant">&quot;global-space&quot;</span><span class="Delimiter">)</span> <span class="Identifier">return</span> <span class="Constant">true</span><span class="Delimiter">;</span>
+
+<span class="Comment">//: writes to this variable go to a field in the current routine</span>
+<span class="Delimiter">:(before &quot;End routine Fields&quot;)</span>
+long long int global_space<span class="Delimiter">;</span>
+<span class="Delimiter">:(before &quot;End routine Constructor&quot;)</span>
+global_space = <span class="Constant">0</span><span class="Delimiter">;</span>
+<span class="Delimiter">:(after &quot;void write_memory(reagent x, vector&lt;double&gt; data)&quot;)</span>
+  if <span class="Delimiter">(</span>x<span class="Delimiter">.</span>name == <span class="Constant">&quot;global-space&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
+    assert<span class="Delimiter">(</span>scalar<span class="Delimiter">(</span>data<span class="Delimiter">));</span>
+    if <span class="Delimiter">(</span>Current_routine<span class="Delimiter">-&gt;</span>global_space<span class="Delimiter">)</span>
+      raise &lt;&lt; <span class="Constant">&quot;routine already has a global-space; you can't over-write your globals&quot;</span><span class="Delimiter">;</span>
+    Current_routine<span class="Delimiter">-&gt;</span>global_space = data<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">);</span>
+    <span class="Identifier">return</span><span class="Delimiter">;</span>
+  <span class="Delimiter">}</span>
+
+<span class="Comment">//: now marking variables as /space:global looks them up inside this field</span>
+<span class="Delimiter">:(after &quot;long long int space_base(const reagent&amp; x)&quot;)</span>
+  if <span class="Delimiter">(</span>is_global<span class="Delimiter">(</span>x<span class="Delimiter">))</span> <span class="Delimiter">{</span>
+    if <span class="Delimiter">(</span>!Current_routine<span class="Delimiter">-&gt;</span>global_space<span class="Delimiter">)</span>
+      raise &lt;&lt; <span class="Constant">&quot;routine has no global space</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; die<span class="Delimiter">();</span>
+    <span class="Identifier">return</span> Current_routine<span class="Delimiter">-&gt;</span>global_space<span class="Delimiter">;</span>
+  <span class="Delimiter">}</span>
+
+<span class="Comment">//: for now let's not bother giving global variables names.</span>
+<span class="Comment">//: don't want to make them too comfortable to use.</span>
+
+<span class="Delimiter">:(scenario global_space_with_names)</span>
+<span class="Special">% Hide_warnings = true;</span>
+recipe main [
+  global-space:address:array:location<span class="Special"> &lt;- </span>new location:type<span class="Delimiter">,</span> <span class="Constant">10</span>:literal
+  x:number<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>:literal
+  <span class="Constant">1</span>:number/space:global<span class="Special"> &lt;- </span>copy <span class="Constant">24</span>:literal
+]
+<span class="Comment"># don't warn that we're mixing numeric addresses and names</span>
+$warn: <span class="Constant">0</span>
+
+<span class="Delimiter">:(after &quot;bool is_numeric_location(const reagent&amp; x)&quot;)</span>
+  if <span class="Delimiter">(</span>is_global<span class="Delimiter">(</span>x<span class="Delimiter">))</span> <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
+
+<span class="Comment">//: helpers</span>
+
+<span class="Delimiter">:(code)</span>
+bool is_global<span class="Delimiter">(</span>const reagent&amp; x<span class="Delimiter">)</span> <span class="Delimiter">{</span>
+<span class="CommentedCode">//?   cerr &lt;&lt; x.to_string() &lt;&lt; '\n'; //? 1</span>
+  for <span class="Delimiter">(</span>long long int i = <span class="Comment">/*</span><span class="Comment">skip name:type</span><span class="Comment">*/</span><span class="Constant">1</span><span class="Delimiter">;</span> i &lt; SIZE<span class="Delimiter">(</span>x<span class="Delimiter">.</span>properties<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
+    if <span class="Delimiter">(</span>x<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>first == <span class="Constant">&quot;space&quot;</span><span class="Delimiter">)</span>
+      <span class="Identifier">return</span> !x<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>second<span class="Delimiter">.</span>empty<span class="Delimiter">()</span> &amp;&amp; x<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>second<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)</span> == <span class="Constant">&quot;global&quot;</span><span class="Delimiter">;</span>
+  <span class="Delimiter">}</span>
+  <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
+<span class="Delimiter">}</span>
+</pre>
+</body>
+</html>
+<!-- vim: set foldmethod=manual : -->
diff --git a/html/046tangle.cc.html b/html/048tangle.cc.html
index 15a61c22..eb665a5b 100644
--- a/html/046tangle.cc.html
+++ b/html/048tangle.cc.html
@@ -2,7 +2,7 @@
 <html>
 <head>
 <meta http-equiv="content-type" content="text/html; charset=UTF-8">
-<title>Mu - 046tangle.cc</title>
+<title>Mu - 048tangle.cc</title>
 <meta name="Generator" content="Vim/7.4">
 <meta name="plugin-version" content="vim7.4_v1">
 <meta name="syntax" content="cpp">
diff --git a/html/060string.mu.html b/html/060string.mu.html
index 45ff99e2..eb98cd88 100644
--- a/html/060string.mu.html
+++ b/html/060string.mu.html
@@ -13,14 +13,14 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
-.muScenario { color: #00af00; }
+.muRecipe { color: #ff8700; }
 .Delimiter { color: #a04060; }
+.muScenario { color: #00af00; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
 .CommentedCode { color: #6c6c6c; }
 .muControl { color: #c0a020; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
 
@@ -35,7 +35,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 <span class="Comment"># Some useful helpers for dealing with strings.</span>
 
 <span class="muRecipe">recipe</span> string-equal [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   a:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   a-len:number<span class="Special"> &lt;- </span>length a:address:array:character/deref
   b:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -138,7 +138,7 @@ container buffer [
 ]
 
 <span class="muRecipe">recipe</span> new-buffer [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
 <span class="CommentedCode">#?   $print default-space:address:array:location, [</span>
 <span class="CommentedCode">#? ]</span>
   result:address:buffer<span class="Special"> &lt;- </span>new buffer:type
@@ -154,7 +154,7 @@ container buffer [
 ]
 
 <span class="muRecipe">recipe</span> grow-buffer [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   in:address:buffer<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># double buffer size</span>
   x:address:address:array:character<span class="Special"> &lt;- </span>get-address in:address:buffer/deref, data:offset
@@ -177,7 +177,7 @@ container buffer [
 ]
 
 <span class="muRecipe">recipe</span> buffer-full? [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   in:address:buffer<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   len:number<span class="Special"> &lt;- </span>get in:address:buffer/deref, length:offset
   s:address:array:character<span class="Special"> &lt;- </span>get in:address:buffer/deref, data:offset
@@ -188,7 +188,7 @@ container buffer [
 
 <span class="Comment"># in:address:buffer &lt;- buffer-append in:address:buffer, c:character</span>
 <span class="muRecipe">recipe</span> buffer-append [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   in:address:buffer<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   c:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   len:address:number<span class="Special"> &lt;- </span>get-address in:address:buffer/deref, length:offset
@@ -222,7 +222,7 @@ container buffer [
 
 <span class="muScenario">scenario</span> buffer-append-works [
   run [
-    <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+    <span class="Constant">new-default-space</span>
     x:address:buffer<span class="Special"> &lt;- </span>new-buffer <span class="Constant">3:literal</span>
     s1:address:array:character<span class="Special"> &lt;- </span>get x:address:buffer/deref, data:offset
     x:address:buffer<span class="Special"> &lt;- </span>buffer-append x:address:buffer, <span class="Constant">97:literal</span>  <span class="Comment"># 'a'</span>
@@ -274,7 +274,7 @@ container buffer [
 
 <span class="muScenario">scenario</span> buffer-append-handles-backspace [
   run [
-    <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+    <span class="Constant">new-default-space</span>
     x:address:buffer<span class="Special"> &lt;- </span>new-buffer <span class="Constant">3:literal</span>
     x:address:buffer<span class="Special"> &lt;- </span>buffer-append x:address:buffer, <span class="Constant">97:literal</span>  <span class="Comment"># 'a'</span>
     x:address:buffer<span class="Special"> &lt;- </span>buffer-append x:address:buffer, <span class="Constant">98:literal</span>  <span class="Comment"># 'b'</span>
@@ -291,7 +291,7 @@ container buffer [
 
 <span class="Comment"># result:address:array:character &lt;- integer-to-decimal-string n:number</span>
 <span class="muRecipe">recipe</span> integer-to-decimal-string [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   n:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># is it zero?</span>
   <span class="Delimiter">{</span>
@@ -347,7 +347,7 @@ container buffer [
 ]
 
 <span class="muRecipe">recipe</span> buffer-to-array [
-  <span class="Constant">default-space</span>:address:array:character<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   in:address:buffer<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Delimiter">{</span>
     <span class="Comment"># propagate null buffer</span>
@@ -408,7 +408,7 @@ container buffer [
 
 <span class="Comment"># result:address:array:character &lt;- string-append a:address:array:character, b:address:array:character</span>
 <span class="muRecipe">recipe</span> string-append [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   <span class="Comment"># result = new character[a.length + b.length]</span>
   a:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   a-len:number<span class="Special"> &lt;- </span>length a:address:array:character/deref
@@ -467,7 +467,7 @@ container buffer [
 <span class="Comment"># replace underscores in first with remaining args</span>
 <span class="Comment"># result:address:array:character &lt;- interpolate template:address:array:character, ...</span>
 <span class="muRecipe">recipe</span> interpolate [
-  <span class="Constant">default-space</span>:array:address:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">60:literal</span>
+  <span class="Constant">new-default-space</span>
   template:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># compute result-len, space to allocate for result</span>
   tem-len:number<span class="Special"> &lt;- </span>length template:address:array:character/deref
@@ -592,7 +592,7 @@ container buffer [
 
 <span class="Comment"># result:boolean &lt;- space? c:character</span>
 <span class="muRecipe">recipe</span> space? [
-  <span class="Constant">default-space</span>:array:address:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   c:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># most common case first</span>
   result:boolean<span class="Special"> &lt;- </span>equal c:character, <span class="Constant">32:literal/space</span>
@@ -657,7 +657,7 @@ container buffer [
 
 <span class="Comment"># result:address:array:character &lt;- trim s:address:array:character</span>
 <span class="muRecipe">recipe</span> trim [
-  <span class="Constant">default-space</span>:array:address:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   s:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   len:number<span class="Special"> &lt;- </span>length s:address:array:character/deref
   <span class="Comment"># left trim: compute start</span>
@@ -766,7 +766,7 @@ container buffer [
 
 <span class="Comment"># next-index:number &lt;- find-next text:address:array:character, pattern:character</span>
 <span class="muRecipe">recipe</span> find-next [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   text:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   pattern:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   idx:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -866,7 +866,7 @@ container buffer [
 <span class="Comment"># like find-next, but searches for multiple characters</span>
 <span class="Comment"># fairly dumb algorithm</span>
 <span class="muRecipe">recipe</span> find-substring [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   text:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   pattern:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   idx:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -945,7 +945,7 @@ container buffer [
 <span class="Comment"># result:boolean &lt;- match-at text:address:array:character, pattern:address:array:character, idx:number</span>
 <span class="Comment"># checks if substring matches at index 'idx'</span>
 <span class="muRecipe">recipe</span> match-at [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   text:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   pattern:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   idx:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -1076,7 +1076,7 @@ container buffer [
 
 <span class="Comment"># result:address:array:address:array:character &lt;- split s:address:array:character, delim:character</span>
 <span class="muRecipe">recipe</span> split [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   s:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   delim:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># empty string? return empty array</span>
@@ -1206,7 +1206,7 @@ container buffer [
 
 <span class="Comment"># x:address:array:character, y:address:array:character &lt;- split-first text:address:array:character, delim:character</span>
 <span class="muRecipe">recipe</span> split-first [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   text:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   delim:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># empty string? return empty strings</span>
@@ -1241,7 +1241,7 @@ container buffer [
 <span class="Comment"># result:address:array:character &lt;- string-copy buf:address:array:character, start:number, end:number</span>
 <span class="Comment"># todo: make this generic</span>
 <span class="muRecipe">recipe</span> string-copy [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   buf:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   start:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   end:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -1301,7 +1301,7 @@ container buffer [
 ]
 
 <span class="muRecipe">recipe</span> min [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   y:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Delimiter">{</span>
@@ -1313,7 +1313,7 @@ container buffer [
 ]
 
 <span class="muRecipe">recipe</span> max [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   y:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Delimiter">{</span>
diff --git a/html/061channel.mu.html b/html/061channel.mu.html
index 009ae701..d1fc9b9b 100644
--- a/html/061channel.mu.html
+++ b/html/061channel.mu.html
@@ -15,13 +15,13 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
 .muScenario { color: #00af00; }
 .Delimiter { color: #a04060; }
+.muRecipe { color: #ff8700; }
 .SalientComment { color: #00ffff; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
 .CommentedCode { color: #6c6c6c; }
 .muControl { color: #c0a020; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
 
@@ -68,7 +68,7 @@ container channel [
 
 <span class="Comment"># result:address:channel &lt;- new-channel capacity:number</span>
 <span class="muRecipe">recipe</span> new-channel [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   <span class="Comment"># result = new channel</span>
   result:address:channel<span class="Special"> &lt;- </span>new channel:type
   <span class="Comment"># result.first-full = 0</span>
@@ -87,7 +87,7 @@ container channel [
 
 <span class="Comment"># chan:address:channel &lt;- write chan:address:channel, val:location</span>
 <span class="muRecipe">recipe</span> write [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   chan:address:channel<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   val:location<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Delimiter">{</span>
@@ -116,7 +116,7 @@ container channel [
 
 <span class="Comment"># result:location, chan:address:channel &lt;- read chan:address:channel</span>
 <span class="muRecipe">recipe</span> read [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   chan:address:channel<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Delimiter">{</span>
     <span class="Comment"># block if chan is empty</span>
@@ -142,7 +142,7 @@ container channel [
 ]
 
 <span class="muRecipe">recipe</span> clear-channel [
-  <span class="Constant">default-space</span>:address:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   chan:address:channel<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Delimiter">{</span>
     empty?:boolean<span class="Special"> &lt;- </span>channel-empty? chan:address:channel
@@ -220,7 +220,7 @@ container channel [
 
 <span class="Comment"># An empty channel has first-empty and first-full both at the same value.</span>
 <span class="muRecipe">recipe</span> channel-empty? [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   chan:address:channel<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># return chan.first-full == chan.first-free</span>
   full:number<span class="Special"> &lt;- </span>get chan:address:channel/deref, first-full:offset
@@ -232,7 +232,7 @@ container channel [
 <span class="Comment"># A full channel has first-empty just before first-full, wasting one slot.</span>
 <span class="Comment"># (Other alternatives: <a href="https://en.wikipedia.org/wiki/Circular_buffer#Full_.2F_Empty_Buffer_Distinction)">https://en.wikipedia.org/wiki/Circular_buffer#Full_.2F_Empty_Buffer_Distinction)</a></span>
 <span class="muRecipe">recipe</span> channel-full? [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   chan:address:channel<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># tmp = chan.first-free + 1</span>
   tmp:number<span class="Special"> &lt;- </span>get chan:address:channel/deref, first-free:offset
@@ -252,7 +252,7 @@ container channel [
 
 <span class="Comment"># result:number &lt;- channel-capacity chan:address:channel</span>
 <span class="muRecipe">recipe</span> channel-capacity [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   chan:address:channel<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   q:address:array:location<span class="Special"> &lt;- </span>get chan:address:channel/deref, data:offset
   result:number<span class="Special"> &lt;- </span>length q:address:array:location/deref
@@ -314,7 +314,7 @@ container channel [
 <span class="Comment"># helper for channels of characters in particular</span>
 <span class="Comment"># out:address:channel &lt;- buffer-lines in:address:channel, out:address:channel</span>
 <span class="muRecipe">recipe</span> buffer-lines [
-  <span class="Constant">default-space</span>:address:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
 <span class="CommentedCode">#?   $print [buffer-lines: aaa</span>
 <span class="CommentedCode">#? ]</span>
   in:address:channel<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
diff --git a/html/062array.mu.html b/html/062array.mu.html
index 299748d7..0388b603 100644
--- a/html/062array.mu.html
+++ b/html/062array.mu.html
@@ -15,11 +15,11 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
 .muScenario { color: #00af00; }
 .Delimiter { color: #a04060; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
 .muControl { color: #c0a020; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
 
@@ -46,7 +46,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 
 <span class="Comment"># create an array out of a list of scalar args</span>
 <span class="muRecipe">recipe</span> new-array [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   capacity:number<span class="Special"> &lt;- </span>copy <span class="Constant">0:literal</span>
   <span class="Delimiter">{</span>
     <span class="Comment"># while read curr-value</span>
diff --git a/html/063list.mu.html b/html/063list.mu.html
index 796cf4f0..d805f6ed 100644
--- a/html/063list.mu.html
+++ b/html/063list.mu.html
@@ -13,13 +13,13 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
+.muRecipe { color: #ff8700; }
 .muScenario { color: #00af00; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
 .CommentedCode { color: #6c6c6c; }
 .muControl { color: #c0a020; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
 
@@ -43,7 +43,7 @@ container list [
 
 <span class="Comment"># result:address:list &lt;- push x:location, in:address:list</span>
 <span class="muRecipe">recipe</span> push [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:location<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   in:address:list<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   result:address:list<span class="Special"> &lt;- </span>new list:type
@@ -56,7 +56,7 @@ container list [
 
 <span class="Comment"># result:location &lt;- first in:address:list</span>
 <span class="muRecipe">recipe</span> first [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   in:address:list<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   result:location<span class="Special"> &lt;- </span>get in:address:list/deref, value:offset
   <span class="muControl">reply</span> result:location
@@ -64,7 +64,7 @@ container list [
 
 <span class="Comment"># result:address:list &lt;- rest in:address:list</span>
 <span class="muRecipe">recipe</span> rest [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   in:address:list<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   result:address:list<span class="Special"> &lt;- </span>get in:address:list/deref, next:offset
   <span class="muControl">reply</span> result:address:list
diff --git a/html/064random.cc.html b/html/064random.cc.html
index b340cf44..33ffa770 100644
--- a/html/064random.cc.html
+++ b/html/064random.cc.html
@@ -38,7 +38,7 @@ Recipe_ordinal[<span class="Constant">&quot;random&quot;</span>] = RANDOM<span c
 <span class="Delimiter">:(before &quot;End Primitive Recipe Implementations&quot;)</span>
 case RANDOM: <span class="Delimiter">{</span>
   <span class="Comment">// todo: limited range of numbers, might be imperfectly random</span>
-  <span class="Comment">// todo: thread state in extra ingredients and results</span>
+  <span class="Comment">// todo: thread state in extra ingredients and products</span>
   products<span class="Delimiter">.</span>resize<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">);</span>
   products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>push_back<span class="Delimiter">(</span>rand<span class="Delimiter">());</span>
   <span class="Identifier">break</span><span class="Delimiter">;</span>
diff --git a/html/065duplex_list.mu.html b/html/065duplex_list.mu.html
index 4a573e6e..4f892745 100644
--- a/html/065duplex_list.mu.html
+++ b/html/065duplex_list.mu.html
@@ -13,14 +13,14 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
-.muScenario { color: #00af00; }
+.muRecipe { color: #ff8700; }
 .Delimiter { color: #a04060; }
+.muScenario { color: #00af00; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
 .CommentedCode { color: #6c6c6c; }
 .muControl { color: #c0a020; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
 
@@ -42,7 +42,7 @@ container duplex-list [
 
 <span class="Comment"># result:address:duplex-list &lt;- push-duplex x:location, in:address:duplex-list</span>
 <span class="muRecipe">recipe</span> push-duplex [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:location<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   in:address:duplex-list<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   result:address:duplex-list<span class="Special"> &lt;- </span>new duplex-list:type
@@ -58,7 +58,7 @@ container duplex-list [
 
 <span class="Comment"># result:location &lt;- first-duplex in:address:duplex-list</span>
 <span class="muRecipe">recipe</span> first-duplex [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   in:address:duplex-list<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="muControl">reply-unless</span> in:address:duplex-list, <span class="Constant">0:literal</span>
   result:location<span class="Special"> &lt;- </span>get in:address:duplex-list/deref, value:offset
@@ -67,7 +67,7 @@ container duplex-list [
 
 <span class="Comment"># result:address:duplex-list &lt;- next-duplex in:address:duplex-list</span>
 <span class="muRecipe">recipe</span> next-duplex [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   in:address:duplex-list<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="muControl">reply-unless</span> in:address:duplex-list, <span class="Constant">0:literal</span>
   result:address:duplex-list<span class="Special"> &lt;- </span>get in:address:duplex-list/deref, next:offset
@@ -76,7 +76,7 @@ container duplex-list [
 
 <span class="Comment"># result:address:duplex-list &lt;- prev-duplex in:address:duplex-list</span>
 <span class="muRecipe">recipe</span> prev-duplex [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   in:address:duplex-list<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="muControl">reply-unless</span> in:address:duplex-list, <span class="Constant">0:literal</span>
   result:address:duplex-list<span class="Special"> &lt;- </span>get in:address:duplex-list/deref, prev:offset
@@ -129,7 +129,7 @@ container duplex-list [
 <span class="Comment"># l:address:duplex-list &lt;- insert-duplex x:location, in:address:duplex-list</span>
 <span class="Comment"># Inserts 'x' after 'in'. Returns some pointer into the list.</span>
 <span class="muRecipe">recipe</span> insert-duplex [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:location<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   in:address:duplex-list<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   new-node:address:duplex-list<span class="Special"> &lt;- </span>new duplex-list:type
@@ -271,7 +271,7 @@ container duplex-list [
 <span class="Comment"># Returns null if and only if list is empty. Beware: in that case any pointers</span>
 <span class="Comment"># to the head are now invalid.</span>
 <span class="muRecipe">recipe</span> remove-duplex [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   in:address:duplex-list<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if 'in' is null, return</span>
   <span class="muControl">reply-unless</span> in:address:duplex-list, in:address:duplex-list
diff --git a/html/066stream.mu.html b/html/066stream.mu.html
index feba9cf7..2e899c6c 100644
--- a/html/066stream.mu.html
+++ b/html/066stream.mu.html
@@ -13,11 +13,11 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
 .muControl { color: #c0a020; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
 
@@ -36,7 +36,7 @@ container stream [
 ]
 
 <span class="muRecipe">recipe</span> new-stream [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   result:address:stream<span class="Special"> &lt;- </span>new stream:type
   i:address:number<span class="Special"> &lt;- </span>get-address result:address:stream/deref, index:offset
   i:address:number/deref<span class="Special"> &lt;- </span>copy <span class="Constant">0:literal</span>
@@ -46,7 +46,7 @@ container stream [
 ]
 
 <span class="muRecipe">recipe</span> rewind-stream [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   in:address:stream<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   x:address:number<span class="Special"> &lt;- </span>get-address in:address:stream/deref, index:offset
   x:address:number/deref<span class="Special"> &lt;- </span>copy <span class="Constant">0:literal</span>
@@ -54,7 +54,7 @@ container stream [
 ]
 
 <span class="muRecipe">recipe</span> read-line [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   in:address:stream<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   idx:address:number<span class="Special"> &lt;- </span>get-address in:address:stream/deref, index:offset
   s:address:array:character<span class="Special"> &lt;- </span>get in:address:stream/deref, data:offset
@@ -65,7 +65,7 @@ container stream [
 ]
 
 <span class="muRecipe">recipe</span> end-of-stream? [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   in:address:stream<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   idx:number<span class="Special"> &lt;- </span>get in:address:stream/deref, index:offset
   s:address:array:character<span class="Special"> &lt;- </span>get in:address:stream/deref, data:offset
diff --git a/html/071print.mu.html b/html/071print.mu.html
index 29e893bf..43461cc5 100644
--- a/html/071print.mu.html
+++ b/html/071print.mu.html
@@ -13,14 +13,14 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
-.muScenario { color: #00af00; }
+.muRecipe { color: #ff8700; }
 .Delimiter { color: #a04060; }
+.muScenario { color: #00af00; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
 .CommentedCode { color: #6c6c6c; }
 .muControl { color: #c0a020; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
 
@@ -49,7 +49,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> new-fake-screen [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal/capacity</span>
+  <span class="Constant">new-default-space</span>
   result:address:screen<span class="Special"> &lt;- </span>new screen:type
   width:address:number<span class="Special"> &lt;- </span>get-address result:address:screen/deref, num-columns:offset
   width:address:number/deref<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -69,7 +69,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> clear-screen [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
 <span class="CommentedCode">#?   $print [clearing screen</span>
 <span class="CommentedCode">#? ] #? 1</span>
@@ -104,7 +104,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> print-character [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   c:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   color:number, color-found?:boolean<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -348,7 +348,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> clear-line [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists, clear line in fake screen</span>
   <span class="Delimiter">{</span>
@@ -377,7 +377,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> cursor-position [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists, lookup cursor in fake screen</span>
   <span class="Delimiter">{</span>
@@ -391,7 +391,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> move-cursor [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   new-row:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   new-column:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -441,7 +441,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> cursor-down [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists, move cursor in fake screen</span>
   <span class="Delimiter">{</span>
@@ -468,7 +468,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> cursor-up [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists, move cursor in fake screen</span>
   <span class="Delimiter">{</span>
@@ -489,7 +489,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> cursor-right [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists, move cursor in fake screen</span>
   <span class="Delimiter">{</span>
@@ -511,7 +511,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> cursor-left [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists, move cursor in fake screen</span>
   <span class="Delimiter">{</span>
@@ -532,7 +532,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> cursor-to-start-of-line [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   row:number, _, x:address:screen<span class="Special"> &lt;- </span>cursor-position x:address:screen
   column:number<span class="Special"> &lt;- </span>copy <span class="Constant">0:literal</span>
@@ -541,7 +541,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> cursor-to-next-line [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   x:address:screen<span class="Special"> &lt;- </span>cursor-down x:address:screen
   x:address:screen<span class="Special"> &lt;- </span>cursor-to-start-of-line x:address:screen
@@ -549,7 +549,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> screen-width [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists, move cursor in fake screen</span>
   <span class="Delimiter">{</span>
@@ -563,7 +563,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> screen-height [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists, move cursor in fake screen</span>
   <span class="Delimiter">{</span>
@@ -577,7 +577,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> hide-cursor [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists (not real display), do nothing</span>
   <span class="Delimiter">{</span>
@@ -590,7 +590,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> show-cursor [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists (not real display), do nothing</span>
   <span class="Delimiter">{</span>
@@ -603,7 +603,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> hide-screen [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists (not real display), do nothing</span>
   <span class="Delimiter">{</span>
@@ -616,7 +616,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> show-screen [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># if x exists (not real display), do nothing</span>
   <span class="Delimiter">{</span>
@@ -629,7 +629,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> print-string [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   s:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   color:number, color-found?:boolean<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -678,7 +678,7 @@ container screen-cell [
 ]
 
 <span class="muRecipe">recipe</span> print-integer [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   n:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   color:number, color-found?:boolean<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
diff --git a/html/074console.mu.html b/html/074console.mu.html
index b89a1333..594f28c2 100644
--- a/html/074console.mu.html
+++ b/html/074console.mu.html
@@ -13,13 +13,13 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
+.muRecipe { color: #ff8700; }
 .Delimiter { color: #a04060; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
 .CommentedCode { color: #6c6c6c; }
 .muControl { color: #c0a020; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
 
@@ -53,7 +53,7 @@ container console [
 ]
 
 <span class="muRecipe">recipe</span> new-fake-console [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   result:address:console<span class="Special"> &lt;- </span>new console:type
   buf:address:address:array:character<span class="Special"> &lt;- </span>get-address result:address:console/deref, data:offset
 <span class="CommentedCode">#?   $start-tracing #? 1</span>
@@ -65,7 +65,7 @@ container console [
 ]
 
 <span class="muRecipe">recipe</span> read-event [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:console<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Delimiter">{</span>
     <span class="muControl">break-unless</span> x:address:console
@@ -92,7 +92,7 @@ container console [
 <span class="Comment"># isn't unicode, so no arrow keys, page-up/page-down, etc. But you still get</span>
 <span class="Comment"># newlines, tabs, ctrl-d..</span>
 <span class="muRecipe">recipe</span> read-key [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
 <span class="CommentedCode">#?   $print default-space:address:array:location #? 1</span>
 <span class="CommentedCode">#?   $exit #? 1</span>
 <span class="CommentedCode">#?   $start-tracing #? 1</span>
@@ -110,7 +110,7 @@ container console [
 ]
 
 <span class="muRecipe">recipe</span> send-keys-to-channel [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   console:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   chan:address:channel<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -126,7 +126,7 @@ container console [
 ]
 
 <span class="muRecipe">recipe</span> wait-for-event [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   console:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Delimiter">{</span>
     _, console:address, found?:boolean<span class="Special"> &lt;- </span>read-event console:address
@@ -136,7 +136,7 @@ container console [
 
 <span class="Comment"># use this helper to skip rendering if there's lots of other events queued up</span>
 <span class="muRecipe">recipe</span> has-more-events? [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   console:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Delimiter">{</span>
     <span class="muControl">break-unless</span> console:address
diff --git a/html/callcc.mu.html b/html/callcc.mu.html
index e16e87c4..fa8eaa27 100644
--- a/html/callcc.mu.html
+++ b/html/callcc.mu.html
@@ -13,11 +13,11 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
 .muControl { color: #c0a020; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/channel.mu.html b/html/channel.mu.html
index 14530ec8..d77a5057 100644
--- a/html/channel.mu.html
+++ b/html/channel.mu.html
@@ -13,12 +13,12 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
+.muRecipe { color: #ff8700; }
 .Delimiter { color: #a04060; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
 .muControl { color: #c0a020; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
 
@@ -34,7 +34,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 
 <span class="muRecipe">recipe</span> producer [
   <span class="Comment"># produce numbers 1 to 5 on a channel</span>
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   chan:address:channel<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># n = 0</span>
   n:number<span class="Special"> &lt;- </span>copy <span class="Constant">0:literal</span>
@@ -52,7 +52,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 
 <span class="muRecipe">recipe</span> consumer [
   <span class="Comment"># consume and print integers from a channel</span>
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   chan:address:channel<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Delimiter">{</span>
     <span class="Comment"># read an integer from the channel</span>
@@ -65,7 +65,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 ]
 
 <span class="muRecipe">recipe</span> main [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   chan:address:channel<span class="Special"> &lt;- </span>new-channel <span class="Constant">3:literal</span>
   <span class="Comment"># create two background 'routines' that communicate by a channel</span>
   routine1:number<span class="Special"> &lt;- </span>start-running producer:<span class="muRecipe">recipe</span>, chan:address:channel
diff --git a/html/chessboard.mu.html b/html/chessboard.mu.html
index 7de573ec..42e9f776 100644
--- a/html/chessboard.mu.html
+++ b/html/chessboard.mu.html
@@ -13,15 +13,15 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
-.muScenario { color: #00af00; }
+.muRecipe { color: #ff8700; }
 .Delimiter { color: #a04060; }
+.muScenario { color: #00af00; }
 .SalientComment { color: #00ffff; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
 .CommentedCode { color: #6c6c6c; }
 .muControl { color: #c0a020; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
 
@@ -117,7 +117,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 <span class="muRecipe">recipe</span> chessboard [
 <span class="CommentedCode">#?   $start-tracing [schedule] #? 2</span>
 <span class="CommentedCode">#?   $start-tracing #? 1</span>
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   console:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
 <span class="CommentedCode">#?   $print [screen: ], screen:address, [, console: ], console:address, [ </span>
@@ -173,7 +173,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 <span class="SalientComment">## a board is an array of files, a file is an array of characters (squares)</span>
 
 <span class="muRecipe">recipe</span> new-board [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   initial-position:address:array:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># assert(length(initial-position) == 64)</span>
   len:number<span class="Special"> &lt;- </span>length initial-position:address:array:number/deref
@@ -194,7 +194,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 ]
 
 <span class="muRecipe">recipe</span> new-file [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   position:address:array:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   index:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   index:number<span class="Special"> &lt;- </span>multiply index:number, <span class="Constant">8:literal</span>
@@ -213,7 +213,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 ]
 
 <span class="muRecipe">recipe</span> print-board [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   board:address:array:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   row:number<span class="Special"> &lt;- </span>copy <span class="Constant">7:literal</span>  <span class="Comment"># start printing from the top of the board</span>
@@ -262,7 +262,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 
 <span class="Comment"># board:address:array:address:array:character &lt;- initial-position</span>
 <span class="muRecipe">recipe</span> initial-position [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   <span class="Comment"># layout in memory (in raster order):</span>
   <span class="Comment">#   R P _ _ _ _ p r</span>
   <span class="Comment">#   N P _ _ _ _ p n</span>
@@ -322,7 +322,7 @@ container move [
 <span class="Comment"># result:address:move, quit?:boolean, error?:boolean &lt;- read-move stdin:address:channel, screen:address</span>
 <span class="Comment"># prints only error messages to screen</span>
 <span class="muRecipe">recipe</span> read-move [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   stdin:address:channel<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
 <span class="CommentedCode">#?   $print screen:address #? 1</span>
@@ -357,7 +357,7 @@ container move [
 <span class="Comment"># file:number, quit:boolean, error:boolean &lt;- read-file stdin:address:channel, screen:address</span>
 <span class="Comment"># valid values for file: 0-7</span>
 <span class="muRecipe">recipe</span> read-file [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   stdin:address:channel<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   c:character, stdin:address:channel<span class="Special"> &lt;- </span>read stdin:address:channel
@@ -410,7 +410,7 @@ container move [
 <span class="Comment"># rank:number &lt;- read-rank stdin:address:channel, screen:address</span>
 <span class="Comment"># valid values: 0-7, -1 (quit), -2 (error)</span>
 <span class="muRecipe">recipe</span> read-rank [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   stdin:address:channel<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   c:character, stdin:address:channel<span class="Special"> &lt;- </span>read stdin:address:channel
@@ -457,7 +457,7 @@ container move [
 <span class="Comment"># read a character from the given channel and check that it's what we expect</span>
 <span class="Comment"># return true on error</span>
 <span class="muRecipe">recipe</span> expect-from-channel [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   stdin:address:channel<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   expected:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -659,7 +659,7 @@ F read-move-file: routine failed to pause <span class="muRecipe">after</span> co
 ]
 
 <span class="muRecipe">recipe</span> make-move [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   b:address:array:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   m:address:move<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   from-file:number<span class="Special"> &lt;- </span>get m:address:move/deref, from-file:offset
diff --git a/html/console.mu.html b/html/console.mu.html
index 098c7e43..a4b3827a 100644
--- a/html/console.mu.html
+++ b/html/console.mu.html
@@ -13,12 +13,12 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
+.muRecipe { color: #ff8700; }
 .Constant { color: #00a0a0; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #a04060; }
 .Special { color: #ff6060; }
 .muControl { color: #c0a020; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/counters.mu.html b/html/counters.mu.html
index 9129fed8..1e76afdf 100644
--- a/html/counters.mu.html
+++ b/html/counters.mu.html
@@ -13,11 +13,11 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
 .muControl { color: #c0a020; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
 
@@ -39,7 +39,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 ]
 
 <span class="muRecipe">recipe</span> increment-counter [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   0:address:array:location/names:new-counter<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>  <span class="Comment"># setup outer space; it *must* come from 'new-counter'</span>
   x:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   n:number/space:1<span class="Special"> &lt;- </span>add n:number/space:1, x:number
@@ -47,7 +47,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 ]
 
 <span class="muRecipe">recipe</span> main [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   <span class="Comment"># counter A</span>
   a:address:array:location<span class="Special"> &lt;- </span>new-counter <span class="Constant">34:literal</span>
   <span class="Comment"># counter B</span>
diff --git a/html/display.mu.html b/html/display.mu.html
index d6e1560f..5e248a79 100644
--- a/html/display.mu.html
+++ b/html/display.mu.html
@@ -13,11 +13,11 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
 .CommentedCode { color: #6c6c6c; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/edit.mu.html b/html/edit.mu.html
index 3eb34a4b..078fac53 100644
--- a/html/edit.mu.html
+++ b/html/edit.mu.html
@@ -13,15 +13,15 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
-.muScenario { color: #00af00; }
+.muRecipe { color: #ff8700; }
 .Delimiter { color: #a04060; }
+.muScenario { color: #00af00; }
 .SalientComment { color: #00ffff; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
 .CommentedCode { color: #6c6c6c; }
 .muControl { color: #c0a020; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
 
@@ -36,7 +36,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 <span class="Comment"># Environment for learning programming using mu.</span>
 
 <span class="muRecipe">recipe</span> main [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   open-console
   initial-recipe:address:array:character<span class="Special"> &lt;- </span>new <span class="Constant">[recipe new-add [</span>
 <span class="Constant">  x:number &lt;- next-ingredient</span>
@@ -59,7 +59,7 @@ container programming-environment-data [
 ]
 
 <span class="muRecipe">recipe</span> new-programming-environment [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   initial-recipe-contents:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   initial-sandbox-contents:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -126,7 +126,7 @@ container editor-data [
 <span class="Comment">#   top/left/right constrain the screen area available to the new editor.</span>
 <span class="Comment">#   right is exclusive.</span>
 <span class="muRecipe">recipe</span> new-editor [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   s:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Comment"># no clipping of bounds</span>
@@ -196,7 +196,7 @@ container editor-data [
 
 <span class="Comment"># bottom:number, screen:address &lt;- render screen:address, editor:address:editor-data</span>
 <span class="muRecipe">recipe</span> render [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">40:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   editor:address:editor-data<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="muControl">reply-unless</span> editor:address:editor-data, <span class="Constant">1:literal/top</span>, screen:address/same-as-ingredient:0
@@ -303,7 +303,7 @@ container editor-data [
 <span class="Comment"># print a string 's' to 'editor' in 'color' starting at 'row'</span>
 <span class="Comment"># leave cursor at start of next line</span>
 <span class="muRecipe">recipe</span> render-string [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">40:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   s:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   left:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -369,7 +369,7 @@ container editor-data [
 ]
 
 <span class="muRecipe">recipe</span> clear-line-delimited [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">40:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   left:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   right:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -490,7 +490,7 @@ container editor-data [
 <span class="SalientComment">## handling events from the keyboard, mouse, touch screen, ...</span>
 
 <span class="muRecipe">recipe</span> event-loop [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   console:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   env:address:programming-environment-data<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -549,7 +549,7 @@ container editor-data [
 
 <span class="Comment"># helper for testing a single editor</span>
 <span class="muRecipe">recipe</span> editor-event-loop [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   console:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   editor:address:editor-data<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -582,7 +582,7 @@ container editor-data [
 ]
 
 <span class="muRecipe">recipe</span> handle-event [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">50:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   console:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   editor:address:editor-data<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -721,7 +721,7 @@ container editor-data [
 <span class="Comment"># process click, return if it was on current editor</span>
 <span class="Comment"># todo: ignores menu bar (for now just displays shortcuts)</span>
 <span class="muRecipe">recipe</span> move-cursor-in-editor [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   editor:address:editor-data<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   t:touch-event<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -744,7 +744,7 @@ container editor-data [
 ]
 
 <span class="muRecipe">recipe</span> insert-at-cursor [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   editor:address:editor-data<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   c:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -792,7 +792,7 @@ container editor-data [
 ]
 
 <span class="muRecipe">recipe</span> delete-before-cursor [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   editor:address:editor-data<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   before-cursor:address:address:duplex-list<span class="Special"> &lt;- </span>get-address editor:address:editor-data/deref, before-cursor:offset
   d:address:duplex-list<span class="Special"> &lt;- </span>get editor:address:editor-data/deref, data:offset
@@ -813,7 +813,7 @@ container editor-data [
 <span class="Comment"># takes a pointer 'curr' into the doubly-linked list and its sentinel, counts</span>
 <span class="Comment"># the length of the previous line before the 'curr' pointer.</span>
 <span class="muRecipe">recipe</span> previous-line-length [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   curr:address:duplex-list<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   start:address:duplex-list<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   result:number<span class="Special"> &lt;- </span>copy <span class="Constant">0:literal</span>
@@ -835,7 +835,7 @@ container editor-data [
 ]
 
 <span class="muRecipe">recipe</span> render-all [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">40:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   env:address:programming-environment-data<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   recipes:address:editor-data<span class="Special"> &lt;- </span>get env:address:programming-environment-data/deref, recipes:offset
@@ -879,7 +879,7 @@ container editor-data [
 ]
 
 <span class="muRecipe">recipe</span> render-sandboxes [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">40:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   sandbox:address:sandbox-data<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   left:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -912,7 +912,7 @@ container editor-data [
 ]
 
 <span class="muRecipe">recipe</span> update-cursor [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">40:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   recipes:address:editor-data<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   current-sandbox:address:editor-data<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -1976,7 +1976,7 @@ container sandbox-data [
 ]
 
 <span class="muRecipe">recipe</span> run-sandboxes [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   env:address:programming-environment-data<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   recipes:address:editor-data<span class="Special"> &lt;- </span>get env:address:programming-environment-data/deref, recipes:offset
   current-sandbox:address:editor-data<span class="Special"> &lt;- </span>get env:address:programming-environment-data/deref, current-sandbox:offset
@@ -2119,7 +2119,7 @@ container sandbox-data [
 ]
 
 <span class="muRecipe">recipe</span> editor-contents [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   editor:address:editor-data<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   buf:address:buffer<span class="Special"> &lt;- </span>new-buffer <span class="Constant">80:literal</span>
   curr:address:duplex-list<span class="Special"> &lt;- </span>get editor:address:editor-data/deref, data:offset
@@ -2159,7 +2159,7 @@ container sandbox-data [
 <span class="SalientComment">## helpers for drawing editor borders</span>
 
 <span class="muRecipe">recipe</span> draw-box [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   top:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   left:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -2187,7 +2187,7 @@ container sandbox-data [
 ]
 
 <span class="muRecipe">recipe</span> draw-horizontal [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   row:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   x:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -2219,7 +2219,7 @@ container sandbox-data [
 ]
 
 <span class="muRecipe">recipe</span> draw-vertical [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   col:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   x:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -2246,7 +2246,7 @@ container sandbox-data [
 ]
 
 <span class="muRecipe">recipe</span> draw-top-left [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   top:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   left:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -2261,7 +2261,7 @@ container sandbox-data [
 ]
 
 <span class="muRecipe">recipe</span> draw-top-right [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   top:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   right:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -2276,7 +2276,7 @@ container sandbox-data [
 ]
 
 <span class="muRecipe">recipe</span> draw-bottom-left [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   bottom:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   left:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -2291,7 +2291,7 @@ container sandbox-data [
 ]
 
 <span class="muRecipe">recipe</span> draw-bottom-right [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   screen:address<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   bottom:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   right:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
@@ -2306,7 +2306,7 @@ container sandbox-data [
 ]
 
 <span class="muRecipe">recipe</span> print-string-with-gradient-background [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:address:screen<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   s:address:array:character<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   color:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
diff --git a/html/factorial.mu.html b/html/factorial.mu.html
index b180a35b..41a725b6 100644
--- a/html/factorial.mu.html
+++ b/html/factorial.mu.html
@@ -13,13 +13,13 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
-.muScenario { color: #00af00; }
+.muRecipe { color: #ff8700; }
 .Delimiter { color: #a04060; }
+.muScenario { color: #00af00; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
 .muControl { color: #c0a020; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
 
@@ -34,14 +34,14 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 <span class="Comment"># example program: compute the factorial of 5</span>
 
 <span class="muRecipe">recipe</span> main [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   x:number<span class="Special"> &lt;- </span>factorial <span class="Constant">5:literal</span>
   $print <span class="Constant">[result: ]</span>, x:number, <span class="Constant">[ </span>
 <span class="Constant">]</span>
 ]
 
 <span class="muRecipe">recipe</span> factorial [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   n:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Delimiter">{</span>
     <span class="Comment"># if n=0 return 1</span>
diff --git a/html/factorial.png b/html/factorial.png
index 8d799034..19249bbe 100644
--- a/html/factorial.png
+++ b/html/factorial.png
Binary files differdiff --git a/html/fork.mu.html b/html/fork.mu.html
index 4d6b367c..74e7fb39 100644
--- a/html/fork.mu.html
+++ b/html/fork.mu.html
@@ -13,11 +13,11 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
+.muRecipe { color: #ff8700; }
 .Constant { color: #00a0a0; }
 .Comment { color: #9090ff; }
 .Delimiter { color: #a04060; }
 .muControl { color: #c0a020; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/global.mu.html b/html/global.mu.html
new file mode 100644
index 00000000..8c9b2e84
--- /dev/null
+++ b/html/global.mu.html
@@ -0,0 +1,48 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+<html>
+<head>
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
+<title>Mu - global.mu</title>
+<meta name="Generator" content="Vim/7.4">
+<meta name="plugin-version" content="vim7.4_v1">
+<meta name="syntax" content="none">
+<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy=">
+<meta name="colorscheme" content="minimal">
+<style type="text/css">
+<!--
+pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
+body { font-family: monospace; color: #eeeeee; background-color: #080808; }
+* { font-size: 1.05em; }
+.muRecipe { color: #ff8700; }
+.Comment { color: #9090ff; }
+.Constant { color: #00a0a0; }
+.Special { color: #ff6060; }
+-->
+</style>
+
+<script type='text/javascript'>
+<!--
+
+-->
+</script>
+</head>
+<body>
+<pre id='vimCodeElement'>
+<span class="Comment"># example program: creating and using global variables</span>
+
+<span class="muRecipe">recipe</span> main [
+  <span class="Comment"># allocate 5 locations for globals</span>
+  <span class="Constant">global-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">5:literal</span>
+  <span class="Comment"># read to globals by using /space:global</span>
+  <span class="Special">1:number/space:global</span><span class="Special"> &lt;- </span>copy <span class="Constant">3:literal</span>
+  foo
+]
+
+<span class="muRecipe">recipe</span> foo [
+  <span class="Comment"># ditto for writing to globals</span>
+  $print <span class="Special">1:number/space:global</span>
+]
+</pre>
+</body>
+</html>
+<!-- vim: set foldmethod=manual : -->
diff --git a/html/screen.mu.html b/html/screen.mu.html
index 4618548a..1b07256e 100644
--- a/html/screen.mu.html
+++ b/html/screen.mu.html
@@ -13,10 +13,10 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
 
diff --git a/html/tangle.mu.html b/html/tangle.mu.html
index 77714d9f..f68a77f3 100644
--- a/html/tangle.mu.html
+++ b/html/tangle.mu.html
@@ -13,12 +13,12 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
+.muRecipe { color: #ff8700; }
 .Delimiter { color: #a04060; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
 .muControl { color: #c0a020; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
 
@@ -39,7 +39,7 @@ body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 <span class="Comment"># possibilities.</span>
 
 <span class="muRecipe">recipe</span> factorial [
-  <span class="Constant">default-space</span>:address:array:location<span class="Special"> &lt;- </span>new location:type, <span class="Constant">30:literal</span>
+  <span class="Constant">new-default-space</span>
   n:number<span class="Special"> &lt;- </span><span class="Constant">next-ingredient</span>
   <span class="Delimiter">{</span>
 <span class="Constant">    +base-case</span>
diff --git a/html/x.mu.html b/html/x.mu.html
index fa874a2d..b22cd40b 100644
--- a/html/x.mu.html
+++ b/html/x.mu.html
@@ -13,10 +13,10 @@
 pre { white-space: pre-wrap; font-family: monospace; color: #eeeeee; background-color: #080808; }
 body { font-family: monospace; color: #eeeeee; background-color: #080808; }
 * { font-size: 1.05em; }
+.muRecipe { color: #ff8700; }
 .Comment { color: #9090ff; }
 .Constant { color: #00a0a0; }
 .Special { color: #ff6060; }
-.muRecipe { color: #ff8700; }
 -->
 </style>
author	Kartik K. Agaram <vc@akkartik.com>	2015-07-13 20:53:41 -0700
committer	Kartik K. Agaram <vc@akkartik.com>	2015-07-13 20:53:41 -0700
commit	83fcebf3210b638d9f8248e0007e9f0c9804980a (patch)
tree	95c4855bef341e1d46eb4725b54a3eaaf6858f08 /html
parent	8b9f1750c74c7d3cca99d6949a90cd61eb8e0218 (diff)
download	mu-83fcebf3210b638d9f8248e0007e9f0c9804980a.tar.gz