`traverse_inorder` example in `ControlFlow` compiles, but can't be called

[scottmcm]

Found by Inky-developer in https://users.rust-lang.org/t/how-to-use-documentation-example-for-std-controlflow/66115?u=scottmcm

The example compiles, but can't actually be monomorphized as it adds another &mut at each level of the recursion.

It needs a fix like https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=0b534dc88883f0ebd67774f56a857da2

(And it'd probably be good to show a call in the example anyway.)

[yanok]

@rustbot claim

[yanok]

I made a PR but I have some questions.

First of all, how reasonable is to use FnMut for this example? I think it's a bit counter intuitive that one needs to pass a closure that just prints some elements by mutable reference. Of course, on a second thought, it's a closure that can potentially mutate captured variables, so it must be mutable reference. But then we should have an example with a closure that actually uses this possibility, otherwise it's a bit confusing. But on the other hand, our main goal here is to show the ControlFlow usage, so we probably don't want to over-complicate the rest. So I decided to use Fn trait in my PR.

Then, I'm just curious why the original code compiles. I understand Rust requires monomorphic usage, so it does this check at the call site. But this specific example looks like it can never be monomorphised, so probably it makes sense for the compiler to reject it, even if it is never used. Or am I missing something?

[scottmcm]

(I left some comments on the PR.)

But this specific example looks like it can never be monomorphised, so probably it makes sense for the compiler to reject it, even if it is never used. Or am I missing something?

I agree that it couldn't ever work, because of the heterogeneous recursion. But the pre-monomorphization check is just that all the values meet the trait bounds, which they do in this case as &mut impl FnMut : impl FnMut.

It's an interesting question whether it's something that could feasibly be checked pre-monomorphization. For direct recursion maybe it could, though for indirect recursion I suspect it'd be pretty hard.