summary refs log tree commit diff stats
path: root/tests/array/tarray.nim
blob: 01fbdf4228676bc641ce8deea4501b9c7203f51b (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
discard """
  file: "tarray.nim"
  output: "100124"
"""
# simple check for one dimensional arrays

type
  TMyArray = array[0..2, int]
  TMyRecord = tuple[x, y: int]

proc sum(a: TMyarray): int =
  result = 0
  var i = 0
  while i < len(a):
    inc(result, a[i])
    inc(i)

proc sum(a: openarray[int]): int =
  result = 0
  var i = 0
  while i < len(a):
    inc(result, a[i])
    inc(i)

proc getPos(r: TMyRecord): int =
  result = r.x + r.y

write(stdout, sum([1, 2, 3, 4]))
write(stdout, sum([]))
write(stdout, getPos( (x: 5, y: 7) ))
#OUT 10012

# bug #1669
let filesToCreate = ["tempdir/fl1.a", "tempdir/fl2.b",
            "tempdir/tempdir2/fl3.e", "tempdir/tempdir2/tempdir3/fl4.f"]

var found: array[0..filesToCreate.high, bool]

echo found.len
16' href='#n416'>416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Mu - 054static_dispatch.cc</title>
<meta name="Generator" content="Vim/7.4">
<meta name="plugin-version" content="vim7.4_v2">
<meta name="syntax" content="cpp">
<meta name="settings" content="number_lines,use_css,pre_wrap,no_foldcolumn,expand_tabs,line_ids,prevent_copy=">
<meta name="colorscheme" content="minimal">
<style type="text/css">
<!--
pre { white-space: pre-wrap; font-family: monospace; color: #aaaaaa; background-color: #080808; }
body { font-size: 12pt; font-family: monospace; color: #aaaaaa; background-color: #080808; }
a { color:#eeeeee; text-decoration: none; }
a:hover { text-decoration: underline; }
* { font-size: 12pt; font-size: 1em; }
.CommentedCode { color: #6c6c6c; }
.muData { color: #ffff00; }
.LineNr { color: #444444; }
.Delimiter { color: #800080; }
.Normal { color: #aaaaaa; background-color: #080808; padding-bottom: 1px; }
.traceContains { color: #008000; }
.traceAbsent { color: #c00000; }
.cSpecial { color: #008000; }
.muRecipe { color: #ff8700; }
.Comment { color: #9090ff; }
.Comment a { color:#0000ee; text-decoration:underline; }
.Constant { color: #00a0a0; }
.Special { color: #c00000; }
.Identifier { color: #c0a020; }
-->
</style>

<script type='text/javascript'>
<!--

/* function to open any folds containing a jumped-to line before jumping to it */
function JumpToLine()
{
  var lineNum;
  lineNum = window.location.hash;
  lineNum = lineNum.substr(1); /* strip off '#' */

  if (lineNum.indexOf('L') == -1) {
    lineNum = 'L'+lineNum;
  }
  lineElem = document.getElementById(lineNum);
  /* Always jump to new location even if the line was hidden inside a fold, or
   * we corrected the raw number to a line ID.
   */
  if (lineElem) {
    lineElem.scrollIntoView(true);
  }
  return true;
}
if ('onhashchange' in window) {
  window.onhashchange = JumpToLine;
}

-->
</script>
</head>
<body onload='JumpToLine();'>
<pre id='vimCodeElement'>
<span id="L1" class="LineNr">  1 </span><span class="Comment">//: Transform to maintain multiple variants of a recipe depending on the</span>
<span id="L2" class="LineNr">  2 </span><span class="Comment">//: number and types of the ingredients and products. Allows us to use nice</span>
<span id="L3" class="LineNr">  3 </span><span class="Comment">//: names like 'print' or 'length' in many mutually extensible ways.</span>
<span id="L4" class="LineNr">  4 </span>
<span id="L5" class="LineNr">  5 </span><span class="Delimiter">:(scenario static_dispatch)</span>
<span id="L6" class="LineNr">  6 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L7" class="LineNr">  7 </span>  <span class="Constant">7</span>:num/<span class="Special">raw &lt;- </span>test <span class="Constant">3</span>
<span id="L8" class="LineNr">  8 </span>]
<span id="L9" class="LineNr">  9 </span><span class="muRecipe">def</span> test a:num<span class="muRecipe"> -&gt; </span>z:num [
<span id="L10" class="LineNr"> 10 </span>  z<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
<span id="L11" class="LineNr"> 11 </span>]
<span id="L12" class="LineNr"> 12 </span><span class="muRecipe">def</span> test a:num<span class="Delimiter">,</span> b:num<span class="muRecipe"> -&gt; </span>z:num [
<span id="L13" class="LineNr"> 13 </span>  z<span class="Special"> &lt;- </span>copy <span class="Constant">2</span>
<span id="L14" class="LineNr"> 14 </span>]
<span id="L15" class="LineNr"> 15 </span><span class="traceContains">+mem: storing 1 in location 7</span>
<span id="L16" class="LineNr"> 16 </span>
<span id="L17" class="LineNr"> 17 </span><span class="Comment">//: When loading recipes, accumulate variants if headers don't collide, and</span>
<span id="L18" class="LineNr"> 18 </span><span class="Comment">//: flag an error if headers collide.</span>
<span id="L19" class="LineNr"> 19 </span>
<span id="L20" class="LineNr"> 20 </span><span class="Delimiter">:(before &quot;End Globals&quot;)</span>
<span id="L21" class="LineNr"> 21 </span>map&lt;string<span class="Delimiter">,</span> vector&lt;recipe_ordinal&gt; &gt; Recipe_variants<span class="Delimiter">;</span>
<span id="L22" class="LineNr"> 22 </span><span class="Delimiter">:(before &quot;End One-time Setup&quot;)</span>
<span id="L23" class="LineNr"> 23 </span><a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_variants<span class="Delimiter">,</span> <span class="Constant">&quot;main&quot;</span><span class="Delimiter">,</span> vector&lt;recipe_ordinal&gt;<span class="Delimiter">());</span>  <span class="Comment">// since we manually added main to Recipe_ordinal</span>
<span id="L24" class="LineNr"> 24 </span>
<span id="L25" class="LineNr"> 25 </span><span class="Delimiter">:(before &quot;End Globals&quot;)</span>
<span id="L26" class="LineNr"> 26 </span>map&lt;string<span class="Delimiter">,</span> vector&lt;recipe_ordinal&gt; &gt; Recipe_variants_snapshot<span class="Delimiter">;</span>
<span id="L27" class="LineNr"> 27 </span><span class="Delimiter">:(before &quot;End save_snapshots&quot;)</span>
<span id="L28" class="LineNr"> 28 </span>Recipe_variants_snapshot = Recipe_variants<span class="Delimiter">;</span>
<span id="L29" class="LineNr"> 29 </span><span class="Delimiter">:(before &quot;End restore_snapshots&quot;)</span>
<span id="L30" class="LineNr"> 30 </span>Recipe_variants = Recipe_variants_snapshot<span class="Delimiter">;</span>
<span id="L31" class="LineNr"> 31 </span>
<span id="L32" class="LineNr"> 32 </span><span class="Delimiter">:(before &quot;End Load Recipe Header(result)&quot;)</span>
<span id="L33" class="LineNr"> 33 </span><span class="Comment">// there can only ever be one variant for main</span>
<span id="L34" class="LineNr"> 34 </span><span class="Normal">if</span> <span class="Delimiter">(</span>result<span class="Delimiter">.</span>name != <span class="Constant">&quot;main&quot;</span> &amp;&amp; contains_key<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> result<span class="Delimiter">.</span>name<span class="Delimiter">))</span> <span class="Delimiter">{</span>
<span id="L35" class="LineNr"> 35 </span>  <span class="Normal">const</span> <a href='010vm.cc.html#L14'>recipe_ordinal</a> r = get<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> result<span class="Delimiter">.</span>name<span class="Delimiter">);</span>
<span id="L36" class="LineNr"> 36 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!contains_key<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">)</span> || get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>has_header<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L37" class="LineNr"> 37 </span>    string new_name = <a href='054static_dispatch.cc.html#L56'>matching_variant_name</a><span class="Delimiter">(</span>result<span class="Delimiter">);</span>
<span id="L38" class="LineNr"> 38 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>new_name<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Delimiter">{</span>
<span id="L39" class="LineNr"> 39 </span>      <span class="Comment">// variant doesn't already exist</span>
<span id="L40" class="LineNr"> 40 </span>      new_name = <a href='054static_dispatch.cc.html#L111'>next_unused_recipe_name</a><span class="Delimiter">(</span>result<span class="Delimiter">.</span>name<span class="Delimiter">);</span>
<span id="L41" class="LineNr"> 41 </span>      <a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> new_name<span class="Delimiter">,</span> Next_recipe_ordinal++<span class="Delimiter">);</span>
<span id="L42" class="LineNr"> 42 </span>      <a href='001help.cc.html#L229'>get_or_insert</a><span class="Delimiter">(</span>Recipe_variants<span class="Delimiter">,</span> result<span class="Delimiter">.</span>name<span class="Delimiter">).</span>push_back<span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> new_name<span class="Delimiter">));</span>
<span id="L43" class="LineNr"> 43 </span>    <span class="Delimiter">}</span>
<span id="L44" class="LineNr"> 44 </span>    <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">&quot;load&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;switching &quot;</span> &lt;&lt; result<span class="Delimiter">.</span>name &lt;&lt; <span class="Constant">&quot; to &quot;</span> &lt;&lt; new_name &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L45" class="LineNr"> 45 </span>    result<span class="Delimiter">.</span>name = new_name<span class="Delimiter">;</span>
<span id="L46" class="LineNr"> 46 </span>    result<span class="Delimiter">.</span>is_autogenerated = <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L47" class="LineNr"> 47 </span>  <span class="Delimiter">}</span>
<span id="L48" class="LineNr"> 48 </span><span class="Delimiter">}</span>
<span id="L49" class="LineNr"> 49 </span><span class="Normal">else</span> <span class="Delimiter">{</span>
<span id="L50" class="LineNr"> 50 </span>  <span class="Comment">// save first variant</span>
<span id="L51" class="LineNr"> 51 </span>  <a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> result<span class="Delimiter">.</span>name<span class="Delimiter">,</span> Next_recipe_ordinal++<span class="Delimiter">);</span>
<span id="L52" class="LineNr"> 52 </span>  <a href='001help.cc.html#L229'>get_or_insert</a><span class="Delimiter">(</span>Recipe_variants<span class="Delimiter">,</span> result<span class="Delimiter">.</span>name<span class="Delimiter">).</span>push_back<span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> result<span class="Delimiter">.</span>name<span class="Delimiter">));</span>
<span id="L53" class="LineNr"> 53 </span><span class="Delimiter">}</span>
<span id="L54" class="LineNr"> 54 </span>
<span id="L55" class="LineNr"> 55 </span><span class="Delimiter">:(code)</span>
<span id="L56" class="LineNr"> 56 </span>string <a href='054static_dispatch.cc.html#L56'>matching_variant_name</a><span class="Delimiter">(</span><span class="Normal">const</span> recipe&amp; rr<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L57" class="LineNr"> 57 </span>  <span class="Normal">const</span> vector&lt;recipe_ordinal&gt;&amp; variants = <a href='001help.cc.html#L229'>get_or_insert</a><span class="Delimiter">(</span>Recipe_variants<span class="Delimiter">,</span> rr<span class="Delimiter">.</span>name<span class="Delimiter">);</span>
<span id="L58" class="LineNr"> 58 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>variants<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L59" class="LineNr"> 59 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>!contains_key<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)))</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>
<span id="L60" class="LineNr"> 60 </span>    <span class="Normal">const</span> recipe&amp; candidate = get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">));</span>
<span id="L61" class="LineNr"> 61 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>!all_reagents_match<span class="Delimiter">(</span>rr<span class="Delimiter">,</span> candidate<span class="Delimiter">))</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>
<span id="L62" class="LineNr"> 62 </span>    <span class="Identifier">return</span> candidate<span class="Delimiter">.</span>name<span class="Delimiter">;</span>
<span id="L63" class="LineNr"> 63 </span>  <span class="Delimiter">}</span>
<span id="L64" class="LineNr"> 64 </span>  <span class="Identifier">return</span> <span class="Constant">&quot;&quot;</span><span class="Delimiter">;</span>
<span id="L65" class="LineNr"> 65 </span><span class="Delimiter">}</span>
<span id="L66" class="LineNr"> 66 </span>
<span id="L67" class="LineNr"> 67 </span><span class="Normal">bool</span> <a href='054static_dispatch.cc.html#L67'>all_reagents_match</a><span class="Delimiter">(</span><span class="Normal">const</span> recipe&amp; r1<span class="Delimiter">,</span> <span class="Normal">const</span> recipe&amp; r2<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L68" class="LineNr"> 68 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>r1<span class="Delimiter">.</span>ingredients<span class="Delimiter">)</span> != <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>r2<span class="Delimiter">.</span>ingredients<span class="Delimiter">))</span> <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L69" class="LineNr"> 69 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>r1<span class="Delimiter">.</span>products<span class="Delimiter">)</span> != <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>r2<span class="Delimiter">.</span>products<span class="Delimiter">))</span> <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L70" class="LineNr"> 70 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>r1<span class="Delimiter">.</span>ingredients<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L71" class="LineNr"> 71 </span>    expand_type_abbreviations<span class="Delimiter">(</span>r1<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>type<span class="Delimiter">);</span>
<span id="L72" class="LineNr"> 72 </span>    expand_type_abbreviations<span class="Delimiter">(</span>r2<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>type<span class="Delimiter">);</span>
<span id="L73" class="LineNr"> 73 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>!deeply_equal_type_names<span class="Delimiter">(</span>r1<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">),</span> r2<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)))</span>
<span id="L74" class="LineNr"> 74 </span>      <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L75" class="LineNr"> 75 </span>  <span class="Delimiter">}</span>
<span id="L76" class="LineNr"> 76 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>r1<span class="Delimiter">.</span>products<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L77" class="LineNr"> 77 </span>    expand_type_abbreviations<span class="Delimiter">(</span>r1<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>type<span class="Delimiter">);</span>
<span id="L78" class="LineNr"> 78 </span>    expand_type_abbreviations<span class="Delimiter">(</span>r2<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>type<span class="Delimiter">);</span>
<span id="L79" class="LineNr"> 79 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>!deeply_equal_type_names<span class="Delimiter">(</span>r1<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">),</span> r2<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)))</span>
<span id="L80" class="LineNr"> 80 </span>      <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L81" class="LineNr"> 81 </span>  <span class="Delimiter">}</span>
<span id="L82" class="LineNr"> 82 </span>  <span class="Identifier">return</span> <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L83" class="LineNr"> 83 </span><span class="Delimiter">}</span>
<span id="L84" class="LineNr"> 84 </span>
<span id="L85" class="LineNr"> 85 </span><span class="Delimiter">:(before &quot;End Globals&quot;)</span>
<span id="L86" class="LineNr"> 86 </span>set&lt;string&gt; Literal_type_names<span class="Delimiter">;</span>
<span id="L87" class="LineNr"> 87 </span><span class="Delimiter">:(before &quot;End One-time Setup&quot;)</span>
<span id="L88" class="LineNr"> 88 </span>Literal_type_names<span class="Delimiter">.</span>insert<span class="Delimiter">(</span><span class="Constant">&quot;number&quot;</span><span class="Delimiter">);</span>
<span id="L89" class="LineNr"> 89 </span>Literal_type_names<span class="Delimiter">.</span>insert<span class="Delimiter">(</span><span class="Constant">&quot;character&quot;</span><span class="Delimiter">);</span>
<span id="L90" class="LineNr"> 90 </span><span class="Delimiter">:(code)</span>
<span id="L91" class="LineNr"> 91 </span><span class="Normal">bool</span> deeply_equal_type_names<span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; a<span class="Delimiter">,</span> <span class="Normal">const</span> reagent&amp; b<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L92" class="LineNr"> 92 </span>  <span class="Identifier">return</span> deeply_equal_type_names<span class="Delimiter">(</span>a<span class="Delimiter">.</span>type<span class="Delimiter">,</span> b<span class="Delimiter">.</span>type<span class="Delimiter">);</span>
<span id="L93" class="LineNr"> 93 </span><span class="Delimiter">}</span>
<span id="L94" class="LineNr"> 94 </span><span class="Normal">bool</span> deeply_equal_type_names<span class="Delimiter">(</span><span class="Normal">const</span> type_tree* a<span class="Delimiter">,</span> <span class="Normal">const</span> type_tree* b<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L95" class="LineNr"> 95 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!a<span class="Delimiter">)</span> <span class="Identifier">return</span> !b<span class="Delimiter">;</span>
<span id="L96" class="LineNr"> 96 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!b<span class="Delimiter">)</span> <span class="Identifier">return</span> !a<span class="Delimiter">;</span>
<span id="L97" class="LineNr"> 97 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>a<span class="Delimiter">-&gt;</span>atom != b<span class="Delimiter">-&gt;</span>atom<span class="Delimiter">)</span> <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L98" class="LineNr"> 98 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>a<span class="Delimiter">-&gt;</span>atom<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L99" class="LineNr"> 99 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>a<span class="Delimiter">-&gt;</span>name == <span class="Constant">&quot;literal&quot;</span> &amp;&amp; b<span class="Delimiter">-&gt;</span>name == <span class="Constant">&quot;literal&quot;</span><span class="Delimiter">)</span>
<span id="L100" class="LineNr">100 </span>      <span class="Identifier">return</span> <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L101" class="LineNr">101 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>a<span class="Delimiter">-&gt;</span>name == <span class="Constant">&quot;literal&quot;</span><span class="Delimiter">)</span>
<span id="L102" class="LineNr">102 </span>      <span class="Identifier">return</span> Literal_type_names<span class="Delimiter">.</span>find<span class="Delimiter">(</span>b<span class="Delimiter">-&gt;</span>name<span class="Delimiter">)</span> != Literal_type_names<span class="Delimiter">.</span><a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L103" class="LineNr">103 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>b<span class="Delimiter">-&gt;</span>name == <span class="Constant">&quot;literal&quot;</span><span class="Delimiter">)</span>
<span id="L104" class="LineNr">104 </span>      <span class="Identifier">return</span> Literal_type_names<span class="Delimiter">.</span>find<span class="Delimiter">(</span>a<span class="Delimiter">-&gt;</span>name<span class="Delimiter">)</span> != Literal_type_names<span class="Delimiter">.</span><a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L105" class="LineNr">105 </span>    <span class="Identifier">return</span> a<span class="Delimiter">-&gt;</span>name == b<span class="Delimiter">-&gt;</span>name<span class="Delimiter">;</span>
<span id="L106" class="LineNr">106 </span>  <span class="Delimiter">}</span>
<span id="L107" class="LineNr">107 </span>  <span class="Identifier">return</span> deeply_equal_type_names<span class="Delimiter">(</span>a<span class="Delimiter">-&gt;</span>left<span class="Delimiter">,</span> b<span class="Delimiter">-&gt;</span>left<span class="Delimiter">)</span>
<span id="L108" class="LineNr">108 </span>      &amp;&amp; deeply_equal_type_names<span class="Delimiter">(</span>a<span class="Delimiter">-&gt;</span>right<span class="Delimiter">,</span> b<span class="Delimiter">-&gt;</span>right<span class="Delimiter">);</span>
<span id="L109" class="LineNr">109 </span><span class="Delimiter">}</span>
<span id="L110" class="LineNr">110 </span>
<span id="L111" class="LineNr">111 </span>string <a href='054static_dispatch.cc.html#L111'>next_unused_recipe_name</a><span class="Delimiter">(</span><span class="Normal">const</span> string&amp; recipe_name<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L112" class="LineNr">112 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">2</span><span class="Delimiter">;</span>  <span class="Comment">/*</span><span class="Comment">forever</span><span class="Comment">*/</span><span class="Delimiter">;</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L113" class="LineNr">113 </span>    ostringstream out<span class="Delimiter">;</span>
<span id="L114" class="LineNr">114 </span>    out &lt;&lt; recipe_name &lt;&lt; <span class="Constant">'_'</span> &lt;&lt; i<span class="Delimiter">;</span>
<span id="L115" class="LineNr">115 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>!contains_key<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> out<span class="Delimiter">.</span>str<span class="Delimiter">()))</span>
<span id="L116" class="LineNr">116 </span>      <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span>
<span id="L117" class="LineNr">117 </span>  <span class="Delimiter">}</span>
<span id="L118" class="LineNr">118 </span><span class="Delimiter">}</span>
<span id="L119" class="LineNr">119 </span>
<span id="L120" class="LineNr">120 </span><span class="Comment">//: Once all the recipes are loaded, transform their bodies to replace each</span>
<span id="L121" class="LineNr">121 </span><span class="Comment">//: call with the most suitable variant.</span>
<span id="L122" class="LineNr">122 </span>
<span id="L123" class="LineNr">123 </span><span class="Delimiter">:(scenario static_dispatch_picks_most_similar_variant)</span>
<span id="L124" class="LineNr">124 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L125" class="LineNr">125 </span>  <span class="Constant">7</span>:num/<span class="Special">raw &lt;- </span>test <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">4</span><span class="Delimiter">,</span> <span class="Constant">5</span>
<span id="L126" class="LineNr">126 </span>]
<span id="L127" class="LineNr">127 </span><span class="muRecipe">def</span> test a:num<span class="muRecipe"> -&gt; </span>z:num [
<span id="L128" class="LineNr">128 </span>  z<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
<span id="L129" class="LineNr">129 </span>]
<span id="L130" class="LineNr">130 </span><span class="muRecipe">def</span> test a:num<span class="Delimiter">,</span> b:num<span class="muRecipe"> -&gt; </span>z:num [
<span id="L131" class="LineNr">131 </span>  z<span class="Special"> &lt;- </span>copy <span class="Constant">2</span>
<span id="L132" class="LineNr">132 </span>]
<span id="L133" class="LineNr">133 </span><span class="traceContains">+mem: storing 2 in location 7</span>
<span id="L134" class="LineNr">134 </span>
<span id="L135" class="LineNr">135 </span><span class="Comment">//: support recipe headers in a previous transform to fill in missing types</span>
<span id="L136" class="LineNr">136 </span><span class="Delimiter">:(before &quot;End check_or_set_invalid_types&quot;)</span>
<span id="L137" class="LineNr">137 </span><span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>caller<span class="Delimiter">.</span>ingredients<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span>
<span id="L138" class="LineNr">138 </span>  check_or_set_invalid_types<span class="Delimiter">(</span>caller<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>type<span class="Delimiter">,</span> <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>caller<span class="Delimiter">.</span>name<span class="Delimiter">),</span> <span class="Constant">&quot;recipe header ingredient&quot;</span><span class="Delimiter">);</span>
<span id="L139" class="LineNr">139 </span><span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>caller<span class="Delimiter">.</span>products<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span>
<span id="L140" class="LineNr">140 </span>  check_or_set_invalid_types<span class="Delimiter">(</span>caller<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>type<span class="Delimiter">,</span> <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>caller<span class="Delimiter">.</span>name<span class="Delimiter">),</span> <span class="Constant">&quot;recipe header product&quot;</span><span class="Delimiter">);</span>
<span id="L141" class="LineNr">141 </span>
<span id="L142" class="LineNr">142 </span><span class="Comment">//: save original name of recipes before renaming them</span>
<span id="L143" class="LineNr">143 </span><span class="Delimiter">:(before &quot;End <a href='010vm.cc.html#L19'>recipe</a> Fields&quot;)</span>
<span id="L144" class="LineNr">144 </span>string original_name<span class="Delimiter">;</span>
<span id="L145" class="LineNr">145 </span><span class="Comment">//: original name is only set during load</span>
<span id="L146" class="LineNr">146 </span><span class="Delimiter">:(before &quot;End Load Recipe Name&quot;)</span>
<span id="L147" class="LineNr">147 </span>result<span class="Delimiter">.</span>original_name = result<span class="Delimiter">.</span>name<span class="Delimiter">;</span>
<span id="L148" class="LineNr">148 </span>
<span id="L149" class="LineNr">149 </span><span class="Comment">//: after filling in all missing types (because we'll be introducing 'blank' types in this transform in a later layer, for shape-shifting recipes)</span>
<span id="L150" class="LineNr">150 </span><span class="Delimiter">:(after &quot;Transform.push_back(transform_names)&quot;)</span>
<span id="L151" class="LineNr">151 </span>Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span><a href='054static_dispatch.cc.html#L163'>resolve_ambiguous_calls</a><span class="Delimiter">);</span>  <span class="Comment">// idempotent</span>
<span id="L152" class="LineNr">152 </span>
<span id="L153" class="LineNr">153 </span><span class="Comment">//: In a later layer we'll introduce recursion in resolve_ambiguous_calls, by</span>
<span id="L154" class="LineNr">154 </span><span class="Comment">//: having it generate code for shape-shifting recipes and then transform such</span>
<span id="L155" class="LineNr">155 </span><span class="Comment">//: code. This data structure will help error messages be more useful.</span>
<span id="L156" class="LineNr">156 </span><span class="Comment">//:</span>
<span id="L157" class="LineNr">157 </span><span class="Comment">//: We're punning the 'call' data structure just because it has slots for</span>
<span id="L158" class="LineNr">158 </span><span class="Comment">//: calling recipe and calling instruction.</span>
<span id="L159" class="LineNr">159 </span><span class="Delimiter">:(before &quot;End Globals&quot;)</span>
<span id="L160" class="LineNr">160 </span>list&lt;call&gt; Resolve_stack<span class="Delimiter">;</span>
<span id="L161" class="LineNr">161 </span>
<span id="L162" class="LineNr">162 </span><span class="Delimiter">:(code)</span>
<span id="L163" class="LineNr">163 </span><span class="Normal">void</span> <a href='054static_dispatch.cc.html#L163'>resolve_ambiguous_calls</a><span class="Delimiter">(</span><span class="Normal">const</span> <a href='010vm.cc.html#L14'>recipe_ordinal</a> r<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L164" class="LineNr">164 </span>  recipe&amp; caller_recipe = get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">);</span>
<span id="L165" class="LineNr">165 </span>  <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9991</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;--- resolve ambiguous calls for <a href='010vm.cc.html#L19'>recipe</a> &quot;</span> &lt;&lt; caller_recipe<span class="Delimiter">.</span>name &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L166" class="LineNr">166 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> index = <span class="Constant">0</span><span class="Delimiter">;</span>  index &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>caller_recipe<span class="Delimiter">.</span>steps<span class="Delimiter">);</span>  ++index<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L167" class="LineNr">167 </span>    instruction&amp; inst = caller_recipe<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>at<span class="Delimiter">(</span>index<span class="Delimiter">);</span>
<span id="L168" class="LineNr">168 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>is_label<span class="Delimiter">)</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>
<span id="L169" class="LineNr">169 </span>    <a href='054static_dispatch.cc.html#L173'>resolve_ambiguous_call</a><span class="Delimiter">(</span>r<span class="Delimiter">,</span> index<span class="Delimiter">,</span> inst<span class="Delimiter">,</span> caller_recipe<span class="Delimiter">);</span>
<span id="L170" class="LineNr">170 </span>  <span class="Delimiter">}</span>
<span id="L171" class="LineNr">171 </span><span class="Delimiter">}</span>
<span id="L172" class="LineNr">172 </span>
<span id="L173" class="LineNr">173 </span><span class="Normal">void</span> <a href='054static_dispatch.cc.html#L173'>resolve_ambiguous_call</a><span class="Delimiter">(</span><span class="Normal">const</span> <a href='010vm.cc.html#L14'>recipe_ordinal</a> r<span class="Delimiter">,</span> <span class="Normal">int</span> index<span class="Delimiter">,</span> instruction&amp; inst<span class="Delimiter">,</span> <span class="Normal">const</span> recipe&amp; caller_recipe<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L174" class="LineNr">174 </span>  <span class="Comment">// End resolve_ambiguous_call(r, index, inst, caller_recipe) Special-cases</span>
<span id="L175" class="LineNr">175 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='054static_dispatch.cc.html#L370'>non_ghost_size</a><span class="Delimiter">(</span><a href='001help.cc.html#L229'>get_or_insert</a><span class="Delimiter">(</span>Recipe_variants<span class="Delimiter">,</span> inst<span class="Delimiter">.</span>name<span class="Delimiter">))</span> == <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Identifier">return</span><span class="Delimiter">;</span>
<span id="L176" class="LineNr">176 </span>  <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9992</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;instruction &quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L177" class="LineNr">177 </span>  Resolve_stack<span class="Delimiter">.</span>push_front<span class="Delimiter">(</span>call<span class="Delimiter">(</span>r<span class="Delimiter">,</span> index<span class="Delimiter">));</span>
<span id="L178" class="LineNr">178 </span>  string new_name = best_variant<span class="Delimiter">(</span>inst<span class="Delimiter">,</span> caller_recipe<span class="Delimiter">);</span>
<span id="L179" class="LineNr">179 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!new_name<span class="Delimiter">.</span>empty<span class="Delimiter">())</span>
<span id="L180" class="LineNr">180 </span>    inst<span class="Delimiter">.</span>name = new_name<span class="Delimiter">;</span>
<span id="L181" class="LineNr">181 </span>  assert<span class="Delimiter">(</span>Resolve_stack<span class="Delimiter">.</span>front<span class="Delimiter">().</span>running_recipe == r<span class="Delimiter">);</span>
<span id="L182" class="LineNr">182 </span>  assert<span class="Delimiter">(</span>Resolve_stack<span class="Delimiter">.</span>front<span class="Delimiter">().</span>running_step_index == index<span class="Delimiter">);</span>
<span id="L183" class="LineNr">183 </span>  Resolve_stack<span class="Delimiter">.</span>pop_front<span class="Delimiter">();</span>
<span id="L184" class="LineNr">184 </span><span class="Delimiter">}</span>
<span id="L185" class="LineNr">185 </span>
<span id="L186" class="LineNr">186 </span>string best_variant<span class="Delimiter">(</span><span class="Normal">const</span> instruction&amp; inst<span class="Delimiter">,</span> <span class="Normal">const</span> recipe&amp; caller_recipe<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L187" class="LineNr">187 </span>  <span class="Normal">const</span> vector&lt;recipe_ordinal&gt;&amp; variants = get<span class="Delimiter">(</span>Recipe_variants<span class="Delimiter">,</span> inst<span class="Delimiter">.</span>name<span class="Delimiter">);</span>
<span id="L188" class="LineNr">188 </span>  vector&lt;recipe_ordinal&gt; candidates<span class="Delimiter">;</span>
<span id="L189" class="LineNr">189 </span>
<span id="L190" class="LineNr">190 </span>  <span class="Comment">// Static Dispatch Phase 1</span>
<span id="L191" class="LineNr">191 </span><span class="CommentedCode">//?   cerr &lt;&lt; inst.name &lt;&lt; &quot; phase 1\n&quot;;</span>
<span id="L192" class="LineNr">192 </span>  candidates = <a href='054static_dispatch.cc.html#L245'>strictly_matching_variants</a><span class="Delimiter">(</span>inst<span class="Delimiter">,</span> variants<span class="Delimiter">);</span>
<span id="L193" class="LineNr">193 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!candidates<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Identifier">return</span> best_variant<span class="Delimiter">(</span>inst<span class="Delimiter">,</span> candidates<span class="Delimiter">).</span>name<span class="Delimiter">;</span>
<span id="L194" class="LineNr">194 </span>
<span id="L195" class="LineNr">195 </span>  <span class="Comment">// Static Dispatch Phase 2</span>
<span id="L196" class="LineNr">196 </span><span class="CommentedCode">//?   cerr &lt;&lt; inst.name &lt;&lt; &quot; phase 2\n&quot;;</span>
<span id="L197" class="LineNr">197 </span>  candidates = <a href='054static_dispatch.cc.html#L274'>strictly_matching_variants_except_literal_against_address_or_boolean</a><span class="Delimiter">(</span>inst<span class="Delimiter">,</span> variants<span class="Delimiter">);</span>
<span id="L198" class="LineNr">198 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!candidates<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Identifier">return</span> best_variant<span class="Delimiter">(</span>inst<span class="Delimiter">,</span> candidates<span class="Delimiter">).</span>name<span class="Delimiter">;</span>
<span id="L199" class="LineNr">199 </span>
<span id="L200" class="LineNr">200 </span><span class="CommentedCode">//?   cerr &lt;&lt; inst.name &lt;&lt; &quot; phase 3\n&quot;;</span>
<span id="L201" class="LineNr">201 </span>  <span class="Comment">// Static Dispatch Phase 3</span>
<span id="L202" class="LineNr">202 </span>  <span class="Comment">//: (shape-shifting recipes in a later layer)</span>
<span id="L203" class="LineNr">203 </span>  <span class="Comment">// End Static Dispatch Phase 3</span>
<span id="L204" class="LineNr">204 </span>
<span id="L205" class="LineNr">205 </span>  <span class="Comment">// Static Dispatch Phase 4</span>
<span id="L206" class="LineNr">206 </span><span class="CommentedCode">//?   cerr &lt;&lt; inst.name &lt;&lt; &quot; phase 4\n&quot;;</span>
<span id="L207" class="LineNr">207 </span>  candidates = <a href='054static_dispatch.cc.html#L313'>matching_variants</a><span class="Delimiter">(</span>inst<span class="Delimiter">,</span> variants<span class="Delimiter">);</span>
<span id="L208" class="LineNr">208 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!candidates<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Identifier">return</span> best_variant<span class="Delimiter">(</span>inst<span class="Delimiter">,</span> candidates<span class="Delimiter">).</span>name<span class="Delimiter">;</span>
<span id="L209" class="LineNr">209 </span>
<span id="L210" class="LineNr">210 </span>  <span class="Comment">// error messages</span>
<span id="L211" class="LineNr">211 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!is_primitive<span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> inst<span class="Delimiter">.</span>name<span class="Delimiter">)))</span> <span class="Delimiter">{</span>  <span class="Comment">// we currently don't check types for primitive variants</span>
<span id="L212" class="LineNr">212 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>variants<span class="Delimiter">)</span> == <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L213" class="LineNr">213 </span>      <a href='003trace.cc.html#L174'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>caller_recipe<span class="Delimiter">.</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;types don't match in call for '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
<span id="L214" class="LineNr">214 </span>      <a href='003trace.cc.html#L174'>raise</a> &lt;&lt; <span class="Constant">&quot;  which tries to call '&quot;</span> &lt;&lt; original_header_label<span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L215" class="LineNr">215 </span>    <span class="Delimiter">}</span>
<span id="L216" class="LineNr">216 </span>    <span class="Normal">else</span> <span class="Delimiter">{</span>
<span id="L217" class="LineNr">217 </span>      <a href='003trace.cc.html#L174'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>caller_recipe<span class="Delimiter">.</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;failed to find a matching call for '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L218" class="LineNr">218 </span>      <a href='003trace.cc.html#L174'>raise</a> &lt;&lt; <span class="Constant">&quot;  available variants are:</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L219" class="LineNr">219 </span>      <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>variants<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span>
<span id="L220" class="LineNr">220 </span>        <a href='003trace.cc.html#L174'>raise</a> &lt;&lt; <span class="Constant">&quot;    &quot;</span> &lt;&lt; <a href='054static_dispatch.cc.html#L594'>original_header_label</a><span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)))</span> &lt;&lt; <span class="cSpecial">'\n'</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L221" class="LineNr">221 </span>    <span class="Delimiter">}</span>
<span id="L222" class="LineNr">222 </span>    <span class="Normal">for</span> <span class="Delimiter">(</span>list&lt;call&gt;::iterator p = <span class="Comment">/*</span><span class="Comment">skip</span><span class="Comment">*/</span>++Resolve_stack<span class="Delimiter">.</span>begin<span class="Delimiter">();</span>  p != Resolve_stack<span class="Delimiter">.</span><a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>  ++p<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L223" class="LineNr">223 </span>      <span class="Normal">const</span> recipe&amp; specializer_recipe = get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> p<span class="Delimiter">-&gt;</span>running_recipe<span class="Delimiter">);</span>
<span id="L224" class="LineNr">224 </span>      <span class="Normal">const</span> instruction&amp; specializer_inst = specializer_recipe<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>at<span class="Delimiter">(</span>p<span class="Delimiter">-&gt;</span>running_step_index<span class="Delimiter">);</span>
<span id="L225" class="LineNr">225 </span>      <span class="Normal">if</span> <span class="Delimiter">(</span>specializer_recipe<span class="Delimiter">.</span>name != <span class="Constant">&quot;interactive&quot;</span><span class="Delimiter">)</span>
<span id="L226" class="LineNr">226 </span>        <a href='003trace.cc.html#L174'>raise</a> &lt;&lt; <span class="Constant">&quot;  (from '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>specializer_inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;' in &quot;</span> &lt;&lt; specializer_recipe<span class="Delimiter">.</span>name &lt;&lt; <span class="Constant">&quot;)</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L227" class="LineNr">227 </span>      <span class="Normal">else</span>
<span id="L228" class="LineNr">228 </span>        <a href='003trace.cc.html#L174'>raise</a> &lt;&lt; <span class="Constant">&quot;  (from '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>specializer_inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;')</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L229" class="LineNr">229 </span>      <span class="Comment">// One special-case to help with the rewrite_stash transform. (cross-layer)</span>
<span id="L230" class="LineNr">230 </span>      <span class="Normal">if</span> <span class="Delimiter">(</span>specializer_inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>name<span class="Delimiter">.</span>find<span class="Delimiter">(</span><span class="Constant">&quot;stash_&quot;</span><span class="Delimiter">)</span> == <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L231" class="LineNr">231 </span>        <a href='010vm.cc.html#L32'>instruction</a> stash_inst<span class="Delimiter">;</span>
<span id="L232" class="LineNr">232 </span>        <span class="Normal">if</span> <span class="Delimiter">(</span><a href='054static_dispatch.cc.html#L377'>next_stash</a><span class="Delimiter">(</span>*p<span class="Delimiter">,</span> &amp;stash_inst<span class="Delimiter">))</span> <span class="Delimiter">{</span>
<span id="L233" class="LineNr">233 </span>          <span class="Normal">if</span> <span class="Delimiter">(</span>specializer_recipe<span class="Delimiter">.</span>name != <span class="Constant">&quot;interactive&quot;</span><span class="Delimiter">)</span>
<span id="L234" class="LineNr">234 </span>            <a href='003trace.cc.html#L174'>raise</a> &lt;&lt; <span class="Constant">&quot;  (part of '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>stash_inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;' in &quot;</span> &lt;&lt; specializer_recipe<span class="Delimiter">.</span>name &lt;&lt; <span class="Constant">&quot;)</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L235" class="LineNr">235 </span>          <span class="Normal">else</span>
<span id="L236" class="LineNr">236 </span>            <a href='003trace.cc.html#L174'>raise</a> &lt;&lt; <span class="Constant">&quot;  (part of '&quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>stash_inst<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;')</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L237" class="LineNr">237 </span>        <span class="Delimiter">}</span>
<span id="L238" class="LineNr">238 </span>      <span class="Delimiter">}</span>
<span id="L239" class="LineNr">239 </span>    <span class="Delimiter">}</span>
<span id="L240" class="LineNr">240 </span>  <span class="Delimiter">}</span>
<span id="L241" class="LineNr">241 </span>  <span class="Identifier">return</span> <span class="Constant">&quot;&quot;</span><span class="Delimiter">;</span>
<span id="L242" class="LineNr">242 </span><span class="Delimiter">}</span>
<span id="L243" class="LineNr">243 </span>
<span id="L244" class="LineNr">244 </span><span class="Comment">// phase 1</span>
<span id="L245" class="LineNr">245 </span>vector&lt;recipe_ordinal&gt; <a href='054static_dispatch.cc.html#L245'>strictly_matching_variants</a><span class="Delimiter">(</span><span class="Normal">const</span> instruction&amp; inst<span class="Delimiter">,</span> <span class="Normal">const</span> vector&lt;recipe_ordinal&gt;&amp; variants<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L246" class="LineNr">246 </span>  vector&lt;recipe_ordinal&gt; result<span class="Delimiter">;</span>
<span id="L247" class="LineNr">247 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>variants<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L248" class="LineNr">248 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)</span> == -<span class="Constant">1</span><span class="Delimiter">)</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>
<span id="L249" class="LineNr">249 </span>    <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9992</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;checking variant (strict) &quot;</span> &lt;&lt; i &lt;&lt; <span class="Constant">&quot;: &quot;</span> &lt;&lt; header_label<span class="Delimiter">(</span>variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">))</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L250" class="LineNr">250 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span><a href='054static_dispatch.cc.html#L256'>all_header_reagents_strictly_match</a><span class="Delimiter">(</span>inst<span class="Delimiter">,</span> get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">))))</span>
<span id="L251" class="LineNr">251 </span>      result<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">));</span>
<span id="L252" class="LineNr">252 </span>  <span class="Delimiter">}</span>
<span id="L253" class="LineNr">253 </span>  <span class="Identifier">return</span> result<span class="Delimiter">;</span>
<span id="L254" class="LineNr">254 </span><span class="Delimiter">}</span>
<span id="L255" class="LineNr">255 </span>
<span id="L256" class="LineNr">256 </span><span class="Normal">bool</span> <a href='054static_dispatch.cc.html#L256'>all_header_reagents_strictly_match</a><span class="Delimiter">(</span><span class="Normal">const</span> instruction&amp; inst<span class="Delimiter">,</span> <span class="Normal">const</span> recipe&amp; variant<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L257" class="LineNr">257 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; min<span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">),</span> <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>variant<span class="Delimiter">.</span>ingredients<span class="Delimiter">));</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L258" class="LineNr">258 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>!types_strictly_match<span class="Delimiter">(</span>variant<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">),</span> inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L259" class="LineNr">259 </span>      <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9993</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;strict match failed: ingredient &quot;</span> &lt;&lt; i &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L260" class="LineNr">260 </span>      <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L261" class="LineNr">261 </span>    <span class="Delimiter">}</span>
<span id="L262" class="LineNr">262 </span>  <span class="Delimiter">}</span>
<span id="L263" class="LineNr">263 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; min<span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">),</span> <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>variant<span class="Delimiter">.</span>products<span class="Delimiter">));</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L264" class="LineNr">264 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>is_dummy<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)))</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>
<span id="L265" class="LineNr">265 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>!types_strictly_match<span class="Delimiter">(</span>variant<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">),</span> inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L266" class="LineNr">266 </span>      <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9993</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;strict match failed: product &quot;</span> &lt;&lt; i &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L267" class="LineNr">267 </span>      <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L268" class="LineNr">268 </span>    <span class="Delimiter">}</span>
<span id="L269" class="LineNr">269 </span>  <span class="Delimiter">}</span>
<span id="L270" class="LineNr">270 </span>  <span class="Identifier">return</span> <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L271" class="LineNr">271 </span><span class="Delimiter">}</span>
<span id="L272" class="LineNr">272 </span>
<span id="L273" class="LineNr">273 </span><span class="Comment">// phase 2</span>
<span id="L274" class="LineNr">274 </span>vector&lt;recipe_ordinal&gt; <a href='054static_dispatch.cc.html#L274'>strictly_matching_variants_except_literal_against_address_or_boolean</a><span class="Delimiter">(</span><span class="Normal">const</span> instruction&amp; inst<span class="Delimiter">,</span> <span class="Normal">const</span> vector&lt;recipe_ordinal&gt;&amp; variants<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L275" class="LineNr">275 </span>  vector&lt;recipe_ordinal&gt; result<span class="Delimiter">;</span>
<span id="L276" class="LineNr">276 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>variants<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L277" class="LineNr">277 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)</span> == -<span class="Constant">1</span><span class="Delimiter">)</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>
<span id="L278" class="LineNr">278 </span>    <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9992</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;checking variant (strict except literal-against-boolean) &quot;</span> &lt;&lt; i &lt;&lt; <span class="Constant">&quot;: &quot;</span> &lt;&lt; header_label<span class="Delimiter">(</span>variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">))</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L279" class="LineNr">279 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span><a href='054static_dispatch.cc.html#L285'>all_header_reagents_strictly_match_except_literal_against_address_or_boolean</a><span class="Delimiter">(</span>inst<span class="Delimiter">,</span> get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">))))</span>
<span id="L280" class="LineNr">280 </span>      result<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">));</span>
<span id="L281" class="LineNr">281 </span>  <span class="Delimiter">}</span>
<span id="L282" class="LineNr">282 </span>  <span class="Identifier">return</span> result<span class="Delimiter">;</span>
<span id="L283" class="LineNr">283 </span><span class="Delimiter">}</span>
<span id="L284" class="LineNr">284 </span>
<span id="L285" class="LineNr">285 </span><span class="Normal">bool</span> <a href='054static_dispatch.cc.html#L285'>all_header_reagents_strictly_match_except_literal_against_address_or_boolean</a><span class="Delimiter">(</span><span class="Normal">const</span> instruction&amp; inst<span class="Delimiter">,</span> <span class="Normal">const</span> recipe&amp; variant<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L286" class="LineNr">286 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; min<span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">),</span> <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>variant<span class="Delimiter">.</span>ingredients<span class="Delimiter">));</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L287" class="LineNr">287 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>!types_strictly_match_except_literal_against_address_or_boolean<span class="Delimiter">(</span>variant<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">),</span> inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L288" class="LineNr">288 </span>      <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9993</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;match failed: ingredient &quot;</span> &lt;&lt; i &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L289" class="LineNr">289 </span>      <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L290" class="LineNr">290 </span>    <span class="Delimiter">}</span>
<span id="L291" class="LineNr">291 </span>  <span class="Delimiter">}</span>
<span id="L292" class="LineNr">292 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; min<span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>variant<span class="Delimiter">.</span>products<span class="Delimiter">),</span> <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">));</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L293" class="LineNr">293 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>is_dummy<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)))</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>
<span id="L294" class="LineNr">294 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>!types_strictly_match_except_literal_against_address_or_boolean<span class="Delimiter">(</span>variant<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">),</span> inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L295" class="LineNr">295 </span>      <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9993</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;match failed: product &quot;</span> &lt;&lt; i &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L296" class="LineNr">296 </span>      <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L297" class="LineNr">297 </span>    <span class="Delimiter">}</span>
<span id="L298" class="LineNr">298 </span>  <span class="Delimiter">}</span>
<span id="L299" class="LineNr">299 </span>  <span class="Identifier">return</span> <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L300" class="LineNr">300 </span><span class="Delimiter">}</span>
<span id="L301" class="LineNr">301 </span>
<span id="L302" class="LineNr">302 </span><span class="Normal">bool</span> <a href='054static_dispatch.cc.html#L302'>types_strictly_match_except_literal_against_address_or_boolean</a><span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; to<span class="Delimiter">,</span> <span class="Normal">const</span> reagent&amp; from<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L303" class="LineNr">303 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>is_literal<span class="Delimiter">(</span>from<span class="Delimiter">)</span> &amp;&amp; <a href='021check_instruction.cc.html#L232'>is_mu_boolean</a><span class="Delimiter">(</span>to<span class="Delimiter">))</span>
<span id="L304" class="LineNr">304 </span>    <span class="Identifier">return</span> from<span class="Delimiter">.</span>name == <span class="Constant">&quot;0&quot;</span> || from<span class="Delimiter">.</span>name == <span class="Constant">&quot;1&quot;</span><span class="Delimiter">;</span>
<span id="L305" class="LineNr">305 </span>  <span class="Comment">// Match Literal Zero Against Address {</span>
<span id="L306" class="LineNr">306 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>is_literal<span class="Delimiter">(</span>from<span class="Delimiter">)</span> &amp;&amp; is_mu_address<span class="Delimiter">(</span>to<span class="Delimiter">))</span>
<span id="L307" class="LineNr">307 </span>    <span class="Identifier">return</span> from<span class="Delimiter">.</span>name == <span class="Constant">&quot;0&quot;</span><span class="Delimiter">;</span>
<span id="L308" class="LineNr">308 </span>  <span class="Comment">// }</span>
<span id="L309" class="LineNr">309 </span>  <span class="Identifier">return</span> types_strictly_match<span class="Delimiter">(</span>to<span class="Delimiter">,</span> from<span class="Delimiter">);</span>
<span id="L310" class="LineNr">310 </span><span class="Delimiter">}</span>
<span id="L311" class="LineNr">311 </span>
<span id="L312" class="LineNr">312 </span><span class="Comment">// phase 4</span>
<span id="L313" class="LineNr">313 </span>vector&lt;recipe_ordinal&gt; <a href='054static_dispatch.cc.html#L313'>matching_variants</a><span class="Delimiter">(</span><span class="Normal">const</span> instruction&amp; inst<span class="Delimiter">,</span> <span class="Normal">const</span> vector&lt;recipe_ordinal&gt;&amp; variants<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L314" class="LineNr">314 </span>  vector&lt;recipe_ordinal&gt; result<span class="Delimiter">;</span>
<span id="L315" class="LineNr">315 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>variants<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L316" class="LineNr">316 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)</span> == -<span class="Constant">1</span><span class="Delimiter">)</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>
<span id="L317" class="LineNr">317 </span>    <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9992</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;checking variant &quot;</span> &lt;&lt; i &lt;&lt; <span class="Constant">&quot;: &quot;</span> &lt;&lt; header_label<span class="Delimiter">(</span>variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">))</span> &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L318" class="LineNr">318 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span><a href='054static_dispatch.cc.html#L324'>all_header_reagents_match</a><span class="Delimiter">(</span>inst<span class="Delimiter">,</span> get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">))))</span>
<span id="L319" class="LineNr">319 </span>      result<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">));</span>
<span id="L320" class="LineNr">320 </span>  <span class="Delimiter">}</span>
<span id="L321" class="LineNr">321 </span>  <span class="Identifier">return</span> result<span class="Delimiter">;</span>
<span id="L322" class="LineNr">322 </span><span class="Delimiter">}</span>
<span id="L323" class="LineNr">323 </span>
<span id="L324" class="LineNr">324 </span><span class="Normal">bool</span> <a href='054static_dispatch.cc.html#L324'>all_header_reagents_match</a><span class="Delimiter">(</span><span class="Normal">const</span> instruction&amp; inst<span class="Delimiter">,</span> <span class="Normal">const</span> recipe&amp; variant<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L325" class="LineNr">325 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; min<span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">),</span> <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>variant<span class="Delimiter">.</span>ingredients<span class="Delimiter">));</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L326" class="LineNr">326 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>!types_match<span class="Delimiter">(</span>variant<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">),</span> inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L327" class="LineNr">327 </span>      <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9993</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;match failed: ingredient &quot;</span> &lt;&lt; i &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L328" class="LineNr">328 </span>      <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L329" class="LineNr">329 </span>    <span class="Delimiter">}</span>
<span id="L330" class="LineNr">330 </span>  <span class="Delimiter">}</span>
<span id="L331" class="LineNr">331 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; min<span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>variant<span class="Delimiter">.</span>products<span class="Delimiter">),</span> <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">));</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L332" class="LineNr">332 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>is_dummy<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)))</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>
<span id="L333" class="LineNr">333 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>!types_match<span class="Delimiter">(</span>variant<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">),</span> inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<span id="L334" class="LineNr">334 </span>      <a href='003trace.cc.html#L167'>trace</a><span class="Delimiter">(</span><span class="Constant">9993</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;match failed: product &quot;</span> &lt;&lt; i &lt;&lt; <a href='003trace.cc.html#L203'>end</a><span class="Delimiter">();</span>
<span id="L335" class="LineNr">335 </span>      <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L336" class="LineNr">336 </span>    <span class="Delimiter">}</span>
<span id="L337" class="LineNr">337 </span>  <span class="Delimiter">}</span>
<span id="L338" class="LineNr">338 </span>  <span class="Identifier">return</span> <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L339" class="LineNr">339 </span><span class="Delimiter">}</span>
<span id="L340" class="LineNr">340 </span>
<span id="L341" class="LineNr">341 </span><span class="Comment">// tie-breaker for each phase</span>
<span id="L342" class="LineNr">342 </span><span class="Normal">const</span> recipe&amp; best_variant<span class="Delimiter">(</span><span class="Normal">const</span> instruction&amp; inst<span class="Delimiter">,</span> vector&lt;recipe_ordinal&gt;&amp; candidates<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L343" class="LineNr">343 </span>  assert<span class="Delimiter">(</span>!candidates<span class="Delimiter">.</span>empty<span class="Delimiter">());</span>
<span id="L344" class="LineNr">344 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>candidates<span class="Delimiter">)</span> == <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Identifier">return</span> get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> candidates<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">));</span>
<span id="L345" class="LineNr">345 </span>  <span class="Normal">int</span> min_score = <span class="Constant">999</span><span class="Delimiter">;</span>
<span id="L346" class="LineNr">346 </span>  <span class="Normal">int</span> min_index = <span class="Constant">0</span><span class="Delimiter">;</span>
<span id="L347" class="LineNr">347 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>candidates<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L348" class="LineNr">348 </span>    <span class="Normal">const</span> recipe&amp; candidate = get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> candidates<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">));</span>
<span id="L349" class="LineNr">349 </span>    <span class="Comment">// prefer variants without extra or missing ingredients or products</span>
<span id="L350" class="LineNr">350 </span>    <span class="Normal">int</span> score = abs<span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>candidate<span class="Delimiter">.</span>products<span class="Delimiter">)</span>-SIZE<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">))</span>
<span id="L351" class="LineNr">351 </span>                          + abs<span class="Delimiter">(</span><a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>candidate<span class="Delimiter">.</span>ingredients<span class="Delimiter">)</span>-SIZE<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">));</span>
<span id="L352" class="LineNr">352 </span>    <span class="Comment">// prefer variants with non-address ingredients or products</span>
<span id="L353" class="LineNr">353 </span>    <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> j = <span class="Constant">0</span><span class="Delimiter">;</span>  j &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>candidate<span class="Delimiter">.</span>ingredients<span class="Delimiter">);</span>  ++j<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L354" class="LineNr">354 </span>      <span class="Normal">if</span> <span class="Delimiter">(</span>is_mu_address<span class="Delimiter">(</span>candidate<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>j<span class="Delimiter">)))</span>
<span id="L355" class="LineNr">355 </span>        ++score<span class="Delimiter">;</span>
<span id="L356" class="LineNr">356 </span>    <span class="Delimiter">}</span>
<span id="L357" class="LineNr">357 </span>    <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> j = <span class="Constant">0</span><span class="Delimiter">;</span>  j &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>candidate<span class="Delimiter">.</span>products<span class="Delimiter">);</span>  ++j<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L358" class="LineNr">358 </span>      <span class="Normal">if</span> <span class="Delimiter">(</span>is_mu_address<span class="Delimiter">(</span>candidate<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>j<span class="Delimiter">)))</span>
<span id="L359" class="LineNr">359 </span>        ++score<span class="Delimiter">;</span>
<span id="L360" class="LineNr">360 </span>    <span class="Delimiter">}</span>
<span id="L361" class="LineNr">361 </span>    assert<span class="Delimiter">(</span>score &lt; <span class="Constant">999</span><span class="Delimiter">);</span>
<span id="L362" class="LineNr">362 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>score &lt; min_score<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L363" class="LineNr">363 </span>      min_score = score<span class="Delimiter">;</span>
<span id="L364" class="LineNr">364 </span>      min_index = i<span class="Delimiter">;</span>
<span id="L365" class="LineNr">365 </span>    <span class="Delimiter">}</span>
<span id="L366" class="LineNr">366 </span>  <span class="Delimiter">}</span>
<span id="L367" class="LineNr">367 </span>  <span class="Identifier">return</span> get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> candidates<span class="Delimiter">.</span>at<span class="Delimiter">(</span>min_index<span class="Delimiter">));</span>
<span id="L368" class="LineNr">368 </span><span class="Delimiter">}</span>
<span id="L369" class="LineNr">369 </span>
<span id="L370" class="LineNr">370 </span><span class="Normal">int</span> <a href='054static_dispatch.cc.html#L370'>non_ghost_size</a><span class="Delimiter">(</span>vector&lt;recipe_ordinal&gt;&amp; variants<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L371" class="LineNr">371 </span>  <span class="Normal">int</span> result = <span class="Constant">0</span><span class="Delimiter">;</span>
<span id="L372" class="LineNr">372 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>variants<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span>
<span id="L373" class="LineNr">373 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>variants<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)</span> != -<span class="Constant">1</span><span class="Delimiter">)</span> ++result<span class="Delimiter">;</span>
<span id="L374" class="LineNr">374 </span>  <span class="Identifier">return</span> result<span class="Delimiter">;</span>
<span id="L375" class="LineNr">375 </span><span class="Delimiter">}</span>
<span id="L376" class="LineNr">376 </span>
<span id="L377" class="LineNr">377 </span><span class="Normal">bool</span> <a href='054static_dispatch.cc.html#L377'>next_stash</a><span class="Delimiter">(</span><span class="Normal">const</span> call&amp; c<span class="Delimiter">,</span> instruction* stash_inst<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L378" class="LineNr">378 </span>  <span class="Normal">const</span> recipe&amp; specializer_recipe = get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> c<span class="Delimiter">.</span>running_recipe<span class="Delimiter">);</span>
<span id="L379" class="LineNr">379 </span>  <span class="Normal">int</span> index = c<span class="Delimiter">.</span>running_step_index<span class="Delimiter">;</span>
<span id="L380" class="LineNr">380 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span>++index<span class="Delimiter">;</span>  index &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>specializer_recipe<span class="Delimiter">.</span>steps<span class="Delimiter">);</span>  ++index<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L381" class="LineNr">381 </span>    <span class="Normal">const</span> instruction&amp; inst = specializer_recipe<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>at<span class="Delimiter">(</span>index<span class="Delimiter">);</span>
<span id="L382" class="LineNr">382 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>name == <span class="Constant">&quot;stash&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L383" class="LineNr">383 </span>      *stash_inst = inst<span class="Delimiter">;</span>
<span id="L384" class="LineNr">384 </span>      <span class="Identifier">return</span> <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L385" class="LineNr">385 </span>    <span class="Delimiter">}</span>
<span id="L386" class="LineNr">386 </span>  <span class="Delimiter">}</span>
<span id="L387" class="LineNr">387 </span>  <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L388" class="LineNr">388 </span><span class="Delimiter">}</span>
<span id="L389" class="LineNr">389 </span>
<span id="L390" class="LineNr">390 </span><span class="Delimiter">:(scenario static_dispatch_disabled_in_recipe_without_variants)</span>
<span id="L391" class="LineNr">391 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L392" class="LineNr">392 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>test <span class="Constant">3</span>
<span id="L393" class="LineNr">393 </span>]
<span id="L394" class="LineNr">394 </span><span class="muRecipe">def</span> test [
<span id="L395" class="LineNr">395 </span>  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>next-ingredient  <span class="Comment"># ensure no header</span>
<span id="L396" class="LineNr">396 </span>  <span class="Identifier">return</span> <span class="Constant">34</span>
<span id="L397" class="LineNr">397 </span>]
<span id="L398" class="LineNr">398 </span><span class="traceContains">+mem: storing 34 in location 1</span>
<span id="L399" class="LineNr">399 </span>
<span id="L400" class="LineNr">400 </span><span class="Delimiter">:(scenario static_dispatch_disabled_on_headerless_definition)</span>
<span id="L401" class="LineNr">401 </span><span class="Special">% Hide_errors = true;</span>
<span id="L402" class="LineNr">402 </span><span class="muRecipe">def</span> test a:num<span class="muRecipe"> -&gt; </span>z:num [
<span id="L403" class="LineNr">403 </span>  z<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
<span id="L404" class="LineNr">404 </span>]
<span id="L405" class="LineNr">405 </span><span class="muRecipe">def</span> test [
<span id="L406" class="LineNr">406 </span>  <span class="Identifier">return</span> <span class="Constant">34</span>
<span id="L407" class="LineNr">407 </span>]
<span id="L408" class="LineNr">408 </span><span class="traceContains">+error: redefining <a href='010vm.cc.html#L19'>recipe</a> test</span>
<span id="L409" class="LineNr">409 </span>
<span id="L410" class="LineNr">410 </span><span class="Delimiter">:(scenario static_dispatch_disabled_on_headerless_definition_2)</span>
<span id="L411" class="LineNr">411 </span><span class="Special">% Hide_errors = true;</span>
<span id="L412" class="LineNr">412 </span><span class="muRecipe">def</span> test [
<span id="L413" class="LineNr">413 </span>  <span class="Identifier">return</span> <span class="Constant">34</span>
<span id="L414" class="LineNr">414 </span>]
<span id="L415" class="LineNr">415 </span><span class="muRecipe">def</span> test a:num<span class="muRecipe"> -&gt; </span>z:num [
<span id="L416" class="LineNr">416 </span>  z<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
<span id="L417" class="LineNr">417 </span>]
<span id="L418" class="LineNr">418 </span><span class="traceContains">+error: redefining <a href='010vm.cc.html#L19'>recipe</a> test</span>
<span id="L419" class="LineNr">419 </span>
<span id="L420" class="LineNr">420 </span><span class="Delimiter">:(scenario static_dispatch_on_primitive_names)</span>
<span id="L421" class="LineNr">421 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L422" class="LineNr">422 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
<span id="L423" class="LineNr">423 </span>  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
<span id="L424" class="LineNr">424 </span>  <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">2</span>:num
<span id="L425" class="LineNr">425 </span>  <span class="Constant">4</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>copy <span class="Constant">0</span>/<span class="Constant">false</span>
<span id="L426" class="LineNr">426 </span>  <span class="Constant">5</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>copy <span class="Constant">0</span>/<span class="Constant">false</span>
<span id="L427" class="LineNr">427 </span>  <span class="Constant">6</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">4</span>:<span class="Normal">bool</span><span class="Delimiter">,</span> <span class="Constant">5</span>:<span class="Normal">bool</span>
<span id="L428" class="LineNr">428 </span>]
<span id="L429" class="LineNr">429 </span><span class="Comment"># temporarily hardcode number equality to always fail</span>
<span id="L430" class="LineNr">430 </span><span class="muRecipe">def</span> equal x:num<span class="Delimiter">,</span> y:num<span class="muRecipe"> -&gt; </span>z:<span class="Normal">bool</span> [
<span id="L431" class="LineNr">431 </span>  local-scope
<span id="L432" class="LineNr">432 </span>  load-ingredients
<span id="L433" class="LineNr">433 </span>  z<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>/<span class="Constant">false</span>
<span id="L434" class="LineNr">434 </span>]
<span id="L435" class="LineNr">435 </span><span class="Comment"># comparing numbers used overload</span>
<span id="L436" class="LineNr">436 </span><span class="traceContains">+mem: storing 0 in location 3</span>
<span id="L437" class="LineNr">437 </span><span class="Comment"># comparing booleans continues to use primitive</span>
<span id="L438" class="LineNr">438 </span><span class="traceContains">+mem: storing 1 in location 6</span>
<span id="L439" class="LineNr">439 </span>
<span id="L440" class="LineNr">440 </span><span class="Delimiter">:(scenario static_dispatch_works_with_dummy_results_for_containers)</span>
<span id="L441" class="LineNr">441 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L442" class="LineNr">442 </span>  _<span class="Special"> &lt;- </span>test <span class="Constant">3</span><span class="Delimiter">,</span> <span class="Constant">4</span>
<span id="L443" class="LineNr">443 </span>]
<span id="L444" class="LineNr">444 </span><span class="muRecipe">def</span> test a:num<span class="muRecipe"> -&gt; </span>z:point [
<span id="L445" class="LineNr">445 </span>  local-scope
<span id="L446" class="LineNr">446 </span>  load-ingredients
<span id="L447" class="LineNr">447 </span>  z<span class="Special"> &lt;- </span>merge a<span class="Delimiter">,</span> <span class="Constant">0</span>
<span id="L448" class="LineNr">448 </span>]
<span id="L449" class="LineNr">449 </span><span class="muRecipe">def</span> test a:num<span class="Delimiter">,</span> b:num<span class="muRecipe"> -&gt; </span>z:point [
<span id="L450" class="LineNr">450 </span>  local-scope
<span id="L451" class="LineNr">451 </span>  load-ingredients
<span id="L452" class="LineNr">452 </span>  z<span class="Special"> &lt;- </span>merge a<span class="Delimiter">,</span> b
<span id="L453" class="LineNr">453 </span>]
<span id="L454" class="LineNr">454 </span>$error: <span class="Constant">0</span>
<span id="L455" class="LineNr">455 </span>
<span id="L456" class="LineNr">456 </span><span class="Delimiter">:(scenario static_dispatch_works_with_compound_type_containing_container_defined_after_first_use)</span>
<span id="L457" class="LineNr">457 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L458" class="LineNr">458 </span>  <span class="Normal">x</span>:&amp;:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo:type</span>
<span id="L459" class="LineNr">459 </span>  test x
<span id="L460" class="LineNr">460 </span>]
<span id="L461" class="LineNr">461 </span><span class="muData">container</span> foo [
<span id="L462" class="LineNr">462 </span>  <span class="Normal">x</span>:num
<span id="L463" class="LineNr">463 </span>]
<span id="L464" class="LineNr">464 </span><span class="muRecipe">def</span> test a:&amp;:foo<span class="muRecipe"> -&gt; </span>z:num [
<span id="L465" class="LineNr">465 </span>  local-scope
<span id="L466" class="LineNr">466 </span>  load-ingredients
<span id="L467" class="LineNr">467 </span>  <span class="Normal">z</span>:num<span class="Special"> &lt;- </span>get *a<span class="Delimiter">,</span> <span class="Constant">x:offset</span>
<span id="L468" class="LineNr">468 </span>]
<span id="L469" class="LineNr">469 </span>$error: <span class="Constant">0</span>
<span id="L470" class="LineNr">470 </span>
<span id="L471" class="LineNr">471 </span><span class="Delimiter">:(scenario static_dispatch_works_with_compound_type_containing_container_defined_after_second_use)</span>
<span id="L472" class="LineNr">472 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L473" class="LineNr">473 </span>  <span class="Normal">x</span>:&amp;:foo<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">foo:type</span>
<span id="L474" class="LineNr">474 </span>  test x
<span id="L475" class="LineNr">475 </span>]
<span id="L476" class="LineNr">476 </span><span class="muRecipe">def</span> test a:&amp;:foo<span class="muRecipe"> -&gt; </span>z:num [
<span id="L477" class="LineNr">477 </span>  local-scope
<span id="L478" class="LineNr">478 </span>  load-ingredients
<span id="L479" class="LineNr">479 </span>  <span class="Normal">z</span>:num<span class="Special"> &lt;- </span>get *a<span class="Delimiter">,</span> <span class="Constant">x:offset</span>
<span id="L480" class="LineNr">480 </span>]
<span id="L481" class="LineNr">481 </span><span class="muData">container</span> foo [
<span id="L482" class="LineNr">482 </span>  <span class="Normal">x</span>:num
<span id="L483" class="LineNr">483 </span>]
<span id="L484" class="LineNr">484 </span>$error: <span class="Constant">0</span>
<span id="L485" class="LineNr">485 </span>
<span id="L486" class="LineNr">486 </span><span class="Delimiter">:(scenario static_dispatch_prefers_literals_to_be_numbers_rather_than_addresses)</span>
<span id="L487" class="LineNr">487 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L488" class="LineNr">488 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>foo <span class="Constant">0</span>
<span id="L489" class="LineNr">489 </span>]
<span id="L490" class="LineNr">490 </span><span class="muRecipe">def</span> foo x:&amp;:num<span class="muRecipe"> -&gt; </span>y:num [
<span id="L491" class="LineNr">491 </span>  <span class="Identifier">return</span> <span class="Constant">34</span>
<span id="L492" class="LineNr">492 </span>]
<span id="L493" class="LineNr">493 </span><span class="muRecipe">def</span> foo x:num<span class="muRecipe"> -&gt; </span>y:num [
<span id="L494" class="LineNr">494 </span>  <span class="Identifier">return</span> <span class="Constant">35</span>
<span id="L495" class="LineNr">495 </span>]
<span id="L496" class="LineNr">496 </span><span class="traceContains">+mem: storing 35 in location 1</span>
<span id="L497" class="LineNr">497 </span>
<span id="L498" class="LineNr">498 </span><span class="Delimiter">:(scenario static_dispatch_prefers_literals_to_be_numbers_rather_than_addresses_2)</span>
<span id="L499" class="LineNr">499 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L500" class="LineNr">500 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>foo <span class="Constant">0</span> <span class="Constant">0</span>
<span id="L501" class="LineNr">501 </span>]
<span id="L502" class="LineNr">502 </span><span class="Comment"># Both variants need to bind 0 to address in first ingredient.</span>
<span id="L503" class="LineNr">503 </span><span class="Comment"># We still want to prefer the variant with a number rather than address for</span>
<span id="L504" class="LineNr">504 </span><span class="Comment"># _subsequent_ ingredients.</span>
<span id="L505" class="LineNr">505 </span><span class="muRecipe">def</span> foo x:&amp;:num y:&amp;:num<span class="muRecipe"> -&gt; </span>z:num [  <span class="Comment"># put the bad match before the good one</span>
<span id="L506" class="LineNr">506 </span>  <span class="Identifier">return</span> <span class="Constant">34</span>
<span id="L507" class="LineNr">507 </span>]
<span id="L508" class="LineNr">508 </span><span class="muRecipe">def</span> foo x:&amp;:num y:num<span class="muRecipe"> -&gt; </span>z:num [
<span id="L509" class="LineNr">509 </span>  <span class="Identifier">return</span> <span class="Constant">35</span>
<span id="L510" class="LineNr">510 </span>]
<span id="L511" class="LineNr">511 </span><span class="traceContains">+mem: storing 35 in location 1</span>
<span id="L512" class="LineNr">512 </span>
<span id="L513" class="LineNr">513 </span><span class="Delimiter">:(scenario static_dispatch_on_non_literal_character_ignores_variant_with_numbers)</span>
<span id="L514" class="LineNr">514 </span><span class="Special">% Hide_errors = true;</span>
<span id="L515" class="LineNr">515 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L516" class="LineNr">516 </span>  local-scope
<span id="L517" class="LineNr">517 </span>  <span class="Normal">x</span>:<span class="Normal">char</span><span class="Special"> &lt;- </span>copy <span class="Constant">10</span>/newline
<span id="L518" class="LineNr">518 </span>  <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>foo x
<span id="L519" class="LineNr">519 </span>]
<span id="L520" class="LineNr">520 </span><span class="muRecipe">def</span> foo x:num<span class="muRecipe"> -&gt; </span>y:num [
<span id="L521" class="LineNr">521 </span>  load-ingredients
<span id="L522" class="LineNr">522 </span>  <span class="Identifier">return</span> <span class="Constant">34</span>
<span id="L523" class="LineNr">523 </span>]
<span id="L524" class="LineNr">524 </span><span class="traceContains">+error: <a href='000organization.cc.html#L113'>main</a>: ingredient 0 has the wrong type at '1:num/raw &lt;- foo x'</span>
<span id="L525" class="LineNr">525 </span><span class="traceAbsent">-mem: storing 34 in location 1</span>
<span id="L526" class="LineNr">526 </span>
<span id="L527" class="LineNr">527 </span><span class="Delimiter">:(scenario static_dispatch_dispatches_literal_to_boolean_before_character)</span>
<span id="L528" class="LineNr">528 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L529" class="LineNr">529 </span>  <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>foo <span class="Constant">0</span>  <span class="Comment"># valid literal for boolean</span>
<span id="L530" class="LineNr">530 </span>]
<span id="L531" class="LineNr">531 </span><span class="muRecipe">def</span> foo x:<span class="Normal">char</span><span class="muRecipe"> -&gt; </span>y:num [
<span id="L532" class="LineNr">532 </span>  local-scope
<span id="L533" class="LineNr">533 </span>  load-ingredients
<span id="L534" class="LineNr">534 </span>  <span class="Identifier">return</span> <span class="Constant">34</span>
<span id="L535" class="LineNr">535 </span>]
<span id="L536" class="LineNr">536 </span><span class="muRecipe">def</span> foo x:<span class="Normal">bool</span><span class="muRecipe"> -&gt; </span>y:num [
<span id="L537" class="LineNr">537 </span>  local-scope
<span id="L538" class="LineNr">538 </span>  load-ingredients
<span id="L539" class="LineNr">539 </span>  <span class="Identifier">return</span> <span class="Constant">35</span>
<span id="L540" class="LineNr">540 </span>]
<span id="L541" class="LineNr">541 </span><span class="Comment"># boolean variant is preferred</span>
<span id="L542" class="LineNr">542 </span><span class="traceContains">+mem: storing 35 in location 1</span>
<span id="L543" class="LineNr">543 </span>
<span id="L544" class="LineNr">544 </span><span class="Delimiter">:(scenario static_dispatch_dispatches_literal_to_character_when_out_of_boolean_range)</span>
<span id="L545" class="LineNr">545 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L546" class="LineNr">546 </span>  <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>foo <span class="Constant">97</span>  <span class="Comment"># not a valid literal for boolean</span>
<span id="L547" class="LineNr">547 </span>]
<span id="L548" class="LineNr">548 </span><span class="muRecipe">def</span> foo x:<span class="Normal">char</span><span class="muRecipe"> -&gt; </span>y:num [
<span id="L549" class="LineNr">549 </span>  local-scope
<span id="L550" class="LineNr">550 </span>  load-ingredients
<span id="L551" class="LineNr">551 </span>  <span class="Identifier">return</span> <span class="Constant">34</span>
<span id="L552" class="LineNr">552 </span>]
<span id="L553" class="LineNr">553 </span><span class="muRecipe">def</span> foo x:<span class="Normal">bool</span><span class="muRecipe"> -&gt; </span>y:num [
<span id="L554" class="LineNr">554 </span>  local-scope
<span id="L555" class="LineNr">555 </span>  load-ingredients
<span id="L556" class="LineNr">556 </span>  <span class="Identifier">return</span> <span class="Constant">35</span>
<span id="L557" class="LineNr">557 </span>]
<span id="L558" class="LineNr">558 </span><span class="Comment"># character variant is preferred</span>
<span id="L559" class="LineNr">559 </span><span class="traceContains">+mem: storing 34 in location 1</span>
<span id="L560" class="LineNr">560 </span>
<span id="L561" class="LineNr">561 </span><span class="Delimiter">:(scenario static_dispatch_dispatches_literal_to_number_if_at_all_possible)</span>
<span id="L562" class="LineNr">562 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L563" class="LineNr">563 </span>  <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>foo <span class="Constant">97</span>
<span id="L564" class="LineNr">564 </span>]
<span id="L565" class="LineNr">565 </span><span class="muRecipe">def</span> foo x:<span class="Normal">char</span><span class="muRecipe"> -&gt; </span>y:num [
<span id="L566" class="LineNr">566 </span>  local-scope
<span id="L567" class="LineNr">567 </span>  load-ingredients
<span id="L568" class="LineNr">568 </span>  <span class="Identifier">return</span> <span class="Constant">34</span>
<span id="L569" class="LineNr">569 </span>]
<span id="L570" class="LineNr">570 </span><span class="muRecipe">def</span> foo x:num<span class="muRecipe"> -&gt; </span>y:num [
<span id="L571" class="LineNr">571 </span>  local-scope
<span id="L572" class="LineNr">572 </span>  load-ingredients
<span id="L573" class="LineNr">573 </span>  <span class="Identifier">return</span> <span class="Constant">35</span>
<span id="L574" class="LineNr">574 </span>]
<span id="L575" class="LineNr">575 </span><span class="Comment"># number variant is preferred</span>
<span id="L576" class="LineNr">576 </span><span class="traceContains">+mem: storing 35 in location 1</span>
<span id="L577" class="LineNr">577 </span>
<span id="L578" class="LineNr">578 </span><span class="Delimiter">:(replace{} &quot;string header_label(const <a href='010vm.cc.html#L14'>recipe_ordinal</a> r)&quot;)</span>
<span id="L579" class="LineNr">579 </span>string header_label<span class="Delimiter">(</span><span class="Normal">const</span> <a href='010vm.cc.html#L14'>recipe_ordinal</a> r<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L580" class="LineNr">580 </span>  <span class="Identifier">return</span> header_label<span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">));</span>
<span id="L581" class="LineNr">581 </span><span class="Delimiter">}</span>
<span id="L582" class="LineNr">582 </span><span class="Delimiter">:(code)</span>
<span id="L583" class="LineNr">583 </span>string header_label<span class="Delimiter">(</span><span class="Normal">const</span> recipe&amp; caller<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L584" class="LineNr">584 </span>  ostringstream out<span class="Delimiter">;</span>
<span id="L585" class="LineNr">585 </span>  out &lt;&lt; <span class="Constant">&quot;recipe &quot;</span> &lt;&lt; caller<span class="Delimiter">.</span>name<span class="Delimiter">;</span>
<span id="L586" class="LineNr">586 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>caller<span class="Delimiter">.</span>ingredients<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span>
<span id="L587" class="LineNr">587 </span>    out &lt;&lt; <span class="Constant">' '</span> &lt;&lt; <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span>caller<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">));</span>
<span id="L588" class="LineNr">588 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!caller<span class="Delimiter">.</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> out &lt;&lt; <span class="Constant">&quot; -&gt;&quot;</span><span class="Delimiter">;</span>
<span id="L589" class="LineNr">589 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>caller<span class="Delimiter">.</span>products<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span>
<span id="L590" class="LineNr">590 </span>    out &lt;&lt; <span class="Constant">' '</span> &lt;&lt; <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span>caller<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">));</span>
<span id="L591" class="LineNr">591 </span>  <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span>
<span id="L592" class="LineNr">592 </span><span class="Delimiter">}</span>
<span id="L593" class="LineNr">593 </span>
<span id="L594" class="LineNr">594 </span>string <a href='054static_dispatch.cc.html#L594'>original_header_label</a><span class="Delimiter">(</span><span class="Normal">const</span> recipe&amp; caller<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L595" class="LineNr">595 </span>  ostringstream out<span class="Delimiter">;</span>
<span id="L596" class="LineNr">596 </span>  out &lt;&lt; <span class="Constant">&quot;recipe &quot;</span> &lt;&lt; caller<span class="Delimiter">.</span>original_name<span class="Delimiter">;</span>
<span id="L597" class="LineNr">597 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>caller<span class="Delimiter">.</span>ingredients<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span>
<span id="L598" class="LineNr">598 </span>    out &lt;&lt; <span class="Constant">' '</span> &lt;&lt; caller<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>original_string<span class="Delimiter">;</span>
<span id="L599" class="LineNr">599 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!caller<span class="Delimiter">.</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> out &lt;&lt; <span class="Constant">&quot; -&gt;&quot;</span><span class="Delimiter">;</span>
<span id="L600" class="LineNr">600 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>caller<span class="Delimiter">.</span>products<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span>
<span id="L601" class="LineNr">601 </span>    out &lt;&lt; <span class="Constant">' '</span> &lt;&lt; caller<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>original_string<span class="Delimiter">;</span>
<span id="L602" class="LineNr">602 </span>  <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span>
<span id="L603" class="LineNr">603 </span><span class="Delimiter">}</span>
<span id="L604" class="LineNr">604 </span>
<span id="L605" class="LineNr">605 </span><span class="Delimiter">:(scenario reload_variant_retains_other_variants)</span>
<span id="L606" class="LineNr">606 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L607" class="LineNr">607 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
<span id="L608" class="LineNr">608 </span>  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>foo <span class="Constant">1</span>:num
<span id="L609" class="LineNr">609 </span>]
<span id="L610" class="LineNr">610 </span><span class="muRecipe">def</span> foo x:num<span class="muRecipe"> -&gt; </span>y:num [
<span id="L611" class="LineNr">611 </span>  local-scope
<span id="L612" class="LineNr">612 </span>  load-ingredients
<span id="L613" class="LineNr">613 </span>  <span class="Identifier">return</span> <span class="Constant">34</span>
<span id="L614" class="LineNr">614 </span>]
<span id="L615" class="LineNr">615 </span><span class="muRecipe">def</span> foo x:&amp;:num<span class="muRecipe"> -&gt; </span>y:num [
<span id="L616" class="LineNr">616 </span>  local-scope
<span id="L617" class="LineNr">617 </span>  load-ingredients
<span id="L618" class="LineNr">618 </span>  <span class="Identifier">return</span> <span class="Constant">35</span>
<span id="L619" class="LineNr">619 </span>]
<span id="L620" class="LineNr">620 </span><span class="muRecipe">def</span>! foo x:&amp;:num<span class="muRecipe"> -&gt; </span>y:num [
<span id="L621" class="LineNr">621 </span>  local-scope
<span id="L622" class="LineNr">622 </span>  load-ingredients
<span id="L623" class="LineNr">623 </span>  <span class="Identifier">return</span> <span class="Constant">36</span>
<span id="L624" class="LineNr">624 </span>]
<span id="L625" class="LineNr">625 </span><span class="traceContains">+mem: storing 34 in location 2</span>
<span id="L626" class="LineNr">626 </span>$error: <span class="Constant">0</span>
<span id="L627" class="LineNr">627 </span>
<span id="L628" class="LineNr">628 </span><span class="Delimiter">:(scenario dispatch_errors_come_after_unknown_name_errors)</span>
<span id="L629" class="LineNr">629 </span><span class="Special">% Hide_errors = true;</span>
<span id="L630" class="LineNr">630 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L631" class="LineNr">631 </span>  <span class="Normal">y</span>:num<span class="Special"> &lt;- </span>foo x
<span id="L632" class="LineNr">632 </span>]
<span id="L633" class="LineNr">633 </span><span class="muRecipe">def</span> foo a:num<span class="muRecipe"> -&gt; </span>b:num [
<span id="L634" class="LineNr">634 </span>  local-scope
<span id="L635" class="LineNr">635 </span>  load-ingredients
<span id="L636" class="LineNr">636 </span>  <span class="Identifier">return</span> <span class="Constant">34</span>
<span id="L637" class="LineNr">637 </span>]
<span id="L638" class="LineNr">638 </span><span class="muRecipe">def</span> foo a:<span class="Normal">bool</span><span class="muRecipe"> -&gt; </span>b:num [
<span id="L639" class="LineNr">639 </span>  local-scope
<span id="L640" class="LineNr">640 </span>  load-ingredients
<span id="L641" class="LineNr">641 </span>  <span class="Identifier">return</span> <span class="Constant">35</span>
<span id="L642" class="LineNr">642 </span>]
<span id="L643" class="LineNr">643 </span><span class="traceContains">+error: <a href='000organization.cc.html#L113'>main</a>: missing type for 'x' in 'y:num &lt;- foo x'</span>
<span id="L644" class="LineNr">644 </span><span class="traceContains">+error: <a href='000organization.cc.html#L113'>main</a>: failed to find a matching call for 'y:num &lt;- foo x'</span>
<span id="L645" class="LineNr">645 </span>
<span id="L646" class="LineNr">646 </span><span class="Delimiter">:(scenario override_methods_with_type_abbreviations)</span>
<span id="L647" class="LineNr">647 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L648" class="LineNr">648 </span>  local-scope
<span id="L649" class="LineNr">649 </span>  <span class="Normal">s</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [abc]
<span id="L650" class="LineNr">650 </span>  <span class="Constant">1</span>:num/<span class="Special">raw &lt;- </span>foo s
<span id="L651" class="LineNr">651 </span>]
<span id="L652" class="LineNr">652 </span><span class="muRecipe">def</span> foo a:<a href='043space.cc.html#L80'>address</a>:array:character<span class="muRecipe"> -&gt; </span>result:number [
<span id="L653" class="LineNr">653 </span>  <span class="Identifier">return</span> <span class="Constant">34</span>
<span id="L654" class="LineNr">654 </span>]
<span id="L655" class="LineNr">655 </span><span class="Comment"># identical to previous variant once you take type abbreviations into account</span>
<span id="L656" class="LineNr">656 </span><span class="muRecipe">def</span>! foo a:text<span class="muRecipe"> -&gt; </span>result:num [
<span id="L657" class="LineNr">657 </span>  <span class="Identifier">return</span> <span class="Constant">35</span>
<span id="L658" class="LineNr">658 </span>]
<span id="L659" class="LineNr">659 </span><span class="traceContains">+mem: storing 35 in location 1</span>
<span id="L660" class="LineNr">660 </span>
<span id="L661" class="LineNr">661 </span><span class="Delimiter">:(scenario ignore_static_dispatch_in_type_errors_without_overloading)</span>
<span id="L662" class="LineNr">662 </span><span class="Special">% Hide_errors = true;</span>
<span id="L663" class="LineNr">663 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L664" class="LineNr">664 </span>  local-scope
<span id="L665" class="LineNr">665 </span>  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<span id="L666" class="LineNr">666 </span>  foo x
<span id="L667" class="LineNr">667 </span>]
<span id="L668" class="LineNr">668 </span><span class="muRecipe">def</span> foo x:&amp;:<span class="Normal">char</span> [
<span id="L669" class="LineNr">669 </span>  local-scope
<span id="L670" class="LineNr">670 </span>  load-ingredients
<span id="L671" class="LineNr">671 </span>]
<span id="L672" class="LineNr">672 </span><span class="traceContains">+error: <a href='000organization.cc.html#L113'>main</a>: types don't match in call for 'foo x'</span>
<span id="L673" class="LineNr">673 </span><span class="traceContains">+error:   which tries to call 'recipe foo x:&amp;:char'</span>
<span id="L674" class="LineNr">674 </span>
<span id="L675" class="LineNr">675 </span><span class="Delimiter">:(scenario show_available_variants_in_dispatch_errors)</span>
<span id="L676" class="LineNr">676 </span><span class="Special">% Hide_errors = true;</span>
<span id="L677" class="LineNr">677 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L678" class="LineNr">678 </span>  local-scope
<span id="L679" class="LineNr">679 </span>  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<span id="L680" class="LineNr">680 </span>  foo x
<span id="L681" class="LineNr">681 </span>]
<span id="L682" class="LineNr">682 </span><span class="muRecipe">def</span> foo x:&amp;:<span class="Normal">char</span> [
<span id="L683" class="LineNr">683 </span>  local-scope
<span id="L684" class="LineNr">684 </span>  load-ingredients
<span id="L685" class="LineNr">685 </span>]
<span id="L686" class="LineNr">686 </span><span class="muRecipe">def</span> foo x:&amp;:<span class="Normal">bool</span> [
<span id="L687" class="LineNr">687 </span>  local-scope
<span id="L688" class="LineNr">688 </span>  load-ingredients
<span id="L689" class="LineNr">689 </span>]
<span id="L690" class="LineNr">690 </span><span class="traceContains">+error: <a href='000organization.cc.html#L113'>main</a>: failed to find a matching call for 'foo x'</span>
<span id="L691" class="LineNr">691 </span><span class="traceContains">+error:   available variants are:</span>
<span id="L692" class="LineNr">692 </span><span class="traceContains">+error:     <a href='010vm.cc.html#L19'>recipe</a> foo x:&amp;:char</span>
<span id="L693" class="LineNr">693 </span><span class="traceContains">+error:     <a href='010vm.cc.html#L19'>recipe</a> foo x:&amp;:bool</span>
<span id="L694" class="LineNr">694 </span>
<span id="L695" class="LineNr">695 </span><span class="Delimiter">:(before &quot;End Includes&quot;)</span>
<span id="L696" class="LineNr">696 </span><span class="Normal">using</span> std::abs<span class="Delimiter">;</span>
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->