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.

7 files changed, 0 insertions, 1491 deletions

diff --git a/transect/000organization.cc b/transect/000organization.cc
deleted file mode 100644
index 9a1938ff..00000000
--- a/transect/000organization.cc
+++ /dev/null
@@ -1,136 +0,0 @@
-//: You guessed right: the '000' prefix means you should start reading here.
-//:
-//: This project is set up to load all files with a numeric prefix. Just
-//: create a new file and start hacking.
-//:
-//: The first few files (00*) are independent of what this program does, an
-//: experimental skeleton that will hopefully make it both easier for others to
-//: understand and more malleable, easier to rewrite and remould into radically
-//: different shapes without breaking in subtle corner cases. The premise is
-//: that understandability and rewrite-friendliness are related in a virtuous
-//: cycle. Doing one well makes it easier to do the other.
-//:
-//: Lower down, this file contains a legal, bare-bones C++ program. It doesn't
-//: do anything yet; subsequent files will contain :(...) directives to insert
-//: lines into it. For example:
-//:   :(after "more events")
-//: This directive means: insert the following lines after a line in the
-//: program containing the words "more events".
-//:
-//: A simple tool is included to 'tangle' all the files together in sequence
-//: according to their directives into a single source file containing all the
-//: code for the project, and then feed the source file to the compiler.
-//: (It'll drop these comments starting with a '//:' prefix that only make
-//: sense before tangling.)
-//:
-//: Directives free up the programmer to order code for others to read rather
-//: than as forced by the computer or compiler. Each individual feature can be
-//: organized in a self-contained 'layer' that adds code to many different data
-//: structures and functions all over the program. The right decomposition into
-//: layers will let each layer make sense in isolation.
-//:
-//:   "If I look at any small part of it, I can see what is going on -- I don't
-//:   need to refer to other parts to understand what something is doing.
-//:
-//:   If I look at any large part in overview, I can see what is going on -- I
-//:   don't need to know all the details to get it.
-//:
-//:   Every level of detail is as locally coherent and as well thought-out as
-//:   any other level."
-//:
-//:       -- Richard Gabriel, "The Quality Without A Name"
-//:          (http://dreamsongs.com/Files/PatternsOfSoftware.pdf, page 42)
-//:
-//: Directives are powerful; they permit inserting or modifying any point in
-//: the program. Using them tastefully requires mapping out specific lines as
-//: waypoints for future layers to hook into. Often such waypoints will be in
-//: comments, capitalized to hint that other layers rely on their presence.
-//:
-//: A single waypoint might have many different code fragments hooking into
-//: it from all over the codebase. Use 'before' directives to insert
-//: code at a location in order, top to bottom, and 'after' directives to
-//: insert code in reverse order. By convention waypoints intended for insertion
-//: before begin with 'End'. Notice below how the layers line up above the "End
-//: Foo" waypoint.
-//:
-//:   File 001          File 002                File 003
-//:   ============      ===================     ===================
-//:   // Foo
-//:   ------------
-//:              <----  :(before "End Foo")
-//:                     ....
-//:                     ...
-//:   ------------
-//:              <----------------------------  :(before "End Foo")
-//:                                             ....
-//:                                             ...
-//:   // End Foo
-//:   ============
-//:
-//: Here's part of a layer in color: http://i.imgur.com/0eONnyX.png. Directives
-//: are shaded dark.
-//:
-//: Layers do more than just shuffle code around. In a well-organized codebase
-//: it should be possible to stop loading after any file/layer, build and run
-//: the program, and pass all tests for loaded features. (Relevant is
-//: http://youtube.com/watch?v=c8N72t7aScY, a scene from "2001: A Space
-//: Odyssey".) Get into the habit of running the included script called
-//: 'test_layers' before you commit any changes.
-//:
-//: This 'subsetting guarantee' ensures that this directory contains a
-//: cleaned-up narrative of the evolution of this codebase. Organizing
-//: autobiographically allows newcomers to rapidly orient themselves, reading
-//: the first few files to understand a simple gestalt of a program's core
-//: purpose and features, and later gradually working their way through other
-//: features as the need arises.
-//:
-//: Programmers shouldn't need to understand everything about a program to
-//: hack on it. But they shouldn't be prevented from a thorough understanding
-//: of each aspect either. The goal of layers is to reward curiosity.
-
-// Includes
-// End Includes
-
-// Types
-// End Types
-
-// Function prototypes are auto-generated in the 'build*' scripts; define your
-// functions in any order. Just be sure to declare each function header all on
-// one line, ending with the '{'. Our auto-generation scripts are too minimal
-// and simple-minded to handle anything else.
-#include "function_list"  // by convention, files ending with '_list' are auto-generated
-
-// Globals
-//
-// All statements in this section should always define a single variable on a
-// single line. The 'build*' scripts will simple-mindedly auto-generate extern
-// declarations for them. Remember to define (not just declare) constants with
-// extern linkage in this section, since C++ global constants have internal
-// linkage by default.
-//
-// End Globals
-
-int main(int argc, char* argv[]) {
-  atexit(reset);
-
-  // End One-time Setup
-
-  // Commandline Parsing
-  // End Commandline Parsing
-
-  return 0;  // End Main
-}
-
-// Unit Tests
-// End Unit Tests
-
-//: our first directive; insert the following header at the start of the program
-:(before "End Includes")
-#include <stdlib.h>
-
-//: Without directives or with the :(code) directive, lines get added at the
-//: end.
-:(code)
-void reset() {
-  // End Reset
-}
diff --git a/transect/001help.cc b/transect/001help.cc
deleted file mode 100644
index 3cab06d9..00000000
--- a/transect/001help.cc
+++ /dev/null
@@ -1,261 +0,0 @@
-//: Everything this project/binary supports.
-//: This should give you a sense for what to look forward to in later layers.
-
-:(before "End Commandline Parsing")
-if (argc <= 1 || is_equal(argv[1], "--help")) {
-  //: this is the functionality later layers will provide
-  // currently no automated tests for commandline arg parsing
-  if (argc <= 1) {
-    cerr << "Please provide a Mu program to run.\n"
-         << "\n";
-  }
-  cerr << "Usage:\n"
-       << "  mu [options] [test] [files]\n"
-       << "or:\n"
-       << "  mu [options] [test] [files] -- [ingredients for function/recipe 'main']\n"
-       << "Square brackets surround optional arguments.\n"
-       << "\n"
-       << "Examples:\n"
-       << "  To load files and run 'main':\n"
-       << "    mu file1.mu file2.mu ...\n"
-       << "  To run 'main' and dump a trace of all operations at the end:\n"
-       << "    mu --trace file1.mu file2.mu ...\n"
-       << "  To run all tests:\n"
-       << "    mu test\n"
-       << "  To load files and then run all tests:\n"
-       << "    mu test file1.mu file2.mu ...\n"
-       << "  To run a single Mu scenario:\n"
-       << "    mu test file1.mu file2.mu ... scenario\n"
-       << "  To run a single Mu scenario and dump a trace at the end:\n"
-       << "    mu --trace test file1.mu file2.mu ... scenario\n"
-       << "  To load files and run only the tests in explicitly loaded files (for apps):\n"
-       << "    mu --test-only-app test file1.mu file2.mu ...\n"
-       << "  To load all files with a numeric prefix in a directory:\n"
-       << "    mu directory1 directory2 ...\n"
-       << "  You can test directories just like files.\n"
-       << "    mu test directory1 directory2 ...\n"
-       << "  To pass ingredients to a mu program, provide them after '--':\n"
-       << "    mu file_or_dir1 file_or_dir2 ... -- ingredient1 ingredient2 ...\n"
-       << "  To see where a mu program is spending its time:\n"
-       << "    mu --profile file_or_dir1 file_or_dir2 ...\n"
-       << "  this slices and dices time spent in various profile.* output files\n"
-       << "\n"
-       << "  To browse a trace generated by a previous run:\n"
-       << "    mu browse-trace file\n"
-       ;
-  return 0;
-}
-
-//: Support for option parsing.
-//: Options always begin with '--' and are always the first arguments. An
-//: option will never follow a non-option.
-:(before "End Commandline Parsing")
-char** arg = &argv[1];
-while (argc > 1 && starts_with(*arg, "--")) {
-  if (false)
-    ;  // no-op branch just so any further additions can consistently always start with 'else'
-  // End Commandline Options(*arg)
-  else
-    cerr << "skipping unknown option " << *arg << '\n';
-  --argc;  ++argv;  ++arg;
-}
-
-//:: Helper function used by the above fragment of code (and later layers too,
-//:: who knows?).
-//: The :(code) directive appends function definitions to the end of the
-//: project. Regardless of where functions are defined, we can call them
-//: anywhere we like as long as we format the function header in a specific
-//: way: put it all on a single line without indent, end the line with ') {'
-//: and no trailing whitespace. As long as functions uniformly start this
-//: way, our 'build*' scripts contain a little command to automatically
-//: generate declarations for them.
-:(code)
-bool is_equal(char* s, const char* lit) {
-  return strncmp(s, lit, strlen(lit)) == 0;
-}
-
-bool starts_with(const string& s, const string& pat) {
-  string::const_iterator a=s.begin(), b=pat.begin();
-  for (/*nada*/;  a!=s.end() && b!=pat.end();  ++a, ++b)
-    if (*a != *b) return false;
-  return b == pat.end();
-}
-
-//: I'll throw some style conventions here for want of a better place for them.
-//: As a rule I hate style guides. Do what you want, that's my motto. But since
-//: we're dealing with C/C++, the one big thing we want to avoid is undefined
-//: behavior. If a compiler ever encounters undefined behavior it can make
-//: your program do anything it wants.
-//:
-//: For reference, my checklist of undefined behaviors to watch out for:
-//:   out-of-bounds access
-//:   uninitialized variables
-//:   use after free
-//:   dereferencing invalid pointers: null, a new of size 0, others
-//:
-//:   casting a large number to a type too small to hold it
-//:
-//:   integer overflow
-//:   division by zero and other undefined expressions
-//:   left-shift by negative count
-//:   shifting values by more than or equal to the number of bits they contain
-//:   bitwise operations on signed numbers
-//:
-//:   Converting pointers to types of different alignment requirements
-//:     T* -> void* -> T*: defined
-//:     T* -> U* -> T*: defined if non-function pointers and alignment requirements are same
-//:     function pointers may be cast to other function pointers
-//:
-//:       Casting a numeric value into a value that can't be represented by the target type (either directly or via static_cast)
-//:
-//: To guard against these, some conventions:
-//:
-//: 0. Initialize all primitive variables in functions and constructors.
-//:
-//: 1. Minimize use of pointers and pointer arithmetic. Avoid 'new' and
-//: 'delete' as far as possible. Rely on STL to perform memory management to
-//: avoid use-after-free issues (and memory leaks).
-//:
-//: 2. Avoid naked arrays to avoid out-of-bounds access. Never use operator[]
-//: except with map. Use at() with STL vectors and so on.
-//:
-//: 3. Valgrind all the things.
-//:
-//: 4. Avoid unsigned numbers. Not strictly an undefined-behavior issue, but
-//: the extra range doesn't matter, and it's one less confusing category of
-//: interaction gotchas to worry about.
-//:
-//: Corollary: don't use the size() method on containers, since it returns an
-//: unsigned and that'll cause warnings about mixing signed and unsigned,
-//: yadda-yadda. Instead use this macro below to perform an unsafe cast to
-//: signed. We'll just give up immediately if a container's ever too large.
-//: Basically, Mu is not concerned about this being a little slower than it
-//: could be. (https://gist.github.com/rygorous/e0f055bfb74e3d5f0af20690759de5a7)
-//:
-//: Addendum to corollary: We're going to uniformly use int everywhere, to
-//: indicate that we're oblivious to number size, and since Clang on 32-bit
-//: platforms doesn't yet support multiplication over 64-bit integers, and
-//: since multiplying two integers seems like a more common situation to end
-//: up in than integer overflow.
-:(before "End Includes")
-#define SIZE(X) (assert((X).size() < (1LL<<(sizeof(int)*8-2))), static_cast<int>((X).size()))
-
-//: 5. Integer overflow is guarded against at runtime using the -ftrapv flag
-//: to the compiler, supported by Clang (GCC version only works sometimes:
-//: http://stackoverflow.com/questions/20851061/how-to-make-gcc-ftrapv-work).
-:(before "atexit(reset)")
-initialize_signal_handlers();  // not always necessary, but doesn't hurt
-//? cerr << INT_MAX+1 << '\n';  // test overflow
-//? assert(false);  // test SIGABRT
-:(code)
-// based on https://spin.atomicobject.com/2013/01/13/exceptions-stack-traces-c
-void initialize_signal_handlers() {
-  struct sigaction action;
-  bzero(&action, sizeof(action));
-  action.sa_sigaction = dump_and_exit;
-  sigemptyset(&action.sa_mask);
-  sigaction(SIGABRT, &action, NULL);  // assert() failure or integer overflow on linux (with -ftrapv)
-  sigaction(SIGILL,  &action, NULL);  // integer overflow on OS X (with -ftrapv)
-}
-void dump_and_exit(int sig, siginfo_t* /*unused*/, void* /*unused*/) {
-  switch (sig) {
-    case SIGABRT:
-      #ifndef __APPLE__
-        cerr << "SIGABRT: might be an integer overflow if it wasn't an assert() failure or exception\n";
-        _Exit(1);
-      #endif
-      break;
-    case SIGILL:
-      #ifdef __APPLE__
-        cerr << "SIGILL: most likely caused by integer overflow\n";
-        _Exit(1);
-      #endif
-      break;
-    default:
-      break;
-  }
-}
-:(before "End Includes")
-#include <signal.h>
-
-//: For good measure we'll also enable SIGFPE.
-:(before "atexit(reset)")
-feenableexcept(FE_OVERFLOW | FE_UNDERFLOW);
-//? assert(sizeof(int) == 4 && sizeof(float) == 4);
-//? //                          | exp   |  mantissa
-//? int smallest_subnormal = 0b00000000000000000000000000000001;
-//? float smallest_subnormal_f = *reinterpret_cast<float*>(&smallest_subnormal);
-//? cerr << "ε: " << smallest_subnormal_f << '\n';
-//? cerr << "ε/2: " << smallest_subnormal_f/2 << " (underflow)\n";  // test SIGFPE
-:(before "End Includes")
-#include <fenv.h>
-:(code)
-#ifdef __APPLE__
-// Public domain polyfill for feenableexcept on OS X
-// http://www-personal.umich.edu/~williams/archive/computation/fe-handling-example.c
-int feenableexcept(unsigned int excepts) {
-  static fenv_t fenv;
-  unsigned int new_excepts = excepts & FE_ALL_EXCEPT;
-  unsigned int old_excepts;
-  if (fegetenv(&fenv)) return -1;
-  old_excepts = fenv.__control & FE_ALL_EXCEPT;
-  fenv.__control &= ~new_excepts;
-  fenv.__mxcsr &= ~(new_excepts << 7);
-  return fesetenv(&fenv) ? -1 : old_excepts;
-}
-#endif
-
-//: 6. Map's operator[] being non-const is fucking evil.
-:(before "Globals")  // can't generate prototypes for these
-// from http://stackoverflow.com/questions/152643/idiomatic-c-for-reading-from-a-const-map
-template<typename T> typename T::mapped_type& get(T& map, typename T::key_type const& key) {
-  typename T::iterator iter(map.find(key));
-  assert(iter != map.end());
-  return iter->second;
-}
-template<typename T> typename T::mapped_type const& get(const T& map, typename T::key_type const& key) {
-  typename T::const_iterator iter(map.find(key));
-  assert(iter != map.end());
-  return iter->second;
-}
-template<typename T> typename T::mapped_type const& put(T& map, typename T::key_type const& key, typename T::mapped_type const& value) {
-  // map[key] requires mapped_type to have a zero-arg (default) constructor
-  map.insert(std::make_pair(key, value)).first->second = value;
-  return value;
-}
-template<typename T> bool contains_key(T& map, typename T::key_type const& key) {
-  return map.find(key) != map.end();
-}
-template<typename T> typename T::mapped_type& get_or_insert(T& map, typename T::key_type const& key) {
-  return map[key];
-}
-//: The contract: any container that relies on get_or_insert should never call
-//: contains_key.
-
-//: 7. istreams are a royal pain in the arse. You have to be careful about
-//: what subclass you try to putback into. You have to watch out for the pesky
-//: failbit and badbit. Just avoid eof() and use this helper instead.
-:(code)
-bool has_data(istream& in) {
-  return in && !in.eof();
-}
-
-:(before "End Includes")
-#include <assert.h>
-
-#include <iostream>
-using std::istream;
-using std::ostream;
-using std::iostream;
-using std::cin;
-using std::cout;
-using std::cerr;
-#include <iomanip>
-
-#include <string.h>
-#include <string>
-using std::string;
-
-#include <algorithm>
-using std::min;
-using std::max;
diff --git a/transect/002test.cc b/transect/002test.cc
deleted file mode 100644
index 817b0d47..00000000
--- a/transect/002test.cc
+++ /dev/null
@@ -1,104 +0,0 @@
-//: A simple test harness. To create new tests, define functions starting with
-//: 'test_'. To run all tests so defined, run:
-//:   $ ./mu test
-//:
-//: Every layer should include tests, and can reach into previous layers.
-//: However, it seems like a good idea never to reach into tests from previous
-//: layers. Every test should be a contract that always passes as originally
-//: written, regardless of any later layers. Avoid writing 'temporary' tests
-//: that are only meant to work until some layer.
-
-:(before "End Types")
-typedef void (*test_fn)(void);
-:(before "Globals")
-// move a global ahead into types that we can't generate an extern declaration for
-const test_fn Tests[] = {
-  #include "test_list"  // auto-generated; see 'build*' scripts
-};
-
-:(before "End Globals")
-bool Run_tests = false;
-bool Passed = true;  // set this to false inside any test to indicate failure
-
-:(before "End Includes")
-#define CHECK(X) \
-  if (Passed && !(X)) { \
-    cerr << "\nF - " << __FUNCTION__ << "(" << __FILE__ << ":" << __LINE__ << "): " << #X << '\n'; \
-    Passed = false; \
-    return;  /* Currently we stop at the very first failure. */ \
-  }
-
-#define CHECK_EQ(X, Y) \
-  if (Passed && (X) != (Y)) { \
-    cerr << "\nF - " << __FUNCTION__ << "(" << __FILE__ << ":" << __LINE__ << "): " << #X << " == " << #Y << '\n'; \
-    cerr << "  got " << (X) << '\n';  /* BEWARE: multiple eval */ \
-    Passed = false; \
-    return;  /* Currently we stop at the very first failure. */ \
-  }
-
-:(before "End Reset")
-Passed = true;
-
-:(before "End Commandline Parsing")
-if (argc > 1 && is_equal(argv[1], "test")) {
-  Run_tests = true;  --argc;  ++argv;  // shift 'test' out of commandline args
-}
-
-:(before "End Main")
-if (Run_tests) {
-  // Test Runs
-  // we run some tests and then exit; assume no state need be maintained afterward
-
-  long num_failures = 0;
-  // End Test Run Initialization
-  time_t t;  time(&t);
-  cerr << "C tests: " << ctime(&t);
-  for (size_t i=0;  i < sizeof(Tests)/sizeof(Tests[0]);  ++i) {
-//?     cerr << "running " << Test_names[i] << '\n';
-    run_test(i);
-    if (Passed) cerr << '.';
-    else ++num_failures;
-  }
-  cerr << '\n';
-  // End Tests
-  if (num_failures > 0) {
-    cerr << num_failures << " failure"
-         << (num_failures > 1 ? "s" : "")
-         << '\n';
-    return 1;
-  }
-  return 0;
-}
-
-:(code)
-void run_test(size_t i) {
-  if (i >= sizeof(Tests)/sizeof(Tests[0])) {
-    cerr << "no test " << i << '\n';
-    return;
-  }
-  reset();
-  // End Test Setup
-  (*Tests[i])();
-  // End Test Teardown
-}
-
-//: Convenience: run a single test
-:(before "Globals")
-// Names for each element of the 'Tests' global, respectively.
-const string Test_names[] = {
-  #include "test_name_list"  // auto-generated; see 'build*' scripts
-};
-:(after "Test Runs")
-string maybe_single_test_to_run = argv[argc-1];
-if (!starts_with(maybe_single_test_to_run, "test_"))
-  maybe_single_test_to_run.insert(0, "test_");
-for (size_t i=0;  i < sizeof(Tests)/sizeof(Tests[0]);  ++i) {
-  if (Test_names[i] == maybe_single_test_to_run) {
-    run_test(i);
-    if (Passed) cerr << ".\n";
-    return 0;
-  }
-}
-
-:(before "End Includes")
-#include <stdlib.h>
diff --git a/transect/003trace.cc b/transect/003trace.cc
deleted file mode 100644
index 3b4ae596..00000000
--- a/transect/003trace.cc
+++ /dev/null
@@ -1,408 +0,0 @@
-//: The goal of layers is to make programs more easy to understand and more
-//: malleable, easy to rewrite in radical ways without accidentally breaking
-//: some corner case. Tests further both goals. They help understandability by
-//: letting one make small changes and get feedback. What if I wrote this line
-//: like so? What if I removed this function call, is it really necessary?
-//: Just try it, see if the tests pass. Want to explore rewriting this bit in
-//: this way? Tests put many refactorings on a firmer footing.
-//:
-//: But the usual way we write tests seems incomplete. Refactorings tend to
-//: work in the small, but don't help with changes to function boundaries. If
-//: you want to extract a new function you have to manually test-drive it to
-//: create tests for it. If you want to inline a function its tests are no
-//: longer valid. In both cases you end up having to reorganize code as well as
-//: tests, an error-prone activity.
-//:
-//: In response, this layer introduces the notion of *domain-driven* testing.
-//: We focus on the domain of inputs the whole program needs to handle rather
-//: than the correctness of individual functions. All tests invoke the program
-//: in a single way: by calling run() with some input. As the program operates
-//: on the input, it traces out a list of _facts_ deduced about the domain:
-//:   trace("label") << "fact 1: " << val;
-//:
-//: Tests can now check these facts:
-//:   :(scenario foo)
-//:   34  # call run() with this input
-//:   +label: fact 1: 34  # 'run' should have deduced this fact
-//:   -label: fact 1: 35  # the trace should not contain such a fact
-//:
-//: Since we never call anything but the run() function directly, we never have
-//: to rewrite the tests when we reorganize the internals of the program. We
-//: just have to make sure our rewrite deduces the same facts about the domain,
-//: and that's something we're going to have to do anyway.
-//:
-//: To avoid the combinatorial explosion of integration tests, each layer
-//: mainly logs facts to the trace with a common *label*. All tests in a layer
-//: tend to check facts with this label. Validating the facts logged with a
-//: specific label is like calling functions of that layer directly.
-//:
-//: To build robust tests, trace facts about your domain rather than details of
-//: how you computed them.
-//:
-//: More details: http://akkartik.name/blog/tracing-tests
-//:
-//: ---
-//:
-//: Between layers and domain-driven testing, programming starts to look like a
-//: fundamentally different activity. Instead of a) superficial, b) local rules
-//: on c) code [like say http://blog.bbv.ch/2013/06/05/clean-code-cheat-sheet],
-//: we allow programmers to engage with the a) deep, b) global structure of the
-//: c) domain. If you can systematically track discontinuities in the domain,
-//: you don't care if the code used gotos as long as it passed the tests. If
-//: tests become more robust to run it becomes easier to try out radically
-//: different implementations for the same program. If code is super-easy to
-//: rewrite, it becomes less important what indentation style it uses, or that
-//: the objects are appropriately encapsulated, or that the functions are
-//: referentially transparent.
-//:
-//: Instead of plumbing, programming becomes building and gradually refining a
-//: map of the environment the program must operate under. Whether a program is
-//: 'correct' at a given point in time is a red herring; what matters is
-//: avoiding regression by monotonically nailing down the more 'eventful' parts
-//: of the terrain. It helps readers new and old, and rewards curiosity, to
-//: organize large programs in self-similar hierarchies of example scenarios
-//: colocated with the code that makes them work.
-//:
-//:   "Programming properly should be regarded as an activity by which
-//:   programmers form a mental model, rather than as production of a program."
-//:   -- Peter Naur (http://alistair.cockburn.us/ASD+book+extract%3A+%22Naur,+Ehn,+Musashi%22)
-
-:(before "End Types")
-struct trace_line {
-  int depth;  // optional field just to help browse traces later
-  string label;
-  string contents;
-  trace_line(string l, string c) :depth(0), label(l), contents(c) {}
-  trace_line(int d, string l, string c) :depth(d), label(l), contents(c) {}
-};
-
-//: Support for tracing an entire run.
-//: Traces can have a lot of overhead, so only turn them on when asked.
-:(before "End Commandline Options(*arg)")
-else if (is_equal(*arg, "--trace")) {
-  Save_trace = true;
-}
-:(before "End Commandline Parsing")
-if (Save_trace) {
-  cerr << "initializing trace\n";
-  Trace_stream = new trace_stream;
-}
-:(code)
-void cleanup_main() {
-  if (!Trace_stream) return;
-  if (Save_trace)
-    Trace_stream->save();
-  delete Trace_stream;
-  Trace_stream = NULL;
-}
-:(before "End One-time Setup")
-atexit(cleanup_main);
-
-:(before "End Types")
-// Pre-define some global constants that trace_stream needs to know about.
-// Since they're in the Types section, they'll be included in any cleaved
-// compilation units. So no extern linkage.
-const int Max_depth = 9999;
-const int Error_depth = 0;  // definitely always print errors
-
-struct trace_stream {
-  vector<trace_line> past_lines;
-  // accumulator for current line
-  ostringstream* curr_stream;
-  string curr_label;
-  int curr_depth;
-  int collect_depth;
-  ofstream null_stream;  // never opens a file, so writes silently fail
-  trace_stream() :curr_stream(NULL), curr_depth(Max_depth), collect_depth(Max_depth) {}
-  ~trace_stream() { if (curr_stream) delete curr_stream; }
-
-  ostream& stream(string label) {
-    return stream(Max_depth, label);
-  }
-
-  ostream& stream(int depth, string label) {
-    if (depth > collect_depth) return null_stream;
-    curr_stream = new ostringstream;
-    curr_label = label;
-    curr_depth = depth;
-    (*curr_stream) << std::hex;
-    return *curr_stream;
-  }
-
-  void save() {
-    cerr << "saving trace to 'last_run'\n";
-    ofstream fout("last_run");
-    fout << readable_contents("");
-    fout.close();
-  }
-
-  // be sure to call this before messing with curr_stream or curr_label
-  void newline();
-  // useful for debugging
-  string readable_contents(string label);  // empty label = show everything
-};
-
-:(code)
-void trace_stream::newline() {
-  if (!curr_stream) return;
-  string curr_contents = curr_stream->str();
-  if (!curr_contents.empty()) {
-    past_lines.push_back(trace_line(curr_depth, trim(curr_label), curr_contents));  // preserve indent in contents
-    if ((!Hide_errors && curr_depth == Error_depth)
-        || Dump_trace
-        || (!Dump_label.empty() && curr_label == Dump_label))
-      cerr << curr_label << ": " << curr_contents << '\n';
-  }
-  delete curr_stream;
-  curr_stream = NULL;
-  curr_label.clear();
-  curr_depth = Max_depth;
-}
-
-string trace_stream::readable_contents(string label) {
-  ostringstream output;
-  label = trim(label);
-  for (vector<trace_line>::iterator p = past_lines.begin();  p != past_lines.end();  ++p)
-    if (label.empty() || label == p->label)
-      output << std::setw(4) << p->depth << ' ' << p->label << ": " << p->contents << '\n';
-  return output.str();
-}
-
-:(before "End Globals")
-trace_stream* Trace_stream = NULL;
-int Trace_errors = 0;  // used only when Trace_stream is NULL
-
-:(before "End Globals")
-bool Hide_errors = false;  // if set, don't print even error trace lines to screen
-bool Dump_trace = false;  // if set, print trace lines to screen
-string Dump_label = "";  // if set, print trace lines matching a single label to screen
-:(before "End Reset")
-Hide_errors = false;
-Dump_trace = false;  // toggle this to print traces to screen as they are emitted
-Dump_label = "";
-
-:(before "End Includes")
-#define CLEAR_TRACE  delete Trace_stream, Trace_stream = new trace_stream;
-
-// Top-level helper. IMPORTANT: can't nest
-#define trace(...)  !Trace_stream ? cerr /*print nothing*/ : Trace_stream->stream(__VA_ARGS__)
-
-// Just for debugging; 'git log' should never show any calls to 'dbg'.
-#define dbg trace(0, "a")
-#define DUMP(label)  if (Trace_stream) cerr << Trace_stream->readable_contents(label);
-
-// Errors are a special layer.
-#define raise  (!Trace_stream ? (++Trace_errors,cerr) /*do print*/ : Trace_stream->stream(Error_depth, "error"))
-// If we aren't yet sure how to deal with some corner case, use assert_for_now
-// to indicate that it isn't an inviolable invariant.
-#define assert_for_now assert
-
-// Inside tests, fail any tests that displayed (unexpected) errors.
-// Expected errors in tests should always be hidden and silently checked for.
-:(before "End Test Teardown")
-if (Passed && !Hide_errors && trace_contains_errors()) {
-  Passed = false;
-}
-:(code)
-bool trace_contains_errors() {
-  return Trace_errors > 0 || trace_count("error") > 0;
-}
-
-:(before "End Types")
-struct end {};
-:(code)
-ostream& operator<<(ostream& os, end /*unused*/) {
-  if (Trace_stream) Trace_stream->newline();
-  return os;
-}
-
-:(before "End Globals")
-bool Save_trace = false;  // if set, write out trace to disk
-
-// Trace_stream is a resource, lease_tracer uses RAII to manage it.
-:(before "End Types")
-struct lease_tracer {
-  lease_tracer();
-  ~lease_tracer();
-};
-:(code)
-lease_tracer::lease_tracer() { Trace_stream = new trace_stream; }
-lease_tracer::~lease_tracer() {
-  if (Save_trace) Trace_stream->save();
-  delete Trace_stream, Trace_stream = NULL;
-}
-:(before "End Includes")
-#define START_TRACING_UNTIL_END_OF_SCOPE  lease_tracer leased_tracer;
-:(before "End Test Setup")
-START_TRACING_UNTIL_END_OF_SCOPE
-
-:(before "End Includes")
-#define CHECK_TRACE_CONTENTS(...)  check_trace_contents(__FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
-
-#define CHECK_TRACE_CONTAINS_ERRORS()  CHECK(trace_contains_errors())
-#define CHECK_TRACE_DOESNT_CONTAIN_ERRORS() \
-  if (Passed && trace_contains_errors()) { \
-    cerr << "\nF - " << __FUNCTION__ << "(" << __FILE__ << ":" << __LINE__ << "): unexpected errors\n"; \
-    DUMP("error"); \
-    Passed = false; \
-    return; \
-  }
-
-#define CHECK_TRACE_COUNT(label, count) \
-  if (Passed && trace_count(label) != (count)) { \
-    cerr << "\nF - " << __FUNCTION__ << "(" << __FILE__ << ":" << __LINE__ << "): trace_count of " << label << " should be " << count << '\n'; \
-    cerr << "  got " << trace_count(label) << '\n';  /* multiple eval */ \
-    DUMP(label); \
-    Passed = false; \
-    return;  /* Currently we stop at the very first failure. */ \
-  }
-
-#define CHECK_TRACE_DOESNT_CONTAIN(...)  CHECK(trace_doesnt_contain(__VA_ARGS__))
-
-:(code)
-bool check_trace_contents(string FUNCTION, string FILE, int LINE, string expected) {
-  if (!Passed) return false;
-  if (!Trace_stream) return false;
-  vector<string> expected_lines = split(expected, "");
-  int curr_expected_line = 0;
-  while (curr_expected_line < SIZE(expected_lines) && expected_lines.at(curr_expected_line).empty())
-    ++curr_expected_line;
-  if (curr_expected_line == SIZE(expected_lines)) return true;
-  string label, contents;
-  split_label_contents(expected_lines.at(curr_expected_line), &label, &contents);
-  for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin();  p != Trace_stream->past_lines.end();  ++p) {
-    if (label != p->label) continue;
-    if (contents != trim(p->contents)) continue;
-    ++curr_expected_line;
-    while (curr_expected_line < SIZE(expected_lines) && expected_lines.at(curr_expected_line).empty())
-      ++curr_expected_line;
-    if (curr_expected_line == SIZE(expected_lines)) return true;
-    split_label_contents(expected_lines.at(curr_expected_line), &label, &contents);
-  }
-
-  if (line_exists_anywhere(label, contents)) {
-    cerr << "\nF - " << FUNCTION << "(" << FILE << ":" << LINE << "): line [" << label << ": " << contents << "] out of order in trace:\n";
-    DUMP("");
-  }
-  else {
-    cerr << "\nF - " << FUNCTION << "(" << FILE << ":" << LINE << "): missing [" << contents << "] in trace:\n";
-    DUMP(label);
-  }
-  Passed = false;
-  return false;
-}
-
-void split_label_contents(const string& s, string* label, string* contents) {
-  static const string delim(": ");
-  size_t pos = s.find(delim);
-  if (pos == string::npos) {
-    *label = "";
-    *contents = trim(s);
-  }
-  else {
-    *label = trim(s.substr(0, pos));
-    *contents = trim(s.substr(pos+SIZE(delim)));
-  }
-}
-
-bool line_exists_anywhere(const string& label, const string& contents) {
-  for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin();  p != Trace_stream->past_lines.end();  ++p) {
-    if (label != p->label) continue;
-    if (contents == trim(p->contents)) return true;
-  }
-  return false;
-}
-
-int trace_count(string label) {
-  return trace_count(label, "");
-}
-
-int trace_count(string label, string line) {
-  if (!Trace_stream) return 0;
-  long result = 0;
-  for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin();  p != Trace_stream->past_lines.end();  ++p) {
-    if (label == p->label) {
-      if (line == "" || trim(line) == trim(p->contents))
-        ++result;
-    }
-  }
-  return result;
-}
-
-int trace_count_prefix(string label, string prefix) {
-  if (!Trace_stream) return 0;
-  long result = 0;
-  for (vector<trace_line>::iterator p = Trace_stream->past_lines.begin();  p != Trace_stream->past_lines.end();  ++p) {
-    if (label == p->label) {
-      if (starts_with(trim(p->contents), trim(prefix)))
-        ++result;
-    }
-  }
-  return result;
-}
-
-bool trace_doesnt_contain(string label, string line) {
-  return trace_count(label, line) == 0;
-}
-
-bool trace_doesnt_contain(string expected) {
-  vector<string> tmp = split_first(expected, ": ");
-  if (SIZE(tmp) == 1) {
-    raise << expected << ": missing label or contents in trace line\n" << end();
-    assert(false);
-  }
-  return trace_doesnt_contain(tmp.at(0), tmp.at(1));
-}
-
-vector<string> split(string s, string delim) {
-  vector<string> result;
-  size_t begin=0, end=s.find(delim);
-  while (true) {
-    if (end == string::npos) {
-      result.push_back(string(s, begin, string::npos));
-      break;
-    }
-    result.push_back(string(s, begin, end-begin));
-    begin = end+SIZE(delim);
-    end = s.find(delim, begin);
-  }
-  return result;
-}
-
-vector<string> split_first(string s, string delim) {
-  vector<string> result;
-  size_t end=s.find(delim);
-  result.push_back(string(s, 0, end));
-  if (end != string::npos)
-    result.push_back(string(s, end+SIZE(delim), string::npos));
-  return result;
-}
-
-string trim(const string& s) {
-  string::const_iterator first = s.begin();
-  while (first != s.end() && isspace(*first))
-    ++first;
-  if (first == s.end()) return "";
-
-  string::const_iterator last = --s.end();
-  while (last != s.begin() && isspace(*last))
-    --last;
-  ++last;
-  return string(first, last);
-}
-
-:(before "End Includes")
-#include <vector>
-using std::vector;
-#include <list>
-using std::list;
-#include <set>
-using std::set;
-
-#include <sstream>
-using std::istringstream;
-using std::ostringstream;
-
-#include <fstream>
-using std::ifstream;
-using std::ofstream;
diff --git a/transect/003trace.test.cc b/transect/003trace.test.cc
deleted file mode 100644
index 67b4c345..00000000
--- a/transect/003trace.test.cc
+++ /dev/null
@@ -1,124 +0,0 @@
-void test_trace_check_compares() {
-  trace("test layer") << "foo" << end();
-  CHECK_TRACE_CONTENTS("test layer: foo");
-}
-
-void test_trace_check_ignores_other_layers() {
-  trace("test layer 1") << "foo" << end();
-  trace("test layer 2") << "bar" << end();
-  CHECK_TRACE_CONTENTS("test layer 1: foo");
-  CHECK_TRACE_DOESNT_CONTAIN("test layer 2: foo");
-}
-
-void test_trace_check_ignores_leading_whitespace() {
-  trace("test layer 1") << " foo" << end();
-  CHECK_EQ(trace_count("test layer 1", /*too little whitespace*/"foo"), 1);
-  CHECK_EQ(trace_count("test layer 1", /*too much whitespace*/"  foo"), 1);
-}
-
-void test_trace_check_ignores_other_lines() {
-  trace("test layer 1") << "foo" << end();
-  trace("test layer 1") << "bar" << end();
-  CHECK_TRACE_CONTENTS("test layer 1: foo");
-}
-
-void test_trace_check_ignores_other_lines2() {
-  trace("test layer 1") << "foo" << end();
-  trace("test layer 1") << "bar" << end();
-  CHECK_TRACE_CONTENTS("test layer 1: bar");
-}
-
-void test_trace_ignores_trailing_whitespace() {
-  trace("test layer 1") << "foo\n" << end();
-  CHECK_TRACE_CONTENTS("test layer 1: foo");
-}
-
-void test_trace_ignores_trailing_whitespace2() {
-  trace("test layer 1") << "foo " << end();
-  CHECK_TRACE_CONTENTS("test layer 1: foo");
-}
-
-void test_trace_orders_across_layers() {
-  trace("test layer 1") << "foo" << end();
-  trace("test layer 2") << "bar" << end();
-  trace("test layer 1") << "qux" << end();
-  CHECK_TRACE_CONTENTS("test layer 1: footest layer 2: bartest layer 1: qux");
-}
-
-void test_trace_supports_count() {
-  trace("test layer 1") << "foo" << end();
-  trace("test layer 1") << "foo" << end();
-  CHECK_EQ(trace_count("test layer 1", "foo"), 2);
-}
-
-void test_trace_supports_count2() {
-  trace("test layer 1") << "foo" << end();
-  trace("test layer 1") << "bar" << end();
-  CHECK_EQ(trace_count("test layer 1"), 2);
-}
-
-void test_trace_count_ignores_trailing_whitespace() {
-  trace("test layer 1") << "foo\n" << end();
-  CHECK_EQ(trace_count("test layer 1", "foo"), 1);
-}
-
-// pending: DUMP tests
-// pending: readable_contents() adds newline if necessary.
-// pending: raise also prints to stderr.
-// pending: raise doesn't print to stderr if Hide_errors is set.
-// pending: raise doesn't have to be saved if Hide_errors is set, just printed.
-// pending: raise prints to stderr if Trace_stream is NULL.
-// pending: raise prints to stderr if Trace_stream is NULL even if Hide_errors is set.
-
-// can't check trace because trace methods call 'split'
-
-void test_split_returns_at_least_one_elem() {
-  vector<string> result = split("", ",");
-  CHECK_EQ(result.size(), 1);
-  CHECK_EQ(result.at(0), "");
-}
-
-void test_split_returns_entire_input_when_no_delim() {
-  vector<string> result = split("abc", ",");
-  CHECK_EQ(result.size(), 1);
-  CHECK_EQ(result.at(0), "abc");
-}
-
-void test_split_works() {
-  vector<string> result = split("abc,def", ",");
-  CHECK_EQ(result.size(), 2);
-  CHECK_EQ(result.at(0), "abc");
-  CHECK_EQ(result.at(1), "def");
-}
-
-void test_split_works2() {
-  vector<string> result = split("abc,def,ghi", ",");
-  CHECK_EQ(result.size(), 3);
-  CHECK_EQ(result.at(0), "abc");
-  CHECK_EQ(result.at(1), "def");
-  CHECK_EQ(result.at(2), "ghi");
-}
-
-void test_split_handles_multichar_delim() {
-  vector<string> result = split("abc,,def,,ghi", ",,");
-  CHECK_EQ(result.size(), 3);
-  CHECK_EQ(result.at(0), "abc");
-  CHECK_EQ(result.at(1), "def");
-  CHECK_EQ(result.at(2), "ghi");
-}
-
-void test_trim() {
-  CHECK_EQ(trim(""), "");
-  CHECK_EQ(trim(" "), "");
-  CHECK_EQ(trim("  "), "");
-  CHECK_EQ(trim("a"), "a");
-  CHECK_EQ(trim(" a"), "a");
-  CHECK_EQ(trim("  a"), "a");
-  CHECK_EQ(trim("  ab"), "ab");
-  CHECK_EQ(trim("a "), "a");
-  CHECK_EQ(trim("a  "), "a");
-  CHECK_EQ(trim("ab  "), "ab");
-  CHECK_EQ(trim(" a "), "a");
-  CHECK_EQ(trim("  a  "), "a");
-  CHECK_EQ(trim("  ab  "), "ab");
-}
diff --git a/transect/010vm.cc b/transect/010vm.cc
deleted file mode 100644
index fad1ee77..00000000
--- a/transect/010vm.cc
+++ /dev/null
@@ -1,230 +0,0 @@
-//: type definitions start with either 'record' or 'choice'
-
-:(before "End Types")
-typedef int type_id;
-:(before "End Globals")
-map</*name*/string, type_id> Type_id;
-map<type_id, type_info> Type_info;
-type_id Next_type_id = 1;
-// primitive types
-type_id Literal_type_id = 0, Int_type_id = 0, Byte_type_id = 0, Address_type_id = 0, Array_type_id = 0, Ref_type_id = 0;
-:(before "End Types")
-struct type_info {
-  type_id id;
-  string name;
-  kind_of_type kind;
-  int size;  // in bytes
-  vector<type_declaration> elements;
-  type_info() :kind(PRIMITIVE), size(0) {}
-};
-:(before "struct type_info")
-enum kind_of_type {
-  PRIMITIVE,
-  RECORD,
-  CHOICE,
-};
-struct type_declaration {
-  string name;
-  vector<type_id> type;
-};
-
-//: global definitions start with 'var'
-
-:(before "End Types")
-typedef int global_id;
-:(before "End Globals")
-map</*name*/string, global_id> Global_id;
-map<global_id, global_info> Global_info;
-global_id Next_global_id = 1;
-:(before "End Types")
-struct global_info {
-  global_id id;
-  vector<type_id> type;
-  int address;
-  global_info() :address(0) {}
-};
-
-//: function definitions start with 'fn'
-
-:(before "End Types")
-typedef int function_id;
-:(before "End Globals")
-map</*name*/string, function_id> Function_id;
-map<function_id, function_info> Function_info;
-function_id Next_function_id = 1;
-:(before "End Types")
-struct function_info {
-  function_id id;
-  string name;
-  vector<operand> in;
-  vector<operand> in_out;
-  vector<instruction> instructions;
-  map</*local variable name*/string, int> stack_offset;
-  function_info() :id(0) {}
-};
-:(before "struct function_info")
-// operands have form name/property1/property2/... : (type1 type2 ...)
-struct operand {
-  string name;
-  vector<type_id> type;
-  vector<string> properties;
-  operand(string);
-  void set_type(istream&);
-};
-
-struct instruction {
-  function_id id;
-  string name;
-  vector<operand> in;
-  vector<operand> in_out;
-};
-:(code)
-operand::operand(string s) {
-  istringstream in(s);
-  name = slurp_until(in, '/');
-  while (has_data(in))
-    properties.push_back(slurp_until(in, '/'));
-}
-
-// extremely hacky; assumes a single-level list of words in parens, with no nesting
-void operand::set_type(istream& in) {
-  assert(has_data(in));
-  string curr;
-  in >> curr;
-//?   cerr << "2: " << curr << '\n';
-  if (curr.at(0) != '(') {
-    type.push_back(get(Type_id, curr));
-    return;
-  }
-  curr = curr.substr(/*skip '('*/1);
-  while (!ends_with(curr, ")")) {
-    if (curr.empty()) continue;
-    assert(curr.at(0) != '(');
-    type.push_back(get(Type_id, curr));
-    // update
-    assert(has_data(in));
-    in >> curr;
-  }
-  assert(ends_with(curr, ")"));
-  curr = curr.substr(0, SIZE(curr)-1);
-  if (!curr.empty()) {
-    /*'(' or ')' isn't a token by itself*/
-    type.push_back(get(Type_id, curr));
-  }
-}
-
-string to_string(const operand& o) {
-  ostringstream out;
-  out << o.name;
-  if (o.type.empty()) return out.str();
-  out << " : ";
-  if (SIZE(o.type) == 1) {
-    out << get(Type_info, o.type.at(0)).name;
-    return out.str();
-  }
-  out << "(";
-  for (int i = 0;  i < SIZE(o.type);  ++i) {
-    if (i > 0) out << ", ";
-    out << get(Type_info, o.type.at(i)).name;
-  }
-  out << ")";
-  return out.str();
-}
-
-string slurp_until(istream& in, char delim) {
-  ostringstream out;
-  char c;
-  while (in >> c) {
-    if (c == delim) {
-      // drop the delim
-      break;
-    }
-    out << c;
-  }
-  return out.str();
-}
-
-bool ends_with(const string& s, const string& pat) {
-  for (string::const_reverse_iterator p = s.rbegin(), q = pat.rbegin();  q != pat.rend();  ++p, ++q) {
-    if (p == s.rend()) return false;  // pat too long
-    if (*p != *q) return false;
-  }
-  return true;
-}
-
-:(before "End One-time Setup")
-init_primitive_types();
-:(code)
-void init_primitive_types() {
-  Literal_type_id = new_type("literal", PRIMITIVE, 0);
-  Int_type_id = new_type("int", PRIMITIVE, 4);
-  Byte_type_id = new_type("byte", PRIMITIVE, 1);
-  Address_type_id = new_type("address", PRIMITIVE, 4);
-  Array_type_id = new_type("array", PRIMITIVE, 0);  // size will depend on length
-  Ref_type_id = new_type("ref", PRIMITIVE, 8);  // address + alloc id
-}
-
-type_id new_type(string name, kind_of_type kind, int size) {
-  assert(!contains_key(Type_id, name));
-  int result = Next_type_id++;
-  put(Type_id, name, result);
-  assert(!contains_key(Type_info, result));
-  type_info& curr = Type_info[result];  // insert
-  curr.id = result;
-  curr.name = name;
-  curr.kind = kind;
-  curr.size = size;
-  return result;
-}
-
-//: Start each test by undoing the previous test's types, globals and functions
-
-:(before "End One-time Setup")
-save_snapshots();
-:(before "End Reset")
-restore_snapshots();
-
-:(before "End Globals")
-map<string, type_id> Type_id_snapshot;
-map<type_id, type_info> Type_info_snapshot;
-type_id Next_type_id_snapshot = 0;
-
-map<string, global_id> Global_id_snapshot;
-map<global_id, global_info> Global_info_snapshot;
-global_id Next_global_id_snapshot = 0;
-
-map<string, function_id> Function_id_snapshot;
-map<function_id, function_info> Function_info_snapshot;
-function_id Next_function_id_snapshot = 0;
-:(code)
-void save_snapshots() {
-  Type_id_snapshot = Type_id;
-  Type_info_snapshot = Type_info;
-  Next_type_id_snapshot = Next_type_id;
-
-  Global_id_snapshot = Global_id;
-  Global_info_snapshot = Global_info;
-  Next_global_id_snapshot = Next_global_id;
-
-  Function_id_snapshot = Function_id;
-  Function_info_snapshot = Function_info;
-  Next_function_id_snapshot = Next_function_id;
-}
-
-void restore_snapshots() {
-  Type_id = Type_id_snapshot;
-  Type_info = Type_info_snapshot;
-  Next_type_id = Next_type_id_snapshot;
-
-  Global_id = Global_id_snapshot;
-  Global_info = Global_info_snapshot;
-  Next_global_id = Next_global_id_snapshot;
-
-  Function_id = Function_id_snapshot;
-  Function_info = Function_info_snapshot;
-  Next_function_id = Next_function_id_snapshot;
-}
-
-:(before "End Includes")
-#include <map>
-using std::map;
diff --git a/transect/011load.cc b/transect/011load.cc
deleted file mode 100644
index f8cf96e8..00000000
--- a/transect/011load.cc
+++ /dev/null
@@ -1,228 +0,0 @@
-//: Phase 1 of translating Mu code: load it from a textual representation.
-//:
-//: The process of translating Mu code:
-//:   load -> check types -> convert
-
-:(scenarios load)  // use 'load' instead of 'run' in all scenarios in this layer
-:(scenario single_function)
-fn foo [
-  1 : int <- copy 23
-]
-+parse: function: foo
-+parse:   0 in operands
-+parse:   0 in_out operands
-+parse: instruction: copy
-+parse:   in => 23 : literal
-+parse:   in_out => 1 : int
-
-:(code)
-void load(string form) {
-  istringstream in(form);
-  load(in);
-}
-
-void load(istream& in) {
-  while (has_data(in)) {
-    string line_data;
-    getline(in, line_data);
-    if (line_data.empty()) continue;  // maybe eof
-    char c = first_non_whitespace(line_data);
-    if (c == '\0') continue;  // only whitespace
-    if (c == '#') continue;  // only comment
-    trace(99, "parse") << "line: " << line_data << end();
-    istringstream lin(line_data);
-    while (has_data(lin)) {
-      string word_data;
-      lin >> word_data;
-      if (word_data.empty()) continue;  // maybe eof
-      if (word_data[0] == '#') break;  // comment; ignore rest of line
-      if (word_data == "record")
-        load_record(lin, in);
-      else if (word_data == "choice")
-        load_choice(lin, in);
-      else if (word_data == "var")
-        load_global(lin, in);
-      else if (word_data == "fn")
-        load_function(lin, in);
-      else
-        raise << "unrecognized top-level keyword '" << word_data << "'; should be one of 'record', 'choice', 'var' or 'fn'\n" << end();
-      break;
-    }
-    // nothing here, because we'll be at the next top-level declaration
-  }
-}
-
-void load_record(istream& first_line, istream& in) {
-}
-
-void load_choice(istream& first_line, istream& in) {
-}
-
-void load_global(istream& first_line, istream& in) {
-}
-
-void load_function(istream& first_line, istream& in) {
-  string name;
-  assert(has_data(first_line));
-  first_line >> name;
-  trace(99, "parse") << "function: " << name << end();
-  function_info& curr = new_function(name);
-  string tmp;
-  // read in parameters
-  while (has_data(first_line)) {
-    // read operand name
-    first_line >> tmp;
-//?     cerr << "0: " << tmp << '\n';
-    if (tmp == "[") break;
-    if (tmp == "->") break;
-    assert(tmp != ":");
-    curr.in.push_back(operand(tmp));
-
-    // skip ':'
-    assert(has_data(first_line));
-    first_line >> tmp;
-//?     cerr << "1: " << tmp << '\n';
-    assert(tmp == ":");  // types are required in function headers
-
-    // read operand type
-    assert(has_data(first_line));
-    curr.in.back().set_type(first_line);
-  }
-  // read in-out parameters
-  while (tmp != "[" && has_data(first_line)) {
-    // read operand name
-    first_line >> tmp;
-//?     cerr << "inout 0: " << tmp << '\n';
-    if (tmp == "[") break;
-    assert(tmp != "->");
-    assert(tmp != ":");  // types are required in function headers
-    curr.in_out.push_back(operand(tmp));
-
-    // skip ':'
-    assert(has_data(first_line));
-    first_line >> tmp;
-//?     cerr << "inout 1: " << tmp << '\n';
-    assert(tmp == ":");
-
-    // read operand type
-    assert(has_data(first_line));
-    curr.in.back().set_type(first_line);
-  }
-  trace(99, "parse") << "  " << SIZE(curr.in) << " in operands" << end();
-  trace(99, "parse") << "  " << SIZE(curr.in_out) << " in_out operands" << end();
-  // not bothering checking for tokens past '[' in first_line
-  
-  // read instructions
-  while (has_data(in)) {
-    string line_data;
-    getline(in, line_data);
-    if (first_non_whitespace(line_data) == ']') break;
-//?     bool has_in_out = (line_data.find("<-") != string::npos);
-    istringstream line(line_data);
-    vector<string> words;
-    bool has_in_out = false;
-    while (has_data(line)) {
-      string w;
-      line >> w;
-      words.push_back(w);
-      if (w == "<-")
-        has_in_out = true;
-    }
-    instruction inst;
-    int i = 0;
-    assert(i < SIZE(words));
-    if (has_in_out) {
-      while (i < SIZE(words)) {
-//?         cerr << "in-out operand: " << i << ' ' << words.at(i) << '\n';
-        inst.in_out.push_back(operand(words.at(i)));
-        ++i;
-        assert(i < SIZE(words));
-        if (words.at(i) == ":") {
-          ++i;  // skip ':'
-          assert(i < SIZE(words));
-          assert(words.at(i) != "<-");
-          assert(words.at(i) != ":");
-          istringstream tmp(words.at(i));
-//?           cerr << "setting type to " << i << ' ' << words.at(i) << '\n';
-          inst.in_out.back().set_type(tmp);
-//?           cerr << "done\n";
-          ++i;
-          assert(i < SIZE(words));
-        }
-        if (words.at(i) == "<-") break;
-      }
-      assert(i < SIZE(words));
-      assert(words.at(i) == "<-");
-      ++i;
-    }
-    assert(i < SIZE(words));
-    assert(words.at(i) != "<-");
-    assert(words.at(i) != ":");
-    inst.name = words.at(i);
-    ++i;
-    while (i < SIZE(words)) {
-      inst.in.push_back(operand(words.at(i)));
-      ++i;
-      if (i < SIZE(words) && words.at(i) == ":") {
-        ++i;  // skip ':'
-        assert(i < SIZE(words));
-        assert(words.at(i) != "<-");
-        assert(words.at(i) != ":");
-        istringstream tmp(words.at(i));
-        inst.in.back().set_type(tmp);
-        ++i;
-      }
-      else if (is_integer(inst.in.back().name)) {
-        inst.in.back().type.push_back(Literal_type_id);
-      }
-    }
-    trace(99, "parse") << "instruction: " << inst.name << end();
-    for (int i = 0;  i < SIZE(inst.in);  ++i)
-      trace(99, "parse") << "  in => " << to_string(inst.in.at(i)) << end();
-    for (int i = 0;  i < SIZE(inst.in_out);  ++i)
-      trace(99, "parse") << "  in_out => " << to_string(inst.in_out.at(i)) << end();
-    curr.instructions.push_back(inst);
-  }
-}
-
-function_info& new_function(string name) {
-  assert(!contains_key(Function_id, name));
-  int id = Next_function_id++;
-  put(Function_id, name, id);
-  assert(!contains_key(Function_info, id));
-  function_info& result = Function_info[id];  // insert
-  result.id = id;
-  result.name = name;
-  return result;
-}
-
-char first_non_whitespace(string in) {
-  for (int i = 0;  i < SIZE(in);  ++i)
-    if (!isspace(in.at(i))) return in.at(i);
-  return '\0';
-}
-
-bool is_integer(const string& s) {
-  return s.find_first_not_of("0123456789-") == string::npos  // no other characters
-      && s.find_first_of("0123456789") != string::npos  // at least one digit
-      && s.find('-', 1) == string::npos;  // '-' only at first position
-}
-
-int to_integer(string n) {
-  char* end = NULL;
-  // safe because string.c_str() is guaranteed to be null-terminated
-  int result = strtoll(n.c_str(), &end, /*any base*/0);
-  if (*end != '\0') cerr << "tried to convert " << n << " to number\n";
-  assert(*end == '\0');
-  return result;
-}
-
-void test_is_integer() {
-  CHECK(is_integer("1234"));
-  CHECK(is_integer("-1"));
-  CHECK(!is_integer("234.0"));
-  CHECK(is_integer("-567"));
-  CHECK(!is_integer("89-0"));
-  CHECK(!is_integer("-"));
-  CHECK(!is_integer("1e3"));  // not supported
-}