Program with multiple ampersand works fine [duplicate]

Answer 1

Because the compiler automatically dereference the chain of references you can mentally think that it insert as many * as necessary to get the right type:

foo(&&&f)

is converted to:

foo(*&*&*&f)

that leads to the right invocation:

foo(f)

The insertions of as many * as needed is actually performed by this blanket implementation of Deref trait:

impl<'a, T: ?Sized> Deref for &'a T {
    type Target = T;

    fn deref(&self) -> &T { *self }
}

Note: I've update my answer because in the original I used the term autoderef in the wrong way, see this post for details.

Answer 2

From the Rust book:

Deref coercion is a convenience that Rust performs on arguments to functions and methods. Deref coercion converts a reference to a type that implements Deref into a reference to a type that Deref can convert the original type into. Deref coercion happens automatically when we pass a reference to a particular type’s value as an argument to a function or method that doesn’t match the parameter type in the function or method definition. A sequence of calls to the deref method converts the type we provided into the type the parameter needs.

So basically, in function arguments the compiler will automatically remove any & written or implied until it gets to a type that can be passed to the function.