During a method lookup, Rust automatically derefences and borrows the receiver\nin a well-defined order until it finds the first function with a suitable\nsignature. What is that order?
\n", "explanation": "The Reference describes Rust's method lookup order. The relevant\nparagraph is:
\n\n\nObtain [the candidate receiver type] by repeatedly dereferencing the receiver\nexpression's type, adding each type encountered to the list, then finally\nattempting an unsized coercion at the end, and adding the result type if that\nis successful. Then, for each candidate
\nT, add&Tand&mut Tto the\nlist immediately afterT.
Applying these rules to the given examples, we have:
\nt.f(): We try to find a function f defined on the type T, but there is\nnone. Next, we search the type &T, and find the first implemenation of the\nOr trait, and we are done. Upon invocation, the resolved call prints 1.wt.f(): We search for a function f defined on &T, which immediately\nsucceeds. Upon invocation, the function prints 1.wwt.f(): The search order is &&T -> &&&T -> &mut &&T -> &T, and\nwe're done. Upon invocation, the function prints 1.wwwt.f(): &&&T -> &&&&T. This prints 2.wwwwt.f(): &&&&T. This prints 2.wwwwwt.f(): &&&&&T -> &&&&&&T -> &mut &&&&&T -> &&&&T. This prints\n2.Either way would be confusing in different situations; there isn't a clear right\nbehavior that a hint could help identify. Guess both. :/
\n", + "explanation": "This question covers two behaviors of match arms and guards.
First, whether an if guard on a match-arm containing | applies to all\nalternatives in the match-arm or just to the one it is adjacent to. In the quiz\ncode, does check(x) execute at all for (x, _) or does it only cover the (_, x) case? We would expect 1 would get printed if and only if the latter is the\ncase. In fact 1 does get printed. A match-arm gets to have at most one if\nguard and that guard applies to all the |-separated alternatives in the arm.
But second, this question also covers a kind of "backtracking" behavior of\nmatch-arms. After check(x) returns false on (x, _), does the whole match-arm\nfail to match at that point or does Rust move on to (_, x) and execute the\nguard a second time? We would expect 2 to be printed if and only if the latter\nis the case. In fact 2 does get printed; the guard is being run multiple\ntimes, once per |-separated alternative in the match-arm.