Challenge 2: calculate Without the ? Operator — Possible Solution
====================================================================

fn calculate(a: f64, b: f64, c: f64) -> Result<f64, String> {
    let step1 = match divide(a, b) {
        Ok(value) => value,
        Err(e) => return Err(e),
    };

    let step2 = match divide(step1, c) {
        Ok(value) => value,
        Err(e) => return Err(e),
    };

    Ok(step2)
}

WHY THIS WORKS AS AN ANSWER
------------------------------
Each divide(...) call now needs its own explicit match: on Ok, the
value is extracted and execution continues; on Err, the SAME error is
returned immediately from calculate via return Err(e) — precisely
replicating what the single ? operator did automatically in the
original version.

COMPARISON: the ?-based version was 3 lines (two ? calls plus a final
Ok), while this explicit version is closer to 10 lines just to express
the identical propagation logic — every additional Result-returning
call in a longer chain would repeat this same 4-line match block again.
This makes concrete exactly what this chapter's Go comparison claimed:
? is a highly concise expression of the exact same "check and
propagate" idea Go's repeated if err != nil { return err } represents,
not a fundamentally different concept — just dramatically less
boilerplate to express it, especially as the number of chained
fallible calls grows.