1 //: So far we've been calling a fixed recipe in each instruction, but we'd
  2 //: also like to make the recipe a variable, pass recipes to "higher-order"
  3 //: recipes, return recipes from recipes and so on.
  4 
  5 :(scenario call_literal_recipe)
  6 def main [
  7   1:num <- call f, 34
  8 ]
  9 def f x:num -> y:num [
 10   local-scope
 11   load-ingredients
 12   y <- copy x
 13 ]
 14 +mem: storing 34 in location 1
 15 
 16 :(before "End Mu Types Initialization")
 17 put(Type_ordinal, "recipe-literal", 0);
 18 // 'recipe' variables can store recipe-literal
 19 type_ordinal recipe = put(Type_ordinal, "recipe", Next_type_ordinal++);
 20 get_or_insert(Type, recipe).name = "recipe";
 21 
 22 :(after "Deduce Missing Type(x, caller)")
 23 if (!x.type)
 24   try_initialize_recipe_literal(x, caller);
 25 :(before "Type Check in Type-ingredient-aware check_or_set_types_by_name")
 26 if (!x.type)
 27   try_initialize_recipe_literal(x, variant);
 28 :(code)
 29 void try_initialize_recipe_literal(reagent& x, const recipe& caller) {
 30   if (x.type) return;
 31   if (!contains_key(Recipe_ordinal, x.name)) return;
 32   if (contains_reagent_with_non_recipe_literal_type(caller, x.name)) return;
 33   x.type = new type_tree("recipe-literal");
 34   x.set_value(get(Recipe_ordinal, x.name));
 35 }
 36 bool contains_reagent_with_non_recipe_literal_type(const recipe& caller, const string& name) {
 37   for (int i = 0;  i < SIZE(caller.steps);  ++i) {
 38     const instruction& inst = caller.steps.at(i);
 39     for (int i = 0;  i < SIZE(inst.ingredients);  ++i)
 40       if (is_matching_non_recipe_literal(inst.ingredients.at(i), name)) return true;
 41     for (int i = 0;  i < SIZE(inst.products);  ++i)
 42       if (is_matching_non_recipe_literal(inst.products.at(i), name)) return true;
 43   }
 44   return false;
 45 }
 46 bool is_matching_non_recipe_literal(const reagent& x, const string& name) {
 47   if (x.name != name) return false;
 48   if (!x.type) return false;
 49   return !x.type->atom || x.type->name != "recipe-literal";
 50 }
 51 
 52 //: It's confusing to use variable names that are also recipe names. Always
 53 //: assume variable types override recipe literals.
 54 :(scenario error_on_recipe_literal_used_as_a_variable)
 55 % Hide_errors = true;
 56 def main [
 57   local-scope
 58   a:bool <- equal break 0
 59   break:bool <- copy 0
 60 ]
 61 +error: main: missing type for 'break' in 'a:bool <- equal break, 0'
 62 
 63 :(before "End Primitive Recipe Declarations")
 64 CALL,
 65 :(before "End Primitive Recipe Numbers")
 66 put(Recipe_ordinal, "call", CALL);
 67 :(before "End Primitive Recipe Checks")
 68 case CALL: {
 69   if (inst.ingredients.empty()) {
 70     raise << maybe(get(Recipe, r).name) << "'call' requires at least one ingredient (the recipe to call)\n" << end();
 71     break;
 72   }
 73   if (!is_mu_recipe(inst.ingredients.at(0))) {
 74     raise << maybe(get(Recipe, r).name) << "first ingredient of 'call' should be a recipe, but got '" << inst.ingredients.at(0).original_string << "'\n" << end();
 75     break;
 76   }
 77   break;
 78 }
 79 :(before "End Primitive Recipe Implementations")
 80 case CALL: {
 81   // Begin Call
 82   if (Trace_stream) {
 83     ++Trace_stream->callstack_depth;
 84     trace("trace") << "indirect 'call': incrementing callstack depth to " << Trace_stream->callstack_depth << end();
 85     assert(Trace_stream->callstack_depth < 9000);  // 9998-101 plus cushion
 86   }
 87   if (!ingredients.at(0).at(0)) {
 88     raise << maybe(current_recipe_name()) << "tried to call empty recipe in '" << to_string(current_instruction()) << "'" << end();
 89     break;
 90   }
 91   const call& caller_frame = current_call();
 92   instruction/*copy*/ call_instruction = to_instruction(caller_frame);
 93   call_instruction.operation = ingredients.at(0).at(0);
 94   call_instruction.ingredients.erase(call_instruction.ingredients.begin());
 95   Current_routine->calls.push_front(call(ingredients.at(0).at(0)));
 96   ingredients.erase(ingredients.begin());  // drop the callee
 97   finish_call_housekeeping(call_instruction, ingredients);
 98   // not done with caller
 99   write_products = false;
100   fall_through_to_next_instruction = false;
101   break;
102 }
103 
104 :(scenario call_variable)
105 def main [
106   {1: (recipe number -> number)} <- copy f
107   2:num <- call {1: (recipe number -> number)}, 34
108 ]
109 def f x:num -> y:num [
110   local-scope
111   load-ingredients
112   y <- copy x
113 ]
114 +mem: storing 34 in location 2
115 
116 :(scenario call_literal_recipe_repeatedly)
117 def main [
118   1:num <- call f, 34
119   1:num <- call f, 35
120 ]
121 def f x:num -> y:num [
122   local-scope
123   load-ingredients
124   y <- copy x
125 ]
126 +mem: storing 34 in location 1
127 +mem: storing 35 in location 1
128 
129 :(scenario call_shape_shifting_recipe)
130 def main [
131   1:num <- call f, 34
132 ]
133 def f x:_elem -> y:_elem [
134   local-scope
135   load-ingredients
136   y <- copy x
137 ]
138 +mem: storing 34 in location 1
139 
140 :(scenario call_shape_shifting_recipe_inside_shape_shifting_recipe)
141 def main [
142   1:num <- f 34
143 ]
144 def f x:_elem -> y:_elem [
145   local-scope
146   load-ingredients
147   y <- call g x
148 ]
149 def g x:_elem -> y:_elem [
150   local-scope
151   load-ingredients
152   y <- copy x
153 ]
154 +mem: storing 34 in location 1
155 
156 :(scenario call_shape_shifting_recipe_repeatedly_inside_shape_shifting_recipe)
157 def main [
158   1:num <- f 34
159 ]
160 def f x:_elem -> y:_elem [
161   local-scope
162   load-ingredients
163   y <- call g x
164   y <- call g x
165 ]
166 def g x:_elem -> y:_elem [
167   local-scope
168   load-ingredients
169   y <- copy x
170 ]
171 +mem: storing 34 in location 1
172 
173 //:: check types for 'call' instructions
174 
175 :(scenario call_check_literal_recipe)
176 % Hide_errors = true;
177 def main [
178   1:num <- call f, 34
179 ]
180 def f x:point -> y:point [
181   local-scope
182   load-ingredients
183   y <- copy x
184 ]
185 +error: main: ingredient 0 has the wrong type at '1:num <- call f, 34'
186 +error: main: product 0 has the wrong type at '1:num <- call f, 34'
187 
188 :(scenario call_check_variable_recipe)
189 % Hide_errors = true;
190 def main [
191   {1: (recipe point -> point)} <- copy f
192   2:num <- call {1: (recipe point -> point)}, 34
193 ]
194 def f x:point -> y:point [
195   local-scope
196   load-ingredients
197   y <- copy x
198 ]
199 +error: main: ingredient 0 has the wrong type at '2:num <- call {1: (recipe point -> point)}, 34'
200 +error: main: product 0 has the wrong type at '2:num <- call {1: (recipe point -> point)}, 34'
201 
202 :(before "End resolve_ambiguous_call(r, index, inst, caller_recipe) Special-cases")
203 if (inst.name == "call" && !inst.ingredients.empty() && is_recipe_literal(inst.ingredients.at(0))) {
204   resolve_indirect_ambiguous_call(r, index, inst, caller_recipe);
205   return;
206 }
207 :(code)
208 bool is_recipe_literal(const reagent& x) {
209   return x.type && x.type->atom && x.type->name == "recipe-literal";
210 }
211 void resolve_indirect_ambiguous_call(const recipe_ordinal r, int index, instruction& inst, const recipe& caller_recipe) {
212   instruction inst2;
213   inst2.name = inst.ingredients.at(0).name;
214   for (int i = /*skip recipe*/1;  i < SIZE(inst.ingredients);  ++i)
215     inst2.ingredients.push_back(inst.ingredients.at(i));
216   for (int i = 0;  i < SIZE(inst.products);  ++i)
217     inst2.products.push_back(inst.products.at(i));
218   resolve_ambiguous_call(r, index, inst2, caller_recipe);
219   inst.ingredients.at(0).name = inst2.name;
220   inst.ingredients.at(0).set_value(get(Recipe_ordinal, inst2.name));
221 }
222 
223 :(after "Transform.push_back(check_instruction)")
224 Transform.push_back(check_indirect_calls_against_header);  // idempotent
225 :(code)
226 void check_indirect_calls_against_header(const recipe_ordinal r) {
227   trace(9991, "transform") << "--- type-check 'call' instructions inside recipe " << get(Recipe, r).name << end();
228   const recipe& caller = get(Recipe, r);
229   for (int i = 0;  i < SIZE(caller.steps);  ++i) {
230     const instruction& inst = caller.steps.at(i);
231     if (!is_indirect_call(inst.operation)) continue;
232     if (inst.ingredients.empty()) continue;  // error raised above
233     const reagent& callee = inst.ingredients.at(0);
234     if (!is_mu_recipe(callee)) continue;  // error raised above
235     const recipe callee_header = is_literal(callee) ? get(Recipe, callee.value) : from_reagent(inst.ingredients.at(0));
236     if (!callee_header.has_header) continue;
237     if (is_indirect_call_with_ingredients(inst.operation)) {
238       for (long int i = /*skip callee*/1;  i < min(SIZE(inst.ingredients), SIZE(callee_header.ingredients)+/*skip callee*/1);  ++i) {
239         if (!types_coercible(callee_header.ingredients.at(i-/*skip callee*/1), inst.ingredients.at(i)))
240           raise << maybe(caller.name) << "ingredient " << i-/*skip callee*/1 << " has the wrong type at '" << to_original_string(inst) << "'\n" << end();
241       }
242     }
243     if (is_indirect_call_with_products(inst.operation)) {
244       for (long int i = 0;  i < min(SIZE(inst.products), SIZE(callee_header.products));  ++i) {
245         if (is_dummy(inst.products.at(i))) continue;
246         if (!types_coercible(callee_header.products.at(i), inst.products.at(i)))
247           raise << maybe(caller.name) << "product " << i << " has the wrong type at '" << to_original_string(inst) << "'\n" << end();
248       }
249     }
250   }
251 }
252 
253 bool is_indirect_call(const recipe_ordinal r) {
254   return is_indirect_call_with_ingredients(r) || is_indirect_call_with_products(r);
255 }
256 
257 bool is_indirect_call_with_ingredients(const recipe_ordinal r) {
258   if (r == CALL) return true;
259   // End is_indirect_call_with_ingredients Special-cases
260   return false;
261 }
262 bool is_indirect_call_with_products(const recipe_ordinal r) {
263   if (r == CALL) return true;
264   // End is_indirect_call_with_products Special-cases
265   return false;
266 }
267 
268 recipe from_reagent(const reagent& r) {
269   assert(r.type);
270   recipe result_header;  // will contain only ingredients and products, nothing else
271   result_header.has_header = true;
272   // Begin Reagent->Recipe(r, recipe_header)
273   if (r.type->atom) {
274     assert(r.type->name == "recipe");
275     return result_header;
276   }
277   const type_tree* root_type = r.type->atom ? r.type : r.type->left;
278   assert(root_type->atom);
279   assert(root_type->name == "recipe");
280   const type_tree* curr = r.type->right;
281   for (/*nada*/;  curr && !curr->atom;  curr = curr->right) {
282     if (curr->left->atom && curr->left->name == "->") {
283       curr = curr->right;  // skip delimiter
284       goto read_products;
285     }
286     result_header.ingredients.push_back(next_recipe_reagent(curr->left));
287   }
288   if (curr) {
289     assert(curr->atom);
290     result_header.ingredients.push_back(next_recipe_reagent(curr));
291     return result_header;  // no products
292   }
293   read_products:
294   for (/*nada*/;  curr && !curr->atom;  curr = curr->right)
295     result_header.products.push_back(next_recipe_reagent(curr->left));
296   if (curr) {
297     assert(curr->atom);
298     result_header.products.push_back(next_recipe_reagent(curr));
299   }
300   return result_header;
301 }
302 
303 :(before "End Unit Tests")
304 void test_from_reagent_atomic() {
305   reagent a("{f: recipe}");
306   recipe r_header = from_reagent(a);
307   CHECK(r_header.ingredients.empty());
308   CHECK(r_header.products.empty());
309 }
310 void test_from_reagent_non_atomic() {
311   reagent a("{f: (recipe number -> number)}");
312   recipe r_header = from_reagent(a);
313   CHECK_EQ(SIZE(r_header.ingredients), 1);
314   CHECK_EQ(SIZE(r_header.products), 1);
315 }
316 void test_from_reagent_reads_ingredient_at_end() {
317   reagent a("{f: (recipe number number)}");
318   recipe r_header = from_reagent(a);
319   CHECK_EQ(SIZE(r_header.ingredients), 2);
320   CHECK(r_header.products.empty());
321 }
322 void test_from_reagent_reads_sole_ingredient_at_end() {
323   reagent a("{f: (recipe number)}");
324   recipe r_header = from_reagent(a);
325   CHECK_EQ(SIZE(r_header.ingredients), 1);
326   CHECK(r_header.products.empty());
327 }
328 
329 :(code)
330 reagent next_recipe_reagent(const type_tree* curr) {
331   if (!curr->left) return reagent("recipe:"+curr->name);
332   return reagent(new type_tree(*curr));
333 }
334 
335 bool is_mu_recipe(const reagent& r) {
336   if (!r.type) return false;
337   if (r.type->atom) {
338     // End is_mu_recipe Atom Cases(r)
339     return r.type->name == "recipe-literal";
340   }
341   return r.type->left->atom && r.type->left->name == "recipe";
342 }
343 
344 :(scenario copy_typecheck_recipe_variable)
345 % Hide_errors = true;
346 def main [
347   3:num <- copy 34  # abc def
348   {1: (recipe number -> number)} <- copy f  # store literal in a matching variable
349   {2: (recipe boolean -> boolean)} <- copy {1: (recipe number -> number)}  # mismatch between recipe variables
350 ]
351 def f x:num -> y:num [
352   local-scope
353   load-ingredients
354   y <- copy x
355 ]
356 +error: main: can't copy '{1: (recipe number -> number)}' to '{2: (recipe boolean -> boolean)}'; types don't match
357 
358 :(scenario copy_typecheck_recipe_variable_2)
359 % Hide_errors = true;
360 def main [
361   {1: (recipe number -> number)} <- copy f  # mismatch with a recipe literal
362 ]
363 def f x:bool -> y:bool [
364   local-scope
365   load-ingredients
366   y <- copy x
367 ]
368 +error: main: can't copy 'f' to '{1: (recipe number -> number)}'; types don't match
369 
370 :(before "End Matching Types For Literal(to)")
371 if (is_mu_recipe(to)) {
372   if (!contains_key(Recipe, from.value)) {
373     raise << "trying to store recipe " << from.name << " into " << to_string(to) << " but there's no such recipe\n" << end();
374     return false;
375   }
376   const recipe& rrhs = get(Recipe, from.value);
377   const recipe& rlhs = from_reagent(to);
378   for (long int i = 0;  i < min(SIZE(rlhs.ingredients), SIZE(rrhs.ingredients));  ++i) {
379     if (!types_match(rlhs.ingredients.at(i), rrhs.ingredients.at(i)))
380       return false;
381   }
382   for (long int i = 0;  i < min(SIZE(rlhs.products), SIZE(rrhs.products));  ++i) {
383     if (!types_match(rlhs.products.at(i), rrhs.products.at(i)))
384       return false;
385   }
386   return true;
387 }
388 
389 :(scenario call_variable_compound_ingredient)
390 def main [
391   {1: (recipe (address number) -> number)} <- copy f
392   2:&:num <- copy null
393   3:num <- call {1: (recipe (address number) -> number)}, 2:&:num
394 ]
395 def f x:&:num -> y:num [
396   local-scope
397   load-ingredients
398   y <- deaddress x
399 ]
400 $error: 0
401 
402 //: make sure we don't accidentally break on a recipe literal
403 :(scenario jump_forbidden_on_recipe_literals)
404 % Hide_errors = true;
405 def foo [
406   local-scope
407 ]
408 def main [
409   local-scope
410   {
411     break-if foo
412   }
413 ]
414 # error should be as if foo is not a recipe
415 +error: main: missing type for 'foo' in 'break-if foo'
416 
417 :(before "End JUMP_IF Checks")
418 check_for_recipe_literals(inst, get(Recipe, r));
419 :(before "End JUMP_UNLESS Checks")
420 check_for_recipe_literals(inst, get(Recipe, r));
421 :(code)
422 void check_for_recipe_literals(const instruction& inst, const recipe& caller) {
423   for (int i = 0;  i < SIZE(inst.ingredients);  ++i) {
424     if (is_mu_recipe(inst.ingredients.at(i))) {
425       raise << maybe(caller.name) << "missing type for '" << inst.ingredients.at(i).original_string << "' in '" << to_original_string(inst) << "'\n" << end();
426       if (is_present_in_ingredients(caller, inst.ingredients.at(i).name))
427         raise << "  did you forget 'load-ingredients'?\n" << end();
428     }
429   }
430 }
431 
432 :(scenario load_ingredients_missing_error_3)
433 % Hide_errors = true;
434 def foo {f: (recipe num -> num)} [
435   local-scope
436   b:num <- call f, 1
437 ]
438 +error: foo: missing type for 'f' in 'b:num <- call f, 1'
439 +error:   did you forget 'load-ingredients'?
440 
441 :(before "End Mu Types Initialization")
442 put(Type_abbreviations, "function", new_type_tree("recipe"));
443 put(Type_abbreviations, "fn", new_type_tree("recipe"));
444 
445 //: copying functions to variables
446 
447 :(scenario copy_recipe_to_variable)
448 def main [
449   {1: (fn number -> number)} <- copy f
450   2:num <- call {1: (function number -> number)}, 34
451 ]
452 def f x:num -> y:num [
453   local-scope
454   load-ingredients
455   y <- copy x
456 ]
457 +mem: storing 34 in location 2
458 
459 :(scenario copy_overloaded_recipe_to_variable)
460 def main [
461   local-scope
462   {x: (fn num -> num)} <- copy f
463   1:num/raw <- call x, 34
464 ]
465 # variant f
466 def f x:bool -> y:bool [
467   local-scope
468   load-ingredients
469   y <- copy x
470 ]
471 # variant f_2
472 def f x:num -> y:num [
473   local-scope
474   load-ingredients
475   y <- copy x
476 ]
477 # x contains f_2
478 +mem: storing 34 in location 1
479 
480 :(before "End resolve_ambiguous_call(r, index, inst, caller_recipe) Special-cases")
481 if (inst.name == "copy") {
482   for (int i = 0;  i < SIZE(inst.ingredients);  ++i) {
483     if (!is_recipe_literal(inst.ingredients.at(i))) continue;
484     if (non_ghost_size(get_or_insert(Recipe_variants, inst.ingredients.at(i).name)) < 1) continue;
485     // potentially overloaded recipe
486     string new_name = resolve_ambiguous_call(inst.ingredients.at(i).name, inst.products.at(i), r, index, caller_recipe);
487     if (new_name == "") continue;
488     inst.ingredients.at(i).name = new_name;
489     inst.ingredients.at(i).value = get(Recipe_ordinal, new_name);
490   }
491   return;
492 }
493 :(code)
494 string resolve_ambiguous_call(const string& recipe_name, const reagent& call_types, const recipe_ordinal r, int index, const recipe& caller_recipe) {
495   instruction inst;
496   inst.name = recipe_name;
497   if (!is_mu_recipe(call_types)) return "";  // error raised elsewhere
498   if (is_recipe_literal(call_types)) return "";  // error raised elsewhere
499   construct_fake_call(call_types, inst);
500   resolve_ambiguous_call(r, index, inst, caller_recipe);
501   return inst.name;
502 }
503 void construct_fake_call(const reagent& recipe_var, instruction& out) {
504   assert(recipe_var.type->left->name == "recipe");
505   type_tree* stem = NULL;
506   for (stem = recipe_var.type->right;  stem && stem->left->name != "->";  stem = stem->right)
507     out.ingredients.push_back(copy(stem->left));
508   if (stem == NULL) return;
509   for (/*skip '->'*/stem = stem->right;  stem;  stem = stem->right)
510     out.products.push_back(copy(stem->left));
511 }
512 
513 :(scenario copy_shape_shifting_recipe_to_variable)
514 def main [
515   local-scope
516   {x: (fn num -> num)} <- copy f
517   1:num/raw <- call x, 34
518 ]
519 def f x:_elem -> y:_elem [
520   local-scope
521   load-inputs
522   y <- copy x
523 ]
524 +mem: storing 34 in location 1
525 
526 //: passing function literals to (higher-order) functions
527 
528 :(scenario pass_overloaded_recipe_literal_to_ingredient)
529 # like copy_overloaded_recipe_to_variable except we bind 'x' in the course of
530 # a 'call' rather than 'copy'
531 def main [
532   1:num <- g f
533 ]
534 def g {x: (fn num -> num)} -> result:num [
535   local-scope
536   load-ingredients
537   result <- call x, 34
538 ]
539 # variant f
540 def f x:bool -> y:bool [
541   local-scope
542   load-ingredients
543   y <- copy x
544 ]
545 # variant f_2
546 def f x:num -> y:num [
547   local-scope
548   load-ingredients
549   y <- copy x
550 ]
551 # x contains f_2
552 +mem: storing 34 in location 1
553 
554 :(after "End resolve_ambiguous_call(r, index, inst, caller_recipe) Special-cases")
555 for (int i = 0;  i < SIZE(inst.ingredients);  ++i) {
556   if (!is_mu_recipe(inst.ingredients.at(i))) continue;
557   if (non_ghost_size(get_or_insert(Recipe_variants, inst.ingredients.at(i).name)) < 1) continue;
558   if (get(Recipe_ordinal, inst.name) < MAX_PRIMITIVE_RECIPES) continue;
559   if (non_ghost_size(get_or_insert(Recipe_variants, inst.name)) > 1) {
560     raise << maybe(caller_recipe.name) << "sorry, we're not yet smart enough to simultaneously guess which overloads you want for '" << inst.name << "' and '" << inst.ingredients.at(i).name << "'\n" << end();
561     return;
562   }
563   const recipe& callee = get(Recipe, get(Recipe_ordinal, inst.name));
564   if (!callee.has_header) {
565     raise << maybe(caller_recipe.name) << "sorry, we're not yet smart enough to guess which variant of '" << inst.ingredients.at(i).name << "' you want, when the caller '" << inst.name << "' doesn't have a header\n" << end();
566     return;
567   }
568   string new_name = resolve_ambiguous_call(inst.ingredients.at(i).name, callee.ingredients.at(i), r, index, caller_recipe);
569   if (new_name != "") {
570     inst.ingredients.at(i).name = new_name;
571     inst.ingredients.at(i).value = get(Recipe_ordinal, new_name);
572   }
573 }
574 
575 :(scenario return_overloaded_recipe_literal_to_caller)
576 def main [
577   local-scope
578   {x: (fn num -> num)} <- g
579   1:num/raw <- call x, 34
580 ]
581 def g -> {x: (fn num -> num)} [
582   local-scope
583   return f
584 ]
585 # variant f
586 def f x:bool -> y:bool [
587   local-scope
588   load-ingredients
589   y <- copy x
590 ]
591 # variant f_2
592 def f x:num -> y:num [
593   local-scope
594   load-ingredients
595   y <- copy x
596 ]
597 # x contains f_2
598 +mem: storing 34 in location 1
599 
600 :(before "End resolve_ambiguous_call(r, index, inst, caller_recipe) Special-cases")
601 if (inst.name == "return" || inst.name == "reply") {
602   for (int i = 0;  i < SIZE(inst.ingredients);  ++i) {
603     if (!is_recipe_literal(inst.ingredients.at(i))) continue;
604     if (non_ghost_size(get_or_insert(Recipe_variants, inst.ingredients.at(i).name)) < 1) continue;
605     // potentially overloaded recipe
606     if (!caller_recipe.has_header) {
607       raise << maybe(caller_recipe.name) << "sorry, we're not yet smart enough to guess which variant of '" << inst.ingredients.at(i).name << "' you want, without a recipe header\n" << end();
608       return;
609     }
610     string new_name = resolve_ambiguous_call(inst.ingredients.at(i).name, caller_recipe.products.at(i), r, index, caller_recipe);
611     if (new_name == "") continue;
612     inst.ingredients.at(i).name = new_name;
613     inst.ingredients.at(i).value = get(Recipe_ordinal, new_name);
614   }
615   return;
616 }