How do I avoid obfuscating logic in a `loop`?

Question

Trying to respect Rust safety rules leads me to write code that is, in this case, less clear than the alternative.

It's marginal, but must be a very common pattern, so I wonder if there's any better way.

The following example doesn't compile:

async fn query_all_items() -> Vec<u32> {
    let mut items = vec![];
    let limit = 10;

    loop {
        let response = getResponse().await;

        // response is moved here
        items.extend(response);

        // can't do this, response is moved above
        if response.len() < limit {
            break;
        }
    }

    items
}

In order to satisfy Rust safety rules, we can pre-compute the break condition:

async fn query_all_items() -> Vec<u32> {
    let mut items = vec![];
    let limit = 10;

    loop {
        let response = getResponse().await;

        let should_break = response.len() < limit;

        // response is moved here
        items.extend(response);

        // meh
        if should_break {
            break;
        }
    }

    items
}

Is there any other way?

Answer 1

I agree with Daniel's point that this should be a while rather than a loop, though I'd move the logic to the while rather than creating a boolean:

let mut len = limit;
while len >= limit {
    let response = queryItems(limit).await?;

    len = response.len();

    items.extend(response);
}