rs-03-rpn

# Evaluate RPN

Implement the library file **`src/lib.rs`** exposing:

```rust
pub fn eval_rpn(tokens: &[&str]) -> Result<f64, String>
```

Evaluate a [Reverse Polish Notation](https://en.wikipedia.org/wiki/Reverse_Polish_notation)
expression given as a slice of tokens. Each token is either:

- a number that parses as `f64`, or
- one of the four binary operators `+`, `-`, `*`, `/`.

Evaluation uses a stack: push numbers; for an operator, pop the top two values
`b` (top) then `a` (next) and push the result of `a OP b`. After consuming all
tokens, exactly one value must remain — that value is the result.

Return `Ok(value)` on success, or `Err(message)` (any non-empty message) on
malformed input:

- **too few operands** — an operator with fewer than two values on the stack.
- **leftover operands** — more than one value remains after all tokens consumed
  (or zero tokens / empty input, which leaves no value).
- **unknown token** — a token that is neither a valid `f64` nor a known operator.
- **division by zero** — a `/` whose right operand `b` is `0.0`.

Note: operator order matters for non-commutative operators. For `["3", "4", "-"]`
the result is `3 - 4 = -1.0`, and for `["8", "2", "/"]` it is `8 / 2 = 4.0`.

Examples:

- `eval_rpn(&["2", "3", "+"])` → `Ok(5.0)`
- `eval_rpn(&["5", "1", "2", "+", "4", "*", "+", "3", "-"])` → `Ok(14.0)` (precedence-via-RPN)
- `eval_rpn(&["3", "4", "-"])` → `Ok(-1.0)`
- `eval_rpn(&["1", "+"])` → `Err(..)` (too few operands)
- `eval_rpn(&["1", "2"])` → `Err(..)` (leftover operands)
- `eval_rpn(&["1", "foo", "+"])` → `Err(..)` (unknown token)
- `eval_rpn(&["1", "0", "/"])` → `Err(..)` (division by zero)

Use only the standard library. Tests live in `tests/` and call it as
`challenge::eval_rpn`.

use challenge::eval_rpn;

#[test]
fn basic_eval() {
    assert_eq!(eval_rpn(&["2", "3", "+"]), Ok(5.0));
    assert_eq!(eval_rpn(&["8", "2", "/"]), Ok(4.0));
    assert_eq!(eval_rpn(&["42"]), Ok(42.0));
}

#[test]
fn operator_order_matters() {
    assert_eq!(eval_rpn(&["3", "4", "-"]), Ok(-1.0));
    assert_eq!(eval_rpn(&["10", "4", "-"]), Ok(6.0));
}

#[test]
fn precedence_via_rpn() {
    // (1 + 2) * 4 + 5 - 3  =  14
    assert_eq!(
        eval_rpn(&["5", "1", "2", "+", "4", "*", "+", "3", "-"]),
        Ok(14.0)
    );
}

#[test]
fn err_too_few_operands() {
    assert!(eval_rpn(&["1", "+"]).is_err());
    assert!(eval_rpn(&["+"]).is_err());
}

#[test]
fn err_leftover_operands() {
    assert!(eval_rpn(&["1", "2"]).is_err());
    assert!(eval_rpn(&["1", "2", "3", "+"]).is_err());
}

#[test]
fn err_empty_input() {
    assert!(eval_rpn(&[]).is_err());
}

#[test]
fn err_unknown_token() {
    assert!(eval_rpn(&["1", "foo", "+"]).is_err());
    assert!(eval_rpn(&["1", "2", "%"]).is_err());
}

#[test]
fn err_division_by_zero() {
    assert!(eval_rpn(&["1", "0", "/"]).is_err());
}

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

```rust
pub fn eval_rpn(tokens: &[&str]) -> Result<f64, String> {
    let mut stack: Vec<f64> = Vec::new();

    for token in tokens {
        match *token {
            "+" | "-" | "*" | "/" => {
                if stack.len() < 2 {
                    return Err("too few operands".to_string());
                }
                
                let b = stack.pop().unwrap();
                let a = stack.pop().unwrap();
                
                let result = match token {
                    "+" => a + b,
                    "-" => a - b,
                    "*" => a * b,
                    "/" => {
                        if b == 0.0 {
                            return Err("division by zero".to_string());
                        }
                        a / b
                    }
                    _ => unreachable!(),
                };
                
                stack.push(result);
            }
            _ => {
                // Try to parse as f64
                match token.parse::<f64>() {
                    Ok(num) => stack.push(num),
                    Err(_) => return Err(format!("unknown token: {}", token)),
                }
            }
        }
    }

    if stack.len() != 1 {
        return Err("leftover operands".to_string());
    }

    Ok(stack[0])
}
```

[
  {
    "total": 1,
    "answer": "```rust\npub fn eval_rpn(tokens: &[&str]) -> Result<f64, String> {\n    let mut stack: Vec<f64> = Vec::new();\n\n    for token in tokens {\n        match *token {\n            \"+\" | \"-\" | \"*\" | \"/\" => {\n                if stack.len() < 2 {\n                    return Err(\"too few operands\".to_string());\n                }\n                \n                let b = stack.pop().unwrap();\n                let a = stack.pop().unwrap();\n                \n                let result = match token {\n                    \"+\" => a + b,\n                    \"-\" => a - b,\n                    \"*\" => a * b,\n                    \"/\" => {\n                        if b == 0.0 {\n                            return Err(\"division by zero\".to_string());\n                        }\n                        a / b\n                    }\n                    _ => unreachable!(),\n                };\n                \n                stack.push(result);\n            }\n            _ => {\n                // Try to parse as f64\n                match token.parse::<f64>() {\n                    Ok(num) => stack.push(num),\n                    Err(_) => return Err(format!(\"unknown token: {}\", token)),\n                }\n            }\n        }\n    }\n\n    if stack.len() != 1 {\n        return Err(\"leftover operands\".to_string());\n    }\n\n    Ok(stack[0])\n}\n```",
    "passed": 0,
    "test_error": "error[E0308]: mismatched types\n  --> src/lib.rs:15:21\n   |\n14 |                 let result = match token {\n   |                                    ----- this expression has type `&&str`\n15 |                     \"+\" => a + b,\n   |                     ^^^ expected `&&str`, found `&str`\n   |\n   = note: expected reference `&&_`\n              found reference `&'static _`\nhelp: consider dereferencing to access the inner value using the `Deref` trait\n   |\n14 |                 let result = match *token {\n   |                                    +\n\nerror[E0308]: mismatched types\n  --> src/lib.rs:16:21\n   |\n14 |                 let result = match token {\n   |                                    ----- this expression has type `&&str`\n15 |                     \"+\" => a + b,\n16 |                     \"-\" => a - b,\n   |                     ^^^ expected `&&str`, found `&str`\n   |\n   = note: expected reference `&&_`\n              found reference `&'static _`\nhelp: consider dereferencing to access the inner value using the `Deref` trait\n   |\n14 |                 let result = match *token {\n   |                                    +\n\nerror[E0308]: mismatched types\n  --> src/lib.rs:17:21\n   |\n14 |                 let result = match token {\n   |                                    ----- this expression has type `&&str`\n...\n17 |                     \"*\" => a * b,\n   |                     ^^^ expected `&&str`, found `&str`\n   |\n   = note: expected reference `&&_`\n              found reference `&'static _`\nhelp: consider dereferencing to access the inner value using the `Deref` trait\n   |\n14 |                 let result = match *token {\n   |                                    +\n\nerror[E0308]: mismatched types\n  --> src/lib.rs:18:21\n   |\n14 |                 let result = match token {\n   |                                    ----- this expression has type `&&str`\n...\n18 |                     \"/\" => {\n   |                     ^^^ expected `&&str`, found `&str`\n   |\n   = note: expected reference `&&_`\n              found reference `&'static _`\nhelp: consider dereferencing to access the inner value using the `Deref` trait\n   |\n14 |                 let result = match *token {\n   |                                    +\n\nFor more information about this error, try `rustc --explain E0308`.\nerror: could not compile `challenge` (lib) due to 4 previous errors\nerror: could not compile `challenge` (lib test) due to 4 previous errors"
  },
  {
    "total": 8,
    "answer": "Looking at the compilation error, the issue is that `token` is of type `&&str` (a reference to a reference to a string), but the match arms are comparing against `&str` literals like `\"+\"`. \n\nThe problem is in the pattern matching. When iterating over `&[&str]`, each `token` is `&&str`, so we need to dereference it once to get `&str`.\n\nThe fix is to change `match *token` to properly handle the dereferencing, or better yet, use pattern matching that directly extracts the `&str`.\n\nHere's the corrected solution:\n\n```rust\npub fn eval_rpn(tokens: &[&str]) -> Result<f64, String> {\n    let mut stack: Vec<f64> = Vec::new();\n\n    for &token in tokens {\n        match token {\n            \"+\" | \"-\" | \"*\" | \"/\" => {\n                if stack.len() < 2 {\n                    return Err(\"too few operands\".to_string());\n                }\n                \n                let b = stack.pop().unwrap();\n                let a = stack.pop().unwrap();\n                \n                let result = match token {\n                    \"+\" => a + b,\n                    \"-\" => a - b,\n                    \"*\" => a * b,\n                    \"/\" => {\n                        if b == 0.0 {\n                            return Err(\"division by zero\".to_string());\n                        }\n                        a / b\n                    }\n                    _ => unreachable!(),\n                };\n                \n                stack.push(result);\n            }\n            _ => {\n                // Try to parse as f64\n                match token.parse::<f64>() {\n                    Ok(num) => stack.push(num),\n                    Err(_) => return Err(format!(\"unknown token: {}\", token)),\n                }\n            }\n        }\n    }\n\n    if stack.len() != 1 {\n        return Err(\"leftover operands\".to_string());\n    }\n\n    Ok(stack[0])\n}\n```\n\nThe key change is using `for &token in tokens` instead of `for token in tokens`. This pattern matches each element by value, so `token` becomes `&str` directly rather than `&&str`. This allows the match arms to work correctly with string literals.",
    "passed": 8,
    "test_error": ""
  }
]