diff options
Diffstat (limited to 'archive/1.vm/055shape_shifting_container.cc')
| -rw-r--r-- | archive/1.vm/055shape_shifting_container.cc | 773 |
1 files changed, 773 insertions, 0 deletions
diff --git a/archive/1.vm/055shape_shifting_container.cc b/archive/1.vm/055shape_shifting_container.cc new file mode 100644 index 00000000..909e6fc5 --- /dev/null +++ b/archive/1.vm/055shape_shifting_container.cc @@ -0,0 +1,773 @@ +//:: Container definitions can contain 'type ingredients' + +//: pre-requisite: extend our notion of containers to not necessarily be +//: atomic types +:(after "Update GET base_type in Check") +base_type = get_base_type(base_type); +:(after "Update GET base_type in Run") +base_type = get_base_type(base_type); +:(after "Update PUT base_type in Check") +base_type = get_base_type(base_type); +:(after "Update PUT base_type in Run") +base_type = get_base_type(base_type); +:(after "Update MAYBE_CONVERT base_type in Check") +base_type = get_base_type(base_type); +:(after "Update base_type in element_type") +base_type = get_base_type(base_type); +:(after "Update base_type in skip_addresses") +base_type = get_base_type(base_type); +:(replace{} "const type_tree* get_base_type(const type_tree* t)") +const type_tree* get_base_type(const type_tree* t) { + const type_tree* result = t->atom ? t : t->left; + if (!result->atom) + raise << "invalid type " << to_string(t) << '\n' << end(); + return result; +} + +:(code) +void test_ill_formed_container() { + Hide_errors = true; + run( + "def main [\n" + " {1: ((foo) num)} <- copy 0\n" + "]\n" + ); + // no crash +} + +//: update size_of to handle non-atom container types + +void test_size_of_shape_shifting_container() { + run( + "container foo:_t [\n" + " x:_t\n" + " y:num\n" + "]\n" + "def main [\n" + " 1:foo:num <- merge 12, 13\n" + " 3:foo:point <- merge 14, 15, 16\n" + "]\n" + ); + CHECK_TRACE_CONTENTS( + "mem: storing 12 in location 1\n" + "mem: storing 13 in location 2\n" + "mem: storing 14 in location 3\n" + "mem: storing 15 in location 4\n" + "mem: storing 16 in location 5\n" + ); +} +void test_size_of_shape_shifting_container_2() { + run( + // multiple type ingredients + "container foo:_a:_b [\n" + " x:_a\n" + " y:_b\n" + "]\n" + "def main [\n" + " 1:foo:num:bool <- merge 34, true\n" + "]\n" + ); + CHECK_TRACE_COUNT("error", 0); +} +void test_size_of_shape_shifting_container_3() { + run( + "container foo:_a:_b [\n" + " x:_a\n" + " y:_b\n" + "]\n" + "def main [\n" + " 1:text <- new [abc]\n" + // compound types for type ingredients + " {3: (foo number (address array character))} <- merge 34/x, 1:text/y\n" + "]\n" + ); + CHECK_TRACE_COUNT("error", 0); +} + +void test_size_of_shape_shifting_container_4() { + run( + "container foo:_a:_b [\n" + " x:_a\n" + " y:_b\n" + "]\n" + "container bar:_a:_b [\n" + // dilated element + " {data: (foo _a (address _b))}\n" + "]\n" + "def main [\n" + " 1:text <- new [abc]\n" + " 3:bar:num:@:char <- merge 34/x, 1:text/y\n" + "]\n" + ); + CHECK_TRACE_COUNT("error", 0); +} + +void test_shape_shifting_container_extend() { + run( + "container foo:_a [\n" + " x:_a\n" + "]\n" + "container foo:_a [\n" + " y:_a\n" + "]\n" + ); + CHECK_TRACE_COUNT("error", 0); +} + +void test_shape_shifting_container_extend_error() { + Hide_errors = true; + run( + "container foo:_a [\n" + " x:_a\n" + "]\n" + "container foo:_b [\n" + " y:_b\n" + "]\n" + ); + CHECK_TRACE_CONTENTS( + "error: headers of container 'foo' must use identical type ingredients\n" + ); +} + +void test_type_ingredient_must_start_with_underscore() { + Hide_errors = true; + run( + "container foo:t [\n" + " x:num\n" + "]\n" + ); + CHECK_TRACE_CONTENTS( + "error: foo: type ingredient 't' must begin with an underscore\n" + ); +} + +:(before "End Globals") +// We'll use large type ordinals to mean "the following type of the variable". +// For example, if we have a generic type called foo:_elem, the type +// ingredient _elem in foo's type_info will have value START_TYPE_INGREDIENTS, +// and we'll handle it by looking in the current reagent for the next type +// that appears after foo. +extern const int START_TYPE_INGREDIENTS = 2000; +:(before "End Commandline Parsing") // after loading .mu files +assert(Next_type_ordinal < START_TYPE_INGREDIENTS); + +:(before "End type_info Fields") +map<string, type_ordinal> type_ingredient_names; + +//: Suppress unknown type checks in shape-shifting containers. + +:(before "Check Container Field Types(info)") +if (!info.type_ingredient_names.empty()) continue; + +:(before "End container Name Refinements") +if (name.find(':') != string::npos) { + trace(101, "parse") << "container has type ingredients; parsing" << end(); + if (!read_type_ingredients(name, command)) { + // error; skip rest of the container definition and continue + slurp_balanced_bracket(in); + return; + } +} + +:(code) +bool read_type_ingredients(string& name, const string& command) { + string save_name = name; + istringstream in(save_name); + name = slurp_until(in, ':'); + map<string, type_ordinal> type_ingredient_names; + if (!slurp_type_ingredients(in, type_ingredient_names, name)) { + return false; + } + if (contains_key(Type_ordinal, name) + && contains_key(Type, get(Type_ordinal, name))) { + const type_info& previous_info = get(Type, get(Type_ordinal, name)); + // we've already seen this container; make sure type ingredients match + if (!type_ingredients_match(type_ingredient_names, previous_info.type_ingredient_names)) { + raise << "headers of " << command << " '" << name << "' must use identical type ingredients\n" << end(); + return false; + } + return true; + } + // we haven't seen this container before + if (!contains_key(Type_ordinal, name) || get(Type_ordinal, name) == 0) + put(Type_ordinal, name, Next_type_ordinal++); + type_info& info = get_or_insert(Type, get(Type_ordinal, name)); + info.type_ingredient_names.swap(type_ingredient_names); + return true; +} + +bool slurp_type_ingredients(istream& in, map<string, type_ordinal>& out, const string& container_name) { + int next_type_ordinal = START_TYPE_INGREDIENTS; + while (has_data(in)) { + string curr = slurp_until(in, ':'); + if (curr.empty()) { + raise << container_name << ": empty type ingredients not permitted\n" << end(); + return false; + } + if (!starts_with(curr, "_")) { + raise << container_name << ": type ingredient '" << curr << "' must begin with an underscore\n" << end(); + return false; + } + if (out.find(curr) != out.end()) { + raise << container_name << ": can't repeat type ingredient name'" << curr << "' in a single container definition\n" << end(); + return false; + } + put(out, curr, next_type_ordinal++); + } + return true; +} + +bool type_ingredients_match(const map<string, type_ordinal>& a, const map<string, type_ordinal>& b) { + if (SIZE(a) != SIZE(b)) return false; + for (map<string, type_ordinal>::const_iterator p = a.begin(); p != a.end(); ++p) { + if (!contains_key(b, p->first)) return false; + if (p->second != get(b, p->first)) return false; + } + return true; +} + +:(before "End insert_container Special-cases") +// check for use of type ingredients +else if (is_type_ingredient_name(type->name)) { + type->value = get(info.type_ingredient_names, type->name); +} +:(code) +bool is_type_ingredient_name(const string& type) { + return starts_with(type, "_"); +} + +:(before "End Container Type Checks") +if (type->value >= START_TYPE_INGREDIENTS + && (type->value - START_TYPE_INGREDIENTS) < SIZE(get(Type, type->value).type_ingredient_names)) + return; + +:(code) +void test_size_of_shape_shifting_exclusive_container() { + run( + "exclusive-container foo:_t [\n" + " x:_t\n" + " y:num\n" + "]\n" + "def main [\n" + " 1:foo:num <- merge 0/x, 34\n" + " 3:foo:point <- merge 0/x, 15, 16\n" + " 6:foo:point <- merge 1/y, 23\n" + "]\n" + ); + CHECK_TRACE_CONTENTS( + "run: {1: (\"foo\" \"number\")} <- merge {0: \"literal\", \"x\": ()}, {34: \"literal\"}\n" + "mem: storing 0 in location 1\n" + "mem: storing 34 in location 2\n" + "run: {3: (\"foo\" \"point\")} <- merge {0: \"literal\", \"x\": ()}, {15: \"literal\"}, {16: \"literal\"}\n" + "mem: storing 0 in location 3\n" + "mem: storing 15 in location 4\n" + "mem: storing 16 in location 5\n" + "run: {6: (\"foo\" \"point\")} <- merge {1: \"literal\", \"y\": ()}, {23: \"literal\"}\n" + "mem: storing 1 in location 6\n" + "mem: storing 23 in location 7\n" + "run: return\n" + ); + // no other stores + CHECK_EQ(trace_count_prefix("mem", "storing"), 7); +} + +:(before "End variant_type Special-cases") +if (contains_type_ingredient(element)) + replace_type_ingredients(element.type, type->right, info, " while computing variant type of exclusive-container"); + +:(code) +void test_get_on_shape_shifting_container() { + run( + "container foo:_t [\n" + " x:_t\n" + " y:num\n" + "]\n" + "def main [\n" + " 1:foo:point <- merge 14, 15, 16\n" + " 4:num <- get 1:foo:point, y:offset\n" + "]\n" + ); + CHECK_TRACE_CONTENTS( + "mem: storing 16 in location 4\n" + ); +} + +void test_get_on_shape_shifting_container_2() { + run( + "container foo:_t [\n" + " x:_t\n" + " y:num\n" + "]\n" + "def main [\n" + " 1:foo:point <- merge 14, 15, 16\n" + " 4:point <- get 1:foo:point, x:offset\n" + "]\n" + ); + CHECK_TRACE_CONTENTS( + "mem: storing 14 in location 4\n" + "mem: storing 15 in location 5\n" + ); +} + +void test_get_on_shape_shifting_container_3() { + run( + "container foo:_t [\n" + " x:_t\n" + " y:num\n" + "]\n" + "def main [\n" + " 1:num/alloc-id, 2:num <- copy 0, 34\n" + " 3:foo:&:point <- merge 1:&:point, 48\n" + " 6:&:point <- get 1:foo:&:point, x:offset\n" + "]\n" + ); + CHECK_TRACE_CONTENTS( + "mem: storing 0 in location 6\n" + "mem: storing 34 in location 7\n" + ); +} + +void test_get_on_shape_shifting_container_inside_container() { + run( + "container foo:_t [\n" + " x:_t\n" + " y:num\n" + "]\n" + "container bar [\n" + " x:foo:point\n" + " y:num\n" + "]\n" + "def main [\n" + " 1:bar <- merge 14, 15, 16, 17\n" + " 5:num <- get 1:bar, 1:offset\n" + "]\n" + ); + CHECK_TRACE_CONTENTS( + "mem: storing 17 in location 5\n" + ); +} + +void test_get_on_complex_shape_shifting_container() { + run( + "container foo:_a:_b [\n" + " x:_a\n" + " y:_b\n" + "]\n" + "def main [\n" + " 1:text <- new [abc]\n" + " {3: (foo number (address array character))} <- merge 34/x, 1:text/y\n" + " 6:text <- get {3: (foo number (address array character))}, y:offset\n" + " 8:bool <- equal 1:text, 6:text\n" + "]\n" + ); + CHECK_TRACE_CONTENTS( + "mem: storing 1 in location 8\n" + ); +} + +:(before "End element_type Special-cases") +replace_type_ingredients(element, type, info, " while computing element type of container"); + +:(before "End size_of(type) Non-atom Special-cases") +assert(type->left->atom); +if (!contains_key(Type, type->left->value)) { + raise << "no such type " << type->left->value << '\n' << end(); + return 0; +} +type_info t = get(Type, type->left->value); +if (t.kind == CONTAINER) { + // size of a container is the sum of the sizes of its elements + int result = 0; + for (int i = 0; i < SIZE(t.elements); ++i) { + // todo: strengthen assertion to disallow mutual type recursion + if (get_base_type(t.elements.at(i).type)->value == get_base_type(type)->value) { + raise << "container " << t.name << " can't include itself as a member\n" << end(); + return 0; + } + result += size_of(element_type(type, i)); + } + return result; +} +if (t.kind == EXCLUSIVE_CONTAINER) { + // size of an exclusive container is the size of its largest variant + // (So like containers, it can't contain arrays.) + int result = 0; + for (int i = 0; i < SIZE(t.elements); ++i) { + reagent tmp; + tmp.type = new type_tree(*type); + int size = size_of(variant_type(tmp, i)); + if (size > result) result = size; + } + // ...+1 for its tag. + return result+1; +} + +:(code) +void test_complex_shape_shifting_exclusive_container() { + run( + "exclusive-container foo:_a [\n" + " x:_a\n" + " y:num\n" + "]\n" + "def main [\n" + " 1:text <- new [abc]\n" + " 3:foo:point <- merge 0/variant, 34/xx, 35/xy\n" + " 10:point, 20:bool <- maybe-convert 3:foo:point, 0/variant\n" + "]\n" + ); + CHECK_TRACE_CONTENTS( + "mem: storing 1 in location 20\n" + "mem: storing 35 in location 11\n" + ); +} + +bool contains_type_ingredient(const reagent& x) { + return contains_type_ingredient(x.type); +} + +bool contains_type_ingredient(const type_tree* type) { + if (!type) return false; + if (type->atom) return type->value >= START_TYPE_INGREDIENTS; + return contains_type_ingredient(type->left) || contains_type_ingredient(type->right); +} + +void replace_type_ingredients(reagent& element, const type_tree* caller_type, const type_info& info, const string& location_for_error_messages) { + if (contains_type_ingredient(element)) { + if (!caller_type->right) + raise << "illegal type " << names_to_string(caller_type) << " seems to be missing a type ingredient or three" << location_for_error_messages << '\n' << end(); + replace_type_ingredients(element.type, caller_type->right, info, location_for_error_messages); + } +} + +// replace all type_ingredients in element_type with corresponding elements of callsite_type +void replace_type_ingredients(type_tree* element_type, const type_tree* callsite_type, const type_info& container_info, const string& location_for_error_messages) { + if (!callsite_type) return; // error but it's already been raised above + if (!element_type) return; + if (!element_type->atom) { + if (element_type->right == NULL && is_type_ingredient(element_type->left)) { + int type_ingredient_index = to_type_ingredient_index(element_type->left); + if (corresponding(callsite_type, type_ingredient_index, is_final_type_ingredient(type_ingredient_index, container_info))->right) { + // replacing type ingredient at end of list, and replacement is a non-degenerate compound type -- (a b) but not (a) + replace_type_ingredient_at(type_ingredient_index, element_type, callsite_type, container_info, location_for_error_messages); + return; + } + } + replace_type_ingredients(element_type->left, callsite_type, container_info, location_for_error_messages); + replace_type_ingredients(element_type->right, callsite_type, container_info, location_for_error_messages); + return; + } + if (is_type_ingredient(element_type)) + replace_type_ingredient_at(to_type_ingredient_index(element_type), element_type, callsite_type, container_info, location_for_error_messages); +} + +const type_tree* corresponding(const type_tree* type, int index, bool final) { + for (const type_tree* curr = type; curr; curr = curr->right, --index) { + assert_for_now(!curr->atom); + if (index == 0) + return final ? curr : curr->left; + } + assert_for_now(false); +} + +bool is_type_ingredient(const type_tree* type) { + return type->atom && type->value >= START_TYPE_INGREDIENTS; +} + +int to_type_ingredient_index(const type_tree* type) { + assert(type->atom); + return type->value-START_TYPE_INGREDIENTS; +} + +void replace_type_ingredient_at(const int type_ingredient_index, type_tree* element_type, const type_tree* callsite_type, const type_info& container_info, const string& location_for_error_messages) { + if (!has_nth_type(callsite_type, type_ingredient_index)) { + raise << "illegal type " << names_to_string(callsite_type) << " seems to be missing a type ingredient or three" << location_for_error_messages << '\n' << end(); + return; + } + *element_type = *nth_type_ingredient(callsite_type, type_ingredient_index, container_info); +} + +const type_tree* nth_type_ingredient(const type_tree* callsite_type, int type_ingredient_index, const type_info& container_info) { + bool final = is_final_type_ingredient(type_ingredient_index, container_info); + const type_tree* curr = callsite_type; + for (int i = 0; i < type_ingredient_index; ++i) { + assert(curr); + assert(!curr->atom); +//? cerr << "type ingredient " << i << " is " << to_string(curr->left) << '\n'; + curr = curr->right; + } + assert(curr); + if (curr->atom) return curr; + if (!final) return curr->left; + if (!curr->right) return curr->left; + return curr; +} + +bool is_final_type_ingredient(int type_ingredient_index, const type_info& container_info) { + for (map<string, type_ordinal>::const_iterator p = container_info.type_ingredient_names.begin(); + p != container_info.type_ingredient_names.end(); + ++p) { + if (p->second > START_TYPE_INGREDIENTS+type_ingredient_index) return false; + } + return true; +} + +:(before "End Unit Tests") +void test_replace_type_ingredients_entire() { + run("container foo:_elem [\n" + " x:_elem\n" + " y:num\n" + "]\n"); + reagent callsite("x:foo:point"); + reagent element = element_type(callsite.type, 0); + CHECK_EQ(to_string(element), "{x: \"point\"}"); +} + +void test_replace_type_ingredients_tail() { + run("container foo:_elem [\n" + " x:_elem\n" + "]\n" + "container bar:_elem [\n" + " x:foo:_elem\n" + "]\n"); + reagent callsite("x:bar:point"); + reagent element = element_type(callsite.type, 0); + CHECK_EQ(to_string(element), "{x: (\"foo\" \"point\")}"); +} + +void test_replace_type_ingredients_head_tail_multiple() { + run("container foo:_elem [\n" + " x:_elem\n" + "]\n" + "container bar:_elem [\n" + " x:foo:_elem\n" + "]\n"); + reagent callsite("x:bar:address:array:character"); + reagent element = element_type(callsite.type, 0); + CHECK_EQ(to_string(element), "{x: (\"foo\" \"address\" \"array\" \"character\")}"); +} + +void test_replace_type_ingredients_head_middle() { + run("container foo:_elem [\n" + " x:_elem\n" + "]\n" + "container bar:_elem [\n" + " x:foo:_elem:num\n" + "]\n"); + reagent callsite("x:bar:address"); + reagent element = element_type(callsite.type, 0); + CHECK_EQ(to_string(element), "{x: (\"foo\" \"address\" \"number\")}"); +} + +void test_replace_last_type_ingredient_with_multiple() { + run("container foo:_a:_b [\n" + " x:_a\n" + " y:_b\n" + "]\n"); + reagent callsite("{f: (foo number (address array character))}"); + reagent element1 = element_type(callsite.type, 0); + CHECK_EQ(to_string(element1), "{x: \"number\"}"); + reagent element2 = element_type(callsite.type, 1); + CHECK_EQ(to_string(element2), "{y: (\"address\" \"array\" \"character\")}"); +} + +void test_replace_last_type_ingredient_inside_compound() { + run("container foo:_a:_b [\n" + " {x: (bar _a (address _b))}\n" + "]\n"); + reagent callsite("f:foo:number:array:character"); + reagent element = element_type(callsite.type, 0); + CHECK_EQ(names_to_string_without_quotes(element.type), "(bar number (address array character))"); +} + +void test_replace_middle_type_ingredient_with_multiple() { + run("container foo:_a:_b:_c [\n" + " x:_a\n" + " y:_b\n" + " z:_c\n" + "]\n"); + reagent callsite("{f: (foo number (address array character) boolean)}"); + reagent element1 = element_type(callsite.type, 0); + CHECK_EQ(to_string(element1), "{x: \"number\"}"); + reagent element2 = element_type(callsite.type, 1); + CHECK_EQ(to_string(element2), "{y: (\"address\" \"array\" \"character\")}"); + reagent element3 = element_type(callsite.type, 2); + CHECK_EQ(to_string(element3), "{z: \"boolean\"}"); +} + +void test_replace_middle_type_ingredient_with_multiple2() { + run("container foo:_key:_value [\n" + " key:_key\n" + " value:_value\n" + "]\n"); + reagent callsite("{f: (foo (address array character) number)}"); + reagent element = element_type(callsite.type, 0); + CHECK_EQ(to_string(element), "{key: (\"address\" \"array\" \"character\")}"); +} + +void test_replace_middle_type_ingredient_with_multiple3() { + run("container foo_table:_key:_value [\n" + " data:&:@:foo_table_row:_key:_value\n" + "]\n" + "\n" + "container foo_table_row:_key:_value [\n" + " key:_key\n" + " value:_value\n" + "]\n"); + reagent callsite("{f: (foo_table (address array character) number)}"); + reagent element = element_type(callsite.type, 0); + CHECK_EQ(to_string(element), "{data: (\"address\" \"array\" \"foo_table_row\" (\"address\" \"array\" \"character\") \"number\")}"); +} + +:(code) +bool has_nth_type(const type_tree* base, int n) { + assert(n >= 0); + if (!base) return false; + if (n == 0) return true; + return has_nth_type(base->right, n-1); +} + +void test_get_on_shape_shifting_container_error() { + Hide_errors = true; + run( + "container foo:_t [\n" + " x:_t\n" + " y:num\n" + "]\n" + "def main [\n" + " 1:foo:point <- merge 14, 15, 16\n" + " 10:num <- get 1:foo, 1:offset\n" + "]\n" + ); + CHECK_TRACE_CONTENTS( + "error: illegal type \"foo\" seems to be missing a type ingredient or three while computing element type of container\n" + ); + // todo: improve error message +} + +void test_typos_in_container_definitions() { + Hide_errors = true; + run( + "container foo:_t [\n" + " x:adress:_t # typo\n" + "]\n" + "def main [\n" + " local-scope\n" + " x:address:foo:num <- new {(foo num): type}\n" + "]\n" + ); + // no crash +} + +void test_typos_in_recipes() { + Hide_errors = true; + run( + "def foo [\n" + " local-scope\n" + " x:adress:array:number <- copy null # typo\n" + "]\n" + ); + // shouldn't crash +} + +//:: 'merge' on shape-shifting containers + +void test_merge_check_shape_shifting_container_containing_exclusive_container() { + run( + "container foo:_elem [\n" + " x:num\n" + " y:_elem\n" + "]\n" + "exclusive-container bar [\n" + " x:num\n" + " y:num\n" + "]\n" + "def main [\n" + " 1:foo:bar <- merge 23, 1/y, 34\n" + "]\n" + ); + CHECK_TRACE_CONTENTS( + "mem: storing 23 in location 1\n" + "mem: storing 1 in location 2\n" + "mem: storing 34 in location 3\n" + ); + CHECK_TRACE_COUNT("error", 0); +} + +void test_merge_check_shape_shifting_container_containing_exclusive_container_2() { + Hide_errors = true; + run( + "container foo:_elem [\n" + " x:num\n" + " y:_elem\n" + "]\n" + "exclusive-container bar [\n" + " x:num\n" + " y:num\n" + "]\n" + "def main [\n" + " 1:foo:bar <- merge 23, 1/y, 34, 35\n" + "]\n" + ); + CHECK_TRACE_CONTENTS( + "error: main: too many ingredients in '1:foo:bar <- merge 23, 1/y, 34, 35'\n" + ); +} + +void test_merge_check_shape_shifting_exclusive_container_containing_container() { + run( + "exclusive-container foo:_elem [\n" + " x:num\n" + " y:_elem\n" + "]\n" + "container bar [\n" + " x:num\n" + " y:num\n" + "]\n" + "def main [\n" + " 1:foo:bar <- merge 1/y, 23, 34\n" + "]\n" + ); + CHECK_TRACE_CONTENTS( + "mem: storing 1 in location 1\n" + "mem: storing 23 in location 2\n" + "mem: storing 34 in location 3\n" + ); + CHECK_TRACE_COUNT("error", 0); +} + +void test_merge_check_shape_shifting_exclusive_container_containing_container_2() { + run( + "exclusive-container foo:_elem [\n" + " x:num\n" + " y:_elem\n" + "]\n" + "container bar [\n" + " x:num\n" + " y:num\n" + "]\n" + "def main [\n" + " 1:foo:bar <- merge 0/x, 23\n" + "]\n" + ); + CHECK_TRACE_COUNT("error", 0); +} + +void test_merge_check_shape_shifting_exclusive_container_containing_container_3() { + Hide_errors = true; + run( + "exclusive-container foo:_elem [\n" + " x:num\n" + " y:_elem\n" + "]\n" + "container bar [\n" + " x:num\n" + " y:num\n" + "]\n" + "def main [\n" + " 1:foo:bar <- merge 1/y, 23\n" + "]\n" + ); + CHECK_TRACE_CONTENTS( + "error: main: too few ingredients in '1:foo:bar <- merge 1/y, 23'\n" + ); +} |