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, 441 insertions, 290 deletions

diff --git a/053recipe_header.cc b/053recipe_header.cc
index 5102f690..73fde510 100644
--- a/053recipe_header.cc
+++ b/053recipe_header.cc
@@ -1,17 +1,22 @@
 //: Advanced notation for the common/easy case where a recipe takes some fixed
 //: number of ingredients and yields some fixed number of products.
 
-:(scenario recipe_with_header)
-def main [
-  1:num/raw <- add2 3, 5
-]
-def add2 x:num, y:num -> z:num [
-  local-scope
-  load-ingredients
-  z:num <- add x, y
-  return z
-]
-+mem: storing 8 in location 1
+void test_recipe_with_header() {
+  run(
+      "def main [\n"
+      "  1:num/raw <- add2 3, 5\n"
+      "]\n"
+      "def add2 x:num, y:num -> z:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  z:num <- add x, y\n"
+      "  return z\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 8 in location 1\n"
+  );
+}
 
 //: When loading recipes save any header.
 
@@ -59,63 +64,93 @@ void load_recipe_header(istream& in, recipe& result) {
   // End Load Recipe Header(result)
 }
 
-:(scenario recipe_handles_stray_comma)
-def main [
-  1:num/raw <- add2 3, 5
-]
-def add2 x:num, y:num -> z:num, [
-  local-scope
-  load-ingredients
-  z:num <- add x, y
-  return z
-]
-+mem: storing 8 in location 1
-
-:(scenario recipe_handles_stray_comma_2)
-def main [
-  foo
-]
-def foo, [
-  1:num/raw <- add 2, 2
-]
-def bar [
-  1:num/raw <- add 2, 3
-]
-+mem: storing 4 in location 1
-
-:(scenario recipe_handles_wrong_arrow)
-% Hide_errors = true;
-def foo a:num <- b:num [
-]
-+error: recipe foo should say '->' and not '<-'
-
-:(scenario recipe_handles_missing_bracket)
-% Hide_errors = true;
-def main
-]
-+error: main: recipe body must begin with '['
-
-:(scenario recipe_handles_missing_bracket_2)
-% Hide_errors = true;
-def main
-  local-scope
-  {
-  }
-]
-# doesn't overflow line when reading header
--parse: header ingredient: local-scope
-+error: main: recipe body must begin with '['
-
-:(scenario recipe_handles_missing_bracket_3)
-% Hide_errors = true;
-def main  # comment
-  local-scope
-  {
-  }
-]
-# doesn't overflow line when reading header
--parse: header ingredient: local-scope
-+error: main: recipe body must begin with '['
+void test_recipe_handles_stray_comma() {
+  run(
+      "def main [\n"
+      "  1:num/raw <- add2 3, 5\n"
+      "]\n"
+      "def add2 x:num, y:num -> z:num, [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  z:num <- add x, y\n"
+      "  return z\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 8 in location 1\n"
+  );
+}
+
+void test_recipe_handles_stray_comma_2() {
+  run(
+      "def main [\n"
+      "  foo\n"
+      "]\n"
+      "def foo, [\n"
+      "  1:num/raw <- add 2, 2\n"
+      "]\n"
+      "def bar [\n"
+      "  1:num/raw <- add 2, 3\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 4 in location 1\n"
+  );
+}
+
+void test_recipe_handles_wrong_arrow() {
+  Hide_errors = true;
+  run(
+      "def foo a:num <- b:num [\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: recipe foo should say '->' and not '<-'\n"
+  );
+}
+
+void test_recipe_handles_missing_bracket() {
+  Hide_errors = true;
+  run(
+      "def main\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: main: recipe body must begin with '['\n"
+  );
+}
+
+void test_recipe_handles_missing_bracket_2() {
+  Hide_errors = true;
+  run(
+      "def main\n"
+      "  local-scope\n"
+      "  {\n"
+      "  }\n"
+      "]\n"
+  );
+  // doesn't overflow line when reading header
+  CHECK_TRACE_DOESNT_CONTAIN("parse: header ingredient: local-scope");
+  CHECK_TRACE_CONTENTS(
+      "error: main: recipe body must begin with '['\n"
+  );
+}
+
+void test_recipe_handles_missing_bracket_3() {
+  Hide_errors = true;
+  run(
+      "def main  # comment\n"
+      "  local-scope\n"
+      "  {\n"
+      "  }\n"
+      "]\n"
+  );
+  // doesn't overflow line when reading header
+  CHECK_TRACE_DOESNT_CONTAIN("parse: header ingredient: local-scope");
+  CHECK_TRACE_CONTENTS(
+      "error: main: recipe body must begin with '['\n"
+  );
+}
 
 :(after "Begin debug_string(recipe x)")
 out << "ingredients:\n";
