//: So far we've been calling a fixed recipe in each instruction, but we'd //: also like to make the recipe a variable, pass recipes to "higher-order" //: recipes, return recipes from recipes and so on. :(scenario call_literal_recipe) def main [ 1:num <- call f, 34 ] def f x:num -> y:num [ local-scope load-ingredients y <- copy x ] +mem: storing 34 in location 1 :(before "End Mu Types Initialization") put(Type_ordinal, "recipe-literal", 0); // 'recipe' variables can store recipe-literal type_ordinal recipe = put(Type_ordinal, "recipe", Next_type_ordinal++); get_or_insert(Type, recipe).name = "recipe"; :(after "Deduce Missing Type(x, caller)") if (!x.type) try_initialize_recipe_literal(x, caller); :(before "Type Check in Type-ingredient-aware check_or_set_types_by_name") if (!x.type) try_initialize_recipe_literal(x, variant); :(code) void try_initialize_recipe_literal(reagent& x, const recipe& caller) { if (x.type) return; if (!contains_key(Recipe_ordinal, x.name)) return; if (contains_reagent_with_non_recipe_literal_type(caller, x.name)) return; x.type = new type_tree("recipe-literal"); x.set_value(get(Recipe_ordinal, x.name)); } bool contains_reagent_with_non_recipe_literal_type(const recipe& caller, const string& name) { for (int i = 0; i < SIZE(caller.steps); ++i) { const instruction& inst = caller.steps.at(i); for (int i = 0; i < SIZE(inst.ingredients); ++i) if (is_matching_non_recipe_literal(inst.ingredients.at(i), name)) return true; for (int i = 0; i < SIZE(inst.products); ++i) if (is_matching_non_recipe_literal(inst.products.at(i), name)) return true; } return false; } bool is_matching_non_recipe_literal(const reagent& x, const string& name) { if (x.name != name) return false; if (!x.type) return false; return !x.type->atom || x.type->name != "recipe-literal"; } //: It's confusing to use variable names that are also recipe names. Always //: assume variable types override recipe literals. :(scenario error_on_recipe_literal_used_as_a_variable) % Hide_errors = true; def main [ local-scope a:bool <- equal break 0 break:bool <- copy 0 ] +error: main: missing type for 'break' in 'a:bool <- equal break, 0' :(before "End Primitive Recipe Declarations") CALL, :(before "End Primitive Recipe Numbers") put(Recipe_ordinal, "call", CALL); :(before "End Primitive Recipe Checks") case CALL: { if (inst.ingredients.empty()) { raise << maybe(get(Recipe, r).name) << "'call' requires at least one ingredient (the recipe to call)\n" << end(); break; } if (!is_mu_recipe(inst.ingredients.at(0))) { raise << maybe(get(Recipe, r).name) << "first ingredient of 'call' should be a recipe, but got '" << inst.ingredients.at(0).original_string << "'\n" << end(); break; } break; } :(before "End Primitive Recipe Implementations") case CALL: { // Begin Call if (Trace_stream) { ++Trace_stream->callstack_depth; trace("trace") << "indirect 'call': incrementing callstack depth to " << Trace_stream->callstack_depth << end(); assert(Trace_stream->callstack_depth < 9000); // 9998-101 plus cushion } if (!ingredients.at(0).at(0)) { raise << maybe(current_recipe_name()) << "tried to call empty recipe in '" << to_string(current_instruction()) << "'" << end(); break; } const call& caller_frame = current_call(); instruction/*copy*/ call_instruction = to_instruction(caller_frame); call_instruction.operation = ingredients.at(0).at(0); call_instruction.ingredients.erase(call_instruction.ingredients.begin()); Current_routine->calls.push_front(call(ingredients.at(0).at(0))); ingredients.erase(ingredients.begin()); // drop the callee finish_call_housekeeping(call_instruction, ingredients); // not done with caller write_products = false; fall_through_to_next_instruction = false; break; } :(scenario call_variable) def main [ {1: (recipe number -> number)} <- copy f 2:num <- call {1: (recipe number -> number)}, 34 ] def f x:num -> y:num [ local-scope load-ingredients y <- copy x ] +mem: storing 34 in location 2 :(scenario call_literal_recipe_repeatedly) def main [ 1:num <- call f, 34 1:num <- call f, 35 ] def f x:num -> y:num [ local-scope load-ingredients y <- copy x ] +mem: storing 34 in location 1 +mem: storing 35 in location 1 :(scenario call_shape_shifting_recipe) def main [ 1:num <- call f, 34 ] def f x:_elem -> y:_elem [ local-scope load-ingredients y <- copy x ] +mem: storing 34 in location 1 :(scenario call_shape_shifting_recipe_inside_shape_shifting_recipe) def main [ 1:num <- f 34 ] def f x:_elem -> y:_elem [ local-scope load-ingredients y <- call g x ] def g x:_elem -> y:_elem [ local-scope load-ingredients y <- copy x ] +mem: storing 34 in location 1 :(scenario call_shape_shifting_recipe_repeatedly_inside_shape_shifting_recipe) def main [ 1:num <- f 34 ] def f x:_elem -> y:_elem [ local-scope load-ingredients y <- call g x y <- call g x ] def g x:_elem -> y:_elem [ local-scope load-ingredients y <- copy x ] +mem: storing 34 in location 1 //:: check types for 'call' instructions :(scenario call_check_literal_recipe) % Hide_errors = true; def main [ 1:num <- call f, 34 ] def f x:point -> y:point [ local-scope load-ingredients y <- copy x ] +error: main: ingredient 0 has the wrong type at '1:num <- call f, 34' +error: main: product 0 has the wrong type at '1:num <- call f, 34' :(scenario call_check_variable_recipe) % Hide_errors = true; def main [ {1: (recipe point -> point)} <- copy f 2:num <- call {1: (recipe point -> point)}, 34 ] def f x:point -> y:point [ local-scope load-ingredients y <- copy x ] +error: main: ingredient 0 has the wrong type at '2:num <- call {1: (recipe point -> point)}, 34' +error: main: product 0 has the wrong type at '2:num <- call {1: (recipe point -> point)}, 34' :(before "End resolve_ambiguous_call(r, index, inst, caller_recipe) Special-cases") if (inst.name == "call" && !inst.ingredients.empty() && is_recipe_literal(inst.ingredients.at(0))) { resolve_indirect_ambiguous_call(r, index, inst, caller_recipe); return; } :(code) bool is_recipe_literal(const reagent& x) { return x.type && x.type->atom && x.type->name == "recipe-literal"; } void resolve_indirect_ambiguous_call(const recipe_ordinal r, int index, instruction& inst, const recipe& caller_recipe) { instruction inst2; inst2.name = inst.ingredients.at(0).name; for (int i = /*skip recipe*/1; i < SIZE(inst.ingredients); ++i) inst2.ingredients.push_back(inst.ingredients.at(i)); for (int i = 0; i < SIZE(inst.products); ++i) inst2.products.push_back(inst.products.at(i)); resolve_ambiguous_call(r, index, inst2, caller_recipe); inst.ingredients.at(0).name = inst2.name; inst.ingredients.at(0).set_value(get(Recipe_ordinal, inst2.name)); } :(after "Transform.push_back(check_instruction)") Transform.push_back(check_indirect_calls_against_header); // idempotent :(code) void check_indirect_calls_against_header(const recipe_ordinal r) { trace(9991, "transform") << "--- type-check 'call' instructions inside recipe " << get(Recipe, r).name << end(); const recipe& caller = get(Recipe, r); for (int i = 0; i < SIZE(caller.steps); ++i) { const instruction& inst = caller.steps.at(i); if (!is_indirect_call(inst.operation)) continue; if (inst.ingredients.empty()) continue; // error raised above const reagent& callee = inst.ingredients.at(0); if (!is_mu_recipe(callee)) continue; // error raised above const recipe callee_header = is_literal(callee) ? get(Recipe, callee.value) : from_reagent(inst.ingredients.at(0)); if (!callee_header.has_header) continue; if (is_indirect_call_with_ingredients(inst.operation)) { for (long int i = /*skip callee*/1; i < min(SIZE(inst.ingredients), SIZE(callee_header.ingredients)+/*skip callee*/1); ++i) { if (!types_coercible(callee_header.ingredients.at(i-/*skip callee*/1), inst.ingredients.at(i))) raise << maybe(caller.name) << "ingredient " << i-/*skip callee*/1 << " has the wrong type at '" << to_original_string(inst) << "'\n" << end(); } } if (is_indirect_call_with_products(inst.operation)) { for (long int i = 0; i < min(SIZE(inst.products), SIZE(callee_header.products)); ++i) { if (is_dummy(inst.products.at(i))) continue; if (!types_coercible(callee_header.products.at(i), inst.products.at(i))) 
//: Writing to a literal (not computed) address of 0 in a recipe chains two
//: spaces together. When a variable has a property of /space:1, it looks up
//: the variable in the chained/surrounding space. /space:2 looks up the
//: surrounding space of the surrounding space, etc.

:(scenario closure)
def main [
  default-space:space <- new location:type, 30
  1:space/names:new-counter <- new-counter
  2:num/raw <- increment-counter 1:space/names:new-counter
  3:num/raw <- increment-counter 1:space/names:new-counter
]
def new-counter [
  default-space:space <- new location:type, 30
  x:num <- copy 23
  y:num <- copy 3  # variable that will be incremented
  return default-space:space
]
def increment-counter [
  default-space:space <- new location:type, 30
  0:space/names:new-counter <- next-ingredient  # outer space must be created by 'new-counter' above
  y:num/space:1 <- add y:num/space:1