Weak Goldbach Conjecture in Rust
Pass by value
There is little point passing integrals by reference:

They are Copy, meaning that they can be copied implicitly, so there is no usability penalty to having the caller by pass value,
They are cheap to copy, so there is no performance penalty either. Actually... it may actually perform better.

It's cheaper and easier so pass by value!
This will get rid for the weird &amp;(first_prime + second_prime + third_prime) == input thing.
Expression oriented language
Rust is an expression oriented language. In short, it means that practically everything is an expression.
Notably, a block {} is an expression which evaluates to the value of its last expression (or () if its ends with a statement).
Therefore, the body of a function is an expression, you can simple use None at the end instead of return None;.
Avoid recomputing primes over and over
At the moment, the complexity of your program is horrendous because you keep recomputing the primes over and over. This is unnecessary.
Instead, you can compute the primes up until input once, and then filter those primes.
First Draft
Applying the two above strategies already cleans up the code quite a bit:
fn get_goldbach_solution(input: usize) -&gt; Option&lt;[usize; 3]&gt; {
    let primes = list_primes_until(input);

    for &amp;first_prime in &amp;primes {
        let remainder = input - first_prime;

        for &amp;second_prime in primes.iter().take_while(|p| **p &lt; remainder) {
            let remainder = remainder - second_prime;

            for &amp;third_prime in primes.iter().take_while(|p| **p &lt;= remainder) {
                if third_prime == remainder {
                    return Some([first_prime, second_prime, third_prime]);
                }
            }
        }
    }

    None
}

The last step however is not, in terms of algorithmic complexity, as efficient as it could be. We are iterating over primes until finding one which equals remainder. Since primes is sorted, a simple binary_search would be more algorithmically palatable; although in practice, for small numbers, linear iteration might be faster.
Result
fn get_goldbach_solution(input: usize) -&gt; Option&lt;[usize; 3]&gt; {
    let primes = list_primes_until(input);

    for &amp;first_prime in &amp;primes {
        let remainder = input - first_prime;

        for &amp;second_prime in primes.iter().take_while(|p| **p &lt; remainder) {
            let third_candidate = remainder - second_prime;

            if let Ok(_) = primes.binary_search(&amp;third_candidate) {
                return Some([first_prime, second_prime, third_candidate]);
            }
        }
    }

    None
}

It might be more efficient to start from the highest primes, as it reduces the size of the list to iterate further.
I'm not quite sure about it; you can test it using .rev() on the iterators to reverse them.