@@ -127,11 +162,17 @@ for (int i = 0;  i < SIZE(x.products);  ++i)
 
 //: If a recipe never mentions any ingredients or products, assume it has a header.
 
-:(scenario recipe_without_ingredients_or_products_has_header)
-def test [
-  1:num <- copy 34
-]
-+parse: recipe test has a header
+:(code)
+void test_recipe_without_ingredients_or_products_has_header() {
+  run(
+      "def test [\n"
+      "  1:num <- copy 34\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "parse: recipe test has a header\n"
+  );
+}
 
 :(before "End Recipe Body(result)")
 if (!result.has_header) {
@@ -154,18 +195,24 @@ if (result.has_header) {
 
 //: Support type abbreviations in headers.
 
-:(scenario type_abbreviations_in_recipe_headers)
-def main [
-  local-scope
-  a:text <- foo
-  1:char/raw <- index *a, 0
-]
-def foo -> a:text [  # 'text' is an abbreviation
-  local-scope
-  load-ingredients
-  a <- new [abc]
-]
-+mem: storing 97 in location 1
+:(code)
+void test_type_abbreviations_in_recipe_headers() {
+  run(
+      "def main [\n"
+      "  local-scope\n"
+      "  a:text <- foo\n"
+      "  1:char/raw <- index *a, 0\n"
+      "]\n"
+      "def foo -> a:text [  # 'text' is an abbreviation\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  a <- new [abc]\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 97 in location 1\n"
+  );
+}
 
 :(before "End Expand Type Abbreviations(caller)")
 for (long int i = 0;  i < SIZE(caller.ingredients);  ++i)
@@ -221,28 +268,39 @@ case NEXT_INGREDIENT_WITHOUT_TYPECHECKING: {
 }
 
 //: more useful error messages if someone forgets 'load-ingredients'
-
-:(scenario load_ingredients_missing_error)
-% Hide_errors = true;
-def foo a:num [
-  local-scope
-  b:num <- add a:num, 1
-]
-+error: foo: tried to read ingredient 'a' in 'b:num <- add a:num, 1' but it hasn't been written to yet
-+error:   did you forget 'load-ingredients'?
+:(code)
+void test_load_ingredients_missing_error() {
+  Hide_errors = true;
+  run(
+      "def foo a:num [\n"
+      "  local-scope\n"
+      "  b:num <- add a:num, 1\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: foo: tried to read ingredient 'a' in 'b:num <- add a:num, 1' but it hasn't been written to yet\n"
+      "error:   did you forget 'load-ingredients'?\n"
+  );
+}
 
 :(after "use-before-set Error")
 if (is_present_in_ingredients(caller, ingredient.name))
   raise << "  did you forget 'load-ingredients'?\n" << end();
 
-:(scenario load_ingredients_missing_error_2)
-% Hide_errors = true;
-def foo a:num [
-  local-scope
-  b:num <- add a, 1
-]
-+error: foo: missing type for 'a' in 'b:num <- add a, 1'
-+error:   did you forget 'load-ingredients'?
+:(code)
+void test_load_ingredients_missing_error_2() {
+  Hide_errors = true;
+  run(
+      "def foo a:num [\n"
+      "  local-scope\n"
+      "  b:num <- add a, 1\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: foo: missing type for 'a' in 'b:num <- add a, 1'\n"
+      "error:   did you forget 'load-ingredients'?\n"
+  );
+}
 
 :(after "missing-type Error 1")
 if (is_present_in_ingredients(get(Recipe, get(Recipe_ordinal, recipe_name)), x.name))
@@ -259,29 +317,39 @@ bool is_present_in_ingredients(const recipe& callee, const string& ingredient_na
 
 //:: Check all calls against headers.
 
-:(scenario show_clear_error_on_bad_call)
-% Hide_errors = true;
-def main [
-  1:num <- foo 34
-]
-def foo x:point -> y:num [
-  local-scope
-  load-ingredients
-  return 35
-]
-+error: main: ingredient 0 has the wrong type at '1:num <- foo 34'
-
-:(scenario show_clear_error_on_bad_call_2)
-% Hide_errors = true;
-def main [
-  1:point <- foo 34
-]
-def foo x:num -> y:num [
-  local-scope
-  load-ingredients
-  return x
-]
-+error: main: product 0 has the wrong type at '1:point <- foo 34'
+void test_show_clear_error_on_bad_call() {
+  Hide_errors = true;
+  run(
+      "def main [\n"
+      "  1:num <- foo 34\n"
+      "]\n"
+      "def foo x:point -> y:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  return 35\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: main: ingredient 0 has the wrong type at '1:num <- foo 34'\n"
+  );
+}
+
+void test_show_clear_error_on_bad_call_2() {
+  Hide_errors = true;
+  run(
+      "def main [\n"
+      "  1:point <- foo 34\n"
+      "]\n"
+      "def foo x:num -> y:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  return x\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: main: product 0 has the wrong type at '1:point <- foo 34'\n"
+  );
+}
 
 :(after "Transform.push_back(check_instruction)")
 Transform.push_back(check_calls_against_header);  // idempotent
@@ -314,16 +382,20 @@ void check_calls_against_header(const recipe_ordinal r) {
 
 //:: Check types going in and out of all recipes with headers.
 
-:(scenarios transform)
-:(scenario recipe_headers_are_checked)
-% Hide_errors = true;
-def add2 x:num, y:num -> z:num [
-  local-scope
-  load-ingredients
-  z:&:num <- copy 0/unsafe
-  return z
-]
-+error: add2: replied with the wrong type at 'return z'
+void test_recipe_headers_are_checked() {
+  Hide_errors = true;
+  transform(
+      "def add2 x:num, y:num -> z:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  z:&:num <- copy 0/unsafe\n"
+      "  return z\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: add2: replied with the wrong type at 'return z'\n"
+  );
+}
 
 :(before "End Checks")
 Transform.push_back(check_return_instructions_against_header);  // idempotent
@@ -347,51 +419,76 @@ void check_return_instructions_against_header(const recipe_ordinal r) {
   }
 }
 
-:(scenario recipe_headers_are_checked_2)
-% Hide_errors = true;
-def add2 x:num, y:num [
-  local-scope
-  load-ingredients
-  z:&:num <- copy 0/unsafe
-  return z
-]
-+error: add2: replied with the wrong number of products at 'return z'
-
-:(scenario recipe_headers_are_checked_against_pre_transformed_instructions)
-% Hide_errors = true;
-def foo -> x:num [
-  local-scope
-  x:num <- copy 0
-  z:bool <- copy false
-  return-if z, z
-]
-+error: foo: replied with the wrong type at 'return-if z, z'
-
-:(scenario recipe_headers_check_for_duplicate_names)
-% Hide_errors = true;
-def foo x:num, x:num -> z:num [
-  local-scope
-  load-ingredients
-  return z
-]
-+error: foo: 'x' can't repeat in the ingredients
-
-:(scenario recipe_headers_check_for_duplicate_names_2)
-% Hide_errors = true;
-def foo x:num, x:num [  # no result
-  local-scope
-  load-ingredients
-]
-+error: foo: 'x' can't repeat in the ingredients
-
-:(scenario recipe_headers_check_for_missing_types)
-% Hide_errors = true;
-def main [
-  foo 0
-]
-def foo a [  # no type for 'a'
-]
-+error: foo: ingredient 'a' has no type
+void test_recipe_headers_are_checked_2() {
+  Hide_errors = true;
+  transform(
+      "def add2 x:num, y:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  z:&:num <- copy 0/unsafe\n"
+      "  return z\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: add2: replied with the wrong number of products at 'return z'\n"
+  );
+}
+
+void test_recipe_headers_are_checked_against_pre_transformed_instructions() {
+  Hide_errors = true;
+  transform(
+      "def foo -> x:num [\n"
+      "  local-scope\n"
+      "  x:num <- copy 0\n"
+      "  z:bool <- copy false\n"
+      "  return-if z, z\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: foo: replied with the wrong type at 'return-if z, z'\n"
+  );
+}
+
+void test_recipe_headers_check_for_duplicate_names() {
+  Hide_errors = true;
+  transform(
+      "def foo x:num, x:num -> z:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  return z\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: foo: 'x' can't repeat in the ingredients\n"
+  );
+}
+
+void test_recipe_headers_check_for_duplicate_names_2() {
+  Hide_errors = true;
+  transform(
+      "def foo x:num, x:num [  # no result\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: foo: 'x' can't repeat in the ingredients\n"
+  );
+}
+
+void test_recipe_headers_check_for_missing_types() {
+  Hide_errors = true;
+  transform(
+      "def main [\n"
+      "  foo 0\n"
+      "]\n"
+      "def foo a [\n"  // no type for 'a'
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: foo: ingredient 'a' has no type\n"
+  );
+}
 
 :(before "End recipe Fields")
 map<string, int> ingredient_index;
@@ -415,18 +512,22 @@ void check_header_ingredients(const recipe_ordinal r) {
 
 //: Deduce types from the header if possible.
 
-:(scenarios run)
-:(scenario deduce_instruction_types_from_recipe_header)
-def main [
-  1:num/raw <- add2 3, 5
-]
-def add2 x:num, y:num -> z:num [
-  local-scope
-  load-ingredients
-  z <- add x, y  # no type for z
-  return z
-]
-+mem: storing 8 in location 1
+void test_deduce_instruction_types_from_recipe_header() {
+  run(
+      "def main [\n"
+      "  1:num/raw <- add2 3, 5\n"
+      "]\n"
+      "def add2 x:num, y:num -> z:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  z <- add x, y  # no type for z\n"
+      "  return z\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 8 in location 1\n"
+  );
+}
 
 :(after "Begin Type Modifying Transforms")
 Transform.push_back(deduce_types_from_header);  // idempotent
@@ -473,17 +574,22 @@ void deduce_types_from_header(const recipe_ordinal r) {
 //: One final convenience: no need to say what to return if the information is
 //: in the header.
 
-:(scenario return_based_on_header)
-def main [
-  1:num/raw <- add2 3, 5
-]
-def add2 x:num, y:num -> z:num [
-  local-scope
-  load-ingredients
-  z <- add x, y
-  return
-]
-+mem: storing 8 in location 1
+void test_return_based_on_header() {
+  run(
+      "def main [\n"
+      "  1:num/raw <- add2 3, 5\n"
+      "]\n"
+      "def add2 x:num, y:num -> z:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  z <- add x, y\n"
+      "  return\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 8 in location 1\n"
+  );
+}
 
 :(after "Transform.push_back(check_header_ingredients)")
 Transform.push_back(fill_in_return_ingredients);  // idempotent
@@ -526,97 +632,142 @@ void add_header_products(instruction& inst, const recipe& caller_recipe) {
   }
 }
 
-:(scenario explicit_return_ignores_header)
-def main [
-  1:num/raw, 2:num/raw <- add2 3, 5
-]
-def add2 a:num, b:num -> y:num, z:num [
-  local-scope
-  load-ingredients
-  y <- add a, b
-  z <- subtract a, b
-  return a, z
-]
-+mem: storing 3 in location 1
-+mem: storing -2 in location 2
-
-:(scenario return_on_fallthrough_based_on_header)
-def main [
-  1:num/raw <- add2 3, 5
-]
-def add2 x:num, y:num -> z:num [
-  local-scope
-  load-ingredients
-  z <- add x, y
-]
-+transform: instruction: return {z: "number"}
-+mem: storing 8 in location 1
-
-:(scenario return_on_fallthrough_already_exists)
-def main [
-  1:num/raw <- add2 3, 5
-]
-def add2 x:num, y:num -> z:num [
-  local-scope
-  load-ingredients
-  z <- add x, y  # no type for z
-  return z
-]
-+transform: instruction: return {z: ()}
--transform: instruction: return z:num
-+mem: storing 8 in location 1
-
-:(scenario return_causes_error_in_empty_recipe)
-% Hide_errors = true;
-def foo -> x:num [
-]
-+error: foo: tried to read ingredient 'x' in 'return x:num' but it hasn't been written to yet
-
-:(scenario return_after_conditional_return_based_on_header)
-def main [
-  1:num/raw <- add2 3, 5
-]
-def add2 x:num, y:num -> z:num [
-  local-scope
-  load-ingredients
-  z <- add x, y  # no type for z
-  return-if false, 34
-]
-+mem: storing 8 in location 1
-
-:(scenario recipe_headers_perform_same_ingredient_check)
-% Hide_errors = true;
-def main [
-  1:num <- copy 34
-  2:num <- copy 34
-  3:num <- add2 1:num, 2:num
-]
-def add2 x:num, y:num -> x:num [
-  local-scope
-  load-ingredients
-]
-+error: main: '3:num <- add2 1:num, 2:num' should write to '1:num' rather than '3:num'
+void test_explicit_return_ignores_header() {
+  run(
+      "def main [\n"
+      "  1:num/raw, 2:num/raw <- add2 3, 5\n"
+      "]\n"
+      "def add2 a:num, b:num -> y:num, z:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  y <- add a, b\n"
+      "  z <- subtract a, b\n"
+      "  return a, z\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 3 in location 1\n"
+      "mem: storing -2 in location 2\n"
+  );
+}
+
+void test_return_on_fallthrough_based_on_header() {
+  run(
+      "def main [\n"
+      "  1:num/raw <- add2 3, 5\n"
+      "]\n"
+      "def add2 x:num, y:num -> z:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  z <- add x, y\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "transform: instruction: return {z: \"number\"}\n"
+      "mem: storing 8 in location 1\n"
+  );
+}
+
+void test_return_on_fallthrough_already_exists() {
+  run(
+      "def main [\n"
+      "  1:num/raw <- add2 3, 5\n"
+      "]\n"
+      "def add2 x:num, y:num -> z:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  z <- add x, y  # no type for z\n"
+      "  return z\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "transform: instruction: return {z: ()}\n"
+  );
+  CHECK_TRACE_DOESNT_CONTAIN("transform: instruction: return z:num");
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 8 in location 1\n"
+  );
+}
+
+void test_return_causes_error_in_empty_recipe() {
+  Hide_errors = true;
+  run(
+      "def foo -> x:num [\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: foo: tried to read ingredient 'x' in 'return x:num' but it hasn't been written to yet\n"
+  );
+}
+
+void test_return_after_conditional_return_based_on_header() {
+  run(
+      "def main [\n"
+      "  1:num/raw <- add2 3, 5\n"
+      "]\n"
+      "def add2 x:num, y:num -> z:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "  z <- add x, y\n"  // no type for z
+      "  return-if false, 34\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "mem: storing 8 in location 1\n"
+  );
+}
+
+void test_recipe_headers_perform_same_ingredient_check() {
+  Hide_errors = true;
+  run(
+      "def main [\n"
+      "  1:num <- copy 34\n"
+      "  2:num <- copy 34\n"
+      "  3:num <- add2 1:num, 2:num\n"
+      "]\n"
+      "def add2 x:num, y:num -> x:num [\n"
+      "  local-scope\n"
+      "  load-ingredients\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: main: '3:num <- add2 1:num, 2:num' should write to '1:num' rather than '3:num'\n"
+  );
+}
 
 //: One special-case is recipe 'main'. Make sure it's only ever taking in text
 //: ingredients, and returning a single number.
 
-:(scenario recipe_header_ingredients_constrained_for_main)
-% Hide_errors = true;
-def main x:num [
-]
-+error: ingredients of recipe 'main' must all be text (address:array:character)
-
-:(scenario recipe_header_products_constrained_for_main)
-% Hide_errors = true;
-def main -> x:text [
-]
-+error: recipe 'main' must return at most a single product, a number
-
-:(scenario recipe_header_products_constrained_for_main_2)
-% Hide_errors = true;
-def main -> x:num, y:num [
-]
-+error: recipe 'main' must return at most a single product, a number
+void test_recipe_header_ingredients_constrained_for_main() {
+  Hide_errors = true;
+  run(
+      "def main x:num [\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: ingredients of recipe 'main' must all be text (address:array:character)\n"
+  );
+}
+void test_recipe_header_products_constrained_for_main() {
+  Hide_errors = true;
+  run(
+      "def main -> x:text [\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: recipe 'main' must return at most a single product, a number\n"
+  );
+}
+void test_recipe_header_products_constrained_for_main_2() {
+  Hide_errors = true;
+  run(
+      "def main -> x:num, y:num [\n"
+      "]\n"
+  );
+  CHECK_TRACE_CONTENTS(
+      "error: recipe 'main' must return at most a single product, a number\n"
+  );
+}
 
 :(after "Transform.push_back(expand_type_abbreviations)")
 Transform.push_back(check_recipe_header_constraints);