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, 329 insertions, 249 deletions

diff --git a/054static_dispatch.cc b/054static_dispatch.cc
index cdd23e4f..289dce87 100644
--- a/054static_dispatch.cc
+++ b/054static_dispatch.cc
@@ -2,17 +2,22 @@
 //: number and types of the ingredients and products. Allows us to use nice
 //: names like 'print' or 'length' in many mutually extensible ways.
 
-:(scenario static_dispatch)
-def main [
-  7:num/raw <- test 3
-]
-def test a:num -> z:num [
-  z <- copy 1
-]
-def test a:num, b:num -> z:num [
-  z <- copy 2
-]
-+mem: storing 1 in location 7
+void test_static_dispatch() {
+  run(
+      "def main [\n"
+      "  7:num/raw <- test 3\n"
+      "]\n"
+      "def test a:num -> z:num [\n"
+      "  z <- copy 1\n"
+      "]\n"
+      "def test a:num, b:num -> z:num [\n"
+      "  z <- copy 2\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 1 in location 7\n"
+  );
+}
 
 //: When loading recipes, accumulate variants if headers don't collide, and
 //: flag an error if headers collide.
@@ -120,17 +125,22 @@ string next_unused_recipe_name(const string& recipe_name) {
 //: Once all the recipes are loaded, transform their bodies to replace each
 //: call with the most suitable variant.
 
-:(scenario static_dispatch_picks_most_similar_variant)
-def main [
-  7:num/raw <- test 3, 4, 5
-]
-def test a:num -> z:num [
-  z <- copy 1
-]
-def test a:num, b:num -> z:num [
-  z <- copy 2
-]
-+mem: storing 2 in location 7
+void test_static_dispatch_picks_most_similar_variant() {
+  run(
+      "def main [\n"
+      "  7:num/raw <- test 3, 4, 5\n"
+      "]\n"
+      "def test a:num -> z:num [\n"
+      "  z <- copy 1\n"
+      "]\n"
+      "def test a:num, b:num -> z:num [\n"
+      "  z <- copy 2\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 2 in location 7\n"
+  );
+}
 
 //: support recipe headers in a previous transform to fill in missing types
 :(before "End check_or_set_invalid_types")
@@ -343,144 +353,189 @@ bool next_stash(const call& c, instruction* stash_inst) {
   return false;
 }
 
-:(scenario static_dispatch_disabled_in_recipe_without_variants)
-def main [
-  1:num <- test 3
-]
-def test [
-  2:num <- next-ingredient  # ensure no header
-  return 34
-]
-+mem: storing 34 in location 1
-
-:(scenario static_dispatch_disabled_on_headerless_definition)
-% Hide_errors = true;
-def test a:num -> z:num [
-  z <- copy 1
-]
-def test [
-  return 34
-]
-+error: redefining recipe test
-
-:(scenario static_dispatch_disabled_on_headerless_definition_2)
-% Hide_errors = true;
-def test [
-  return 34
-]
-def test a:num -> z:num [
-  z <- copy 1
-]
-+error: redefining recipe test
-
-:(scenario static_dispatch_on_primitive_names)
-def main [
-  1:num <- copy 34
-  2:num <- copy 34
-  3:bool <- equal 1:num, 2:num
-  4:bool <- copy false
-  5:bool <- copy false
-  6:bool <- equal 4:bool, 5:bool
-]
-# temporarily hardcode number equality to always fail
-def equal x:num, y:num -> z:bool [
-  local-scope
-  load-ingredients
-  z <- copy false
-]
-# comparing numbers used overload
-+mem: storing 0 in location 3
-# comparing booleans continues to use primitive
-+mem: storing 1 in location 6
-
-:(scenario static_dispatch_works_with_dummy_results_for_containers)
-def main [
-  _ <- test 3, 4
-]
-def test a:num -> z:point [
-  local-scope
-  load-ingredients
-  z <- merge a, 0
-]
-def test a:num, b:num -> z:point [
-  local-scope
-  load-ingredients
-  z <- merge a, b
-]
-$error: 0
-
-:(scenario static_dispatch_works_with_compound_type_containing_container_defined_after_first_use)
-def main [
-  x:&:foo <- new foo:type
-  test x
-]
-container foo [
-  x:num
-]
-def test a:&:foo -> z:num [
-  local-scope
-  load-ingredients
-  z:num <- get *a, x:offset
-]
-$error: 0
-
-:(scenario static_dispatch_works_with_compound_type_containing_container_defined_after_second_use)
-def main [
-  x:&:foo <- new foo:type
-  test x
-]
-def test a:&:foo -> z:num [
-  local-scope
-  load-ingredients
-  z:num <- get *a, x:offset
-]
-container foo [
-  x:num
-]
-$error: 0
-
-:(scenario static_dispatch_on_non_literal_character_ignores_variant_with_numbers)
-% Hide_errors = true;
-def main [
-  local-scope
-  x:char <- copy 10/newline
-  1:num/raw <- foo x
-]
-def foo x:num -> y:num [
-  load-ingredients
-  return 34
-]
-+error: main: ingredient 0 has the wrong type at '1:num/raw <- foo x'
--mem: storing 34 in location 1
-
-:(scenario static_dispatch_dispatches_literal_to_character)
-def main [
-  1:num/raw <- foo 97
-]
-def foo x:char -> y:num [
-  local-scope
-  load-ingredients
-  return 34
-]
-# character variant is preferred
-+mem: storing 34 in location 1
-
-:(scenario static_dispatch_dispatches_literal_to_number_if_at_all_possible)
-def main [
-  1:num/raw <- foo 97
-]
-def foo x:char -> y:num [
-  local-scope
-  load-ingredients
-  return 34
-]
-def foo x:num -> y:num [
-  local-scope
-  load-ingredients
-  return 35
-]
-# number variant is preferred
-+mem: storing 35 in location 1
+void test_static_dispatch_disabled_in_recipe_without_variants() {
+  run(
+      "def main [\n"
+      "  1:num <- test 3\n"
+      "]\n"
+      "def test [\n"
+      "  2:num <- next-ingredient  # ensure no header\n"
+      "  return 34\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 34 in location 1\n"
+  );
+}
+
+void test_static_dispatch_disabled_on_headerless_definition() {
+  Hide_errors = true;
+  run(
+      "def test a:num -> z:num [\n"
+      "  z <- copy 1\n"
+      "]\n"
+      "def test [\n"
+      "  return 34\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: redefining recipe test\n"
+  );
+}
+
+void test_static_dispatch_disabled_on_headerless_definition_2() {
+  Hide_errors = true;
+  run(
+      "def test [\n"
+      "  return 34\n"
+      "]\n"
+      "def test a:num -> z:num [\n"
+      "  z <- copy 1\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: redefining recipe test\n"
+  );
+}
+
+void test_static_dispatch_on_primitive_names() {
+  run(
+      "def main [\n"
+      "  1:num <- copy 34\n"
+      "  2:num <- copy 34\n"
+      "  3:bool <- equal 1:num, 2:num\n"
+      "  4:bool <- copy false\n"
+      "  5:bool <- copy false\n"
+      "  6:bool <- equal 4:bool, 5:bool\n"
+      "]\n"
+      // temporarily hardcode number equality to always fail
+      "def equal x:num, y:num -> z:bool [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  z <- copy false\n"
+      "]\n"
+      "# comparing numbers used overload\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      // comparing numbers used overload
+      "mem: storing 0 in location 3\n"
+      // comparing booleans continues to use primitive
+      "mem: storing 1 in location 6\n"
+  );
+}
+
+void test_static_dispatch_works_with_dummy_results_for_containers() {
+  run(
+      "def main [\n"
+      "  _ <- test 3, 4\n"
+      "]\n"
+      "def test a:num -> z:point [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  z <- merge a, 0\n"
+      "]\n"
+      "def test a:num, b:num -> z:point [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  z <- merge a, b\n"
+      "]\n"
+  );
+  CHECK_TRACE_COUNT("error", 0);
+}
+
+void test_static_dispatch_works_with_compound_type_containing_container_defined_after_first_use() {
+  run(
+      "def main [\n"
+      "  x:&:foo <- new foo:type\n"
+      "  test x\n"
+      "]\n"
+      "container foo [\n"
+      "  x:num\n"
+      "]\n"
+      "def test a:&:foo -> z:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  z:num <- get *a, x:offset\n"
+      "]\n"
+  );
+  CHECK_TRACE_COUNT("error", 0);
+}
+
+void test_static_dispatch_works_with_compound_type_containing_container_defined_after_second_use() {
+  run(
+      "def main [\n"
+      "  x:&:foo <- new foo:type\n"
+      "  test x\n"
+      "]\n"
+      "def test a:&:foo -> z:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  z:num <- get *a, x:offset\n"
+      "]\n"
+      "container foo [\n"
+      "  x:num\n"
+      "]\n"
+  );
+  CHECK_TRACE_COUNT("error", 0);
+}
+
+void test_static_dispatch_on_non_literal_character_ignores_variant_with_numbers() {
+  Hide_errors = true;
+  run(
+      "def main [\n"
+      "  local-scope\n"
+      "  x:char <- copy 10/newline\n"
+      "  1:num/raw <- foo x\n"
+      "]\n"
+      "def foo x:num -> y:num [\n"
+      "  load-ingredients\n"
+      "  return 34\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: main: ingredient 0 has the wrong type at '1:num/raw <- foo x'\n"
+  );
+  CHECK_TRACE_DOESNT_CONTAIN("mem: storing 34 in location 1");
+}
+
+void test_static_dispatch_dispatches_literal_to_character() {
+  run(
+      "def main [\n"
+      "  1:num/raw <- foo 97\n"
+      "]\n"
+      "def foo x:char -> y:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  return 34\n"
+      "]\n"
+      "# character variant is preferred\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 34 in location 1\n"
+  );
+}
+
+void test_static_dispatch_dispatches_literal_to_number_if_at_all_possible() {
+  run(
+      "def main [\n"
+      "  1:num/raw <- foo 97\n"
+      "]\n"
+      "def foo x:char -> y:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  return 34\n"
+      "]\n"
+      "def foo x:num -> y:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  return 35\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      // number variant is preferred
+      "mem: storing 35 in location 1\n"
+  );
+}
 
 :(replace{} "string header_label(const recipe_ordinal r)")
 string header_label(const recipe_ordinal r) {
@@ -509,95 +564,120 @@ string original_header_label(const recipe& caller) {
   return out.str();
 }
 
-:(scenario reload_variant_retains_other_variants)
-def main [
-  1:num <- copy 34
-  2:num <- foo 1:num
-]
-def foo x:num -> y:num [
-  local-scope
-  load-ingredients
-  return 34
-]
-def foo x:&:num -> y:num [
-  local-scope
-  load-ingredients
-  return 35
-]
-def! foo x:&:num -> y:num [
-  local-scope
-  load-ingredients
-  return 36
-]
-+mem: storing 34 in location 2
-$error: 0
-
-:(scenario dispatch_errors_come_after_unknown_name_errors)
-% Hide_errors = true;
-def main [
-  y:num <- foo x
-]
-def foo a:num -> b:num [
-  local-scope
-  load-ingredients
-  return 34
-]
-def foo a:bool -> b:num [
-  local-scope
-  load-ingredients
-  return 35
-]
-+error: main: missing type for 'x' in 'y:num <- foo x'
-+error: main: failed to find a matching call for 'y:num <- foo x'
-
-:(scenario override_methods_with_type_abbreviations)
-def main [
-  local-scope
-  s:text <- new [abc]
-  1:num/raw <- foo s
-]
-def foo a:address:array:character -> result:number [
-  return 34
-]
-# identical to previous variant once you take type abbreviations into account
-def! foo a:text -> result:num [
-  return 35
-]
-+mem: storing 35 in location 1
-
-:(scenario ignore_static_dispatch_in_type_errors_without_overloading)
-% Hide_errors = true;
-def main [
-  local-scope
-  x:&:num <- copy 0
-  foo x
-]
-def foo x:&:char [
-  local-scope
-  load-ingredients
-]
-+error: main: types don't match in call for 'foo x'
-+error:   which tries to call 'recipe foo x:&:char'
-
-:(scenario show_available_variants_in_dispatch_errors)
-% Hide_errors = true;
-def main [
-  local-scope
-  x:&:num <- copy 0
-  foo x
-]
-def foo x:&:char [
-  local-scope
-  load-ingredients
-]
-def foo x:&:bool [
-  local-scope
-  load-ingredients
-]
-+error: main: failed to find a matching call for 'foo x'
-+error:   available variants are:
-+error:     recipe foo x:&:char
-+error:     recipe foo x:&:bool
+void test_reload_variant_retains_other_variants() {
+  run(
+      "def main [\n"
+      "  1:num <- copy 34\n"
+      "  2:num <- foo 1:num\n"
+      "]\n"
+      "def foo x:num -> y:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  return 34\n"
+      "]\n"
+      "def foo x:&:num -> y:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  return 35\n"
+      "]\n"
+      "def! foo x:&:num -> y:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  return 36\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 34 in location 2\n"
+  );
+  CHECK_TRACE_COUNT("error", 0);
+}
+
+void test_dispatch_errors_come_after_unknown_name_errors() {
+  Hide_errors = true;
+  run(
+      "def main [\n"
+      "  y:num <- foo x\n"
+      "]\n"
+      "def foo a:num -> b:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  return 34\n"
+      "]\n"
+      "def foo a:bool -> b:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  return 35\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: main: missing type for 'x' in 'y:num <- foo x'\n"
+      "error: main: failed to find a matching call for 'y:num <- foo x'\n"
+  );
+}
+
+void test_override_methods_with_type_abbreviations() {
+  run(
+      "def main [\n"
+      "  local-scope\n"
+      "  s:text <- new [abc]\n"
+      "  1:num/raw <- foo s\n"
+      "]\n"
+      "def foo a:address:array:character -> result:number [\n"
+      "  return 34\n"
+      "]\n"
+      // identical to previous variant once you take type abbreviations into account
+      "def! foo a:text -> result:num [\n"
+      "  return 35\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 35 in location 1\n"
+  );
+}
+
+void test_ignore_static_dispatch_in_type_errors_without_overloading() {
+  Hide_errors = true;
+  run(
+      "def main [\n"
+      "  local-scope\n"
+      "  x:&:num <- copy 0\n"
+      "  foo x\n"
+      "]\n"
+      "def foo x:&:char [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: main: types don't match in call for 'foo x'\n"
+      "error:   which tries to call 'recipe foo x:&:char'\n"
+  );
+}
+
+void test_show_available_variants_in_dispatch_errors() {
+  Hide_errors = true;
+  run(
+      "def main [\n"
+      "  local-scope\n"
+      "  x:&:num <- copy 0\n"
+      "  foo x\n"
+      "]\n"
+      "def foo x:&:char [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "]\n"
+      "def foo x:&:bool [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: main: failed to find a matching call for 'foo x'\n"
+      "error:   available variants are:\n"
+      "error:     recipe foo x:&:char\n"
+      "error:     recipe foo x:&:bool\n"
+  );
+}
 
 :(before "End Includes")
 using std::abs;