5001 - drop the :(scenario) DSL

I've been saying for a while[1][2][3] that adding extra abstractions makes
things harder for newcomers, and adding new notations doubly so. And then
I notice this DSL in my own backyard. Makes me feel like a hypocrite.

[1] https://news.ycombinator.com/item?id=13565743#13570092
[2] https://lobste.rs/s/to8wpr/configuration_files_are_canary_warning
[3] https://lobste.rs/s/mdmcdi/little_languages_by_jon_bentley_1986#c_3miuf2

The implementation of the DSL was also highly hacky:

a) It was happening in the tangle/ tool, but was utterly unrelated to tangling
layers.

b) There were several persnickety constraints on the different kinds of
lines and the specific order they were expected in. I kept finding bugs
where the translator would silently do the wrong thing. Or the error messages
sucked, and readers may be stuck looking at the generated code to figure
out what happened. Fixing error messages would require a lot more code,
which is one of my arguments against DSLs in the first place: they may
be easy to implement, but they're hard to design to go with the grain of
the underlying platform. They require lots of iteration. Is that effort
worth prioritizing in this project?

On the other hand, the DSL did make at least some readers' life easier,
the ones who weren't immediately put off by having to learn a strange syntax.
There were fewer quotes to parse, fewer backslash escapes.

Anyway, since there are also people who dislike having to put up with strange
syntaxes, we'll call that consideration a wash and tear this DSL out.

---

This commit was sheer drudgery. Hopefully it won't need to be redone with
a new DSL because I grow sick of backslashes.

1 files changed, 43 insertions, 34 deletions

diff --git a/044space_surround.cc b/044space_surround.cc
index 9957630d..5a4afb5e 100644
--- a/044space_surround.cc
+++ b/044space_surround.cc
@@ -4,36 +4,41 @@
 //:
 //: (Surrounding spaces are like lexical scopes in other languages.)
 
-:(scenario surrounding_space)
-# location 2 in space 1 (remember that locations 0 and 1 are reserved in all
-# spaces) refers to the space surrounding the default space, here 20.
-def main [
-  # prepare default-space address
-  10:num/alloc-id, 11:num <- copy 0, 1000
-  # prepare default-space payload
-  1000:num <- copy 0  # alloc id of payload
-  1001:num <- copy 5  # length
-  # prepare address of chained space
-  20:num/alloc-id, 21:num <- copy 0, 2000
-  # prepare payload of chained space
-  2000:num <- copy 0  # alloc id of payload
-  2001:num <- copy 5  # length
-  # actual start of this recipe
-  default-space:space <- copy 10:space
-  #: later layers will explain the /names: property
-  0:space/names:dummy <- copy 20:space/raw
-  2:num <- copy 94
-  2:num/space:1 <- copy 95
-]
-def dummy [  # just for the /names: property above
-]
-# chain space: 1000 + (alloc id) 1 + (length) 1
-+mem: storing 0 in location 1002
-+mem: storing 2000 in location 1003
-# store to default space: 1000 + (alloc id) 1 + (length) 1 + (index) 2
-+mem: storing 94 in location 1004
-# store to chained space: (contents of location 1003) 2000 + (alloc id) 1 + (length) 1 + (index) 2
-+mem: storing 95 in location 2004
+void test_surrounding_space() {
+  run(
+      // location 2 in space 1 (remember that locations 0 and 1 are reserved in all
+      // spaces) refers to the space surrounding the default space, here 20.
+      "def main [\n"
+         // prepare default-space address
+      "  10:num/alloc-id, 11:num <- copy 0, 1000\n"
+         // prepare default-space payload
+      "  1000:num <- copy 0\n"  // alloc id of payload
+      "  1001:num <- copy 5\n"  // length
+         // prepare address of chained space
+      "  20:num/alloc-id, 21:num <- copy 0, 2000\n"
+         // prepare payload of chained space
+      "  2000:num <- copy 0\n"  // alloc id of payload
+      "  2001:num <- copy 5\n"  // length
+         // actual start of this recipe
+      "  default-space:space <- copy 10:space\n"
+         // later layers will explain the /names: property
+      "  0:space/names:dummy <- copy 20:space/raw\n"
+      "  2:num <- copy 94\n"
+      "  2:num/space:1 <- copy 95\n"
+      "]\n"
+      "def dummy [\n"  // just for the /names: property above
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      // chain space: 1000 + (alloc id) 1 + (length) 1
+      "mem: storing 0 in location 1002\n"
+      "mem: storing 2000 in location 1003\n"
+      // store to default space: 1000 + (alloc id) 1 + (length) 1 + (index) 2
+      "mem: storing 94 in location 1004\n"
+      // store to chained space: (contents of location 1003) 2000 + (alloc id) 1 + (length) 1 + (index) 2
+      "mem: storing 95 in location 2004\n"
+  );
+}
 
 //: If you think of a space as a collection of variables with a common
 //: lifetime, surrounding allows managing shorter lifetimes inside a longer
@@ -64,7 +69,11 @@ int space_index(const reagent& x) {
   return 0;
 }
 
-:(scenario permit_space_as_variable_name)
-def main [
-  space:num <- copy 0
-]
+:(code)
+void test_permit_space_as_variable_name() {
+  run(
+      "def main [\n"
+      "  space:num <- copy 0\n"
+      "]\n"
+  );
+}