? Operator

Level 4 — Error Handling & Generics Propagates errors by returning early from a function if a Result is Err or Option is None.

1. Prerequisites

• Result<T, E> — The success/failure enum that ? unpacks.
• Option<T> — The some/none enum that ? can also unpack.
• Pattern Matching — The verbose match syntax that ? successfully replaces.

2. Term Category

Rust-specific (the syntactic sugar): Languages like Java or Python use try/catch blocks for error handling. Rust uses Result enums. Because typing match on every single function call is exhausting, Rust created the ? operator to make error propagation incredibly ergonomic.

3. Explanation

(1) Design Motivation — "Why did we design this?"

If you are doing three things in a row that can fail (e.g., open a file, read its contents, parse the text to a number), you have to match the Result at every single step. This leads to massive, deeply nested "staircase" code that is extremely hard to read.

Rust introduced the ? Operator to solve this. Placing a ? at the exact end of a function call tells the compiler to run a hidden match statement:

• "If this succeeded (Ok), unwrap the inner value and give it to me so I can keep working."
• "If this failed (Err), instantly stop the current function and return the error up to whoever called me."

(2) Reality Metaphor

Imagine you are the manager of a restaurant, and you give your chef three tasks:

1. Buy tomatoes
2. Make sauce
3. Cook pasta

The ? operator is the chef's emergency radio.

• If the chef successfully buys tomatoes (Ok), he quietly unpacks them and moves to step 2.
• But if the store is out of tomatoes (Err), he instantly hits the ? radio button to call you (returning early), saying "Boss, I can't finish the job, here is the error." He doesn't even try to make the sauce or cook the pasta. He just bails out immediately and hands the problem up to you.

(3) Rust Code Examples

Short Snippet (The Verbose Way vs The ? Way)

use std::fs::File;
use std::io::Error;

// THE VERBOSE WAY
fn read_file_old() -> Result<File, Error> {
    let f = File::open("secret.txt");
    
    let file = match f {
        Ok(file) => file,
        Err(e) => return Err(e), // Early return!
    };
    
    Ok(file)
}

// THE `?` WAY
fn read_file_new() -> Result<File, Error> {
    // If this fails, the ? instantly returns the Err for us!
    let file = File::open("secret.txt")?; 
    
    Ok(file)
}

Fuller Example (Chaining ?)

Because ? extracts the inner value on success, you can instantly call another method on that value, leading to beautiful "method chaining".

use std::fs::File;
use std::io::{self, Read};

// This function attempts to open a file and read it into a String.
fn read_username_from_file() -> Result<String, io::Error> {
    let mut username = String::new();
    
    // 1. Try to open the file. If it fails, RETURN early.
    // 2. Try to read the file into `username`. If it fails, RETURN early.
    File::open("hello.txt")?.read_to_string(&mut username)?;
    
    // 3. If we made it this far, both steps succeeded!
    Ok(username)
}

4. Common Mistakes & Pitfalls

Mistake 1: Misunderstanding Question Mark Operator Scoping and Lifecycle Rules

The mistake: Assuming Question Mark Operator instances remain valid beyond their declaring scope block or across asynchronous boundaries without explicit lifetime tracking.

Why it's wrong: Rust strictly enforces lexical scope boundaries and non-lexical lifetimes (NLL) at compile time. Accessing dropped values or failing to handle variable drop order results in compiler errors such as E0597 or E0382.

Incorrect:

fn get_ref() -> &str {
    let s = String::from("question_mark_operator_data");
    &s // ❌ Error E0106/E0515: returns a reference to data owned by the current function
}

Fix:

fn get_string() -> String {
    let s = String::from("question_mark_operator_data");
    s // Ownership of the String is transferred directly to the caller
}

Mistake 2: Mutating Question Mark Operator State Without Exclusive Ownership or mut Borrowing

The mistake: Attempting to mutate data associated with Question Mark Operator through an immutable reference &T or without specifying mut in variable declarations.

Why it's wrong: Rust's aliasing XOR mutability rule (&T for shared immutable access, &mut T for exclusive mutable access) prohibits mutating state through shared references unless interior mutability patterns (e.g. RefCell, Mutex) are explicitly used.

Incorrect:

fn update_val(data: &i32) {
    // *data += 1; // ❌ Error E0594: cannot assign to `*data`, which is behind a `&` reference
}

Fix:

fn update_val(data: &mut i32) {
    *data += 1; // Correct: exclusive mutable reference permits mutation
}

Mistake 3: Concurrent Access to Question Mark Operator Across Threads Without Send / Sync Guards

The mistake: Sharing non-thread-safe Question Mark Operator instances across OS threads via std::thread::spawn.

Why it's wrong: Types that do not implement Send or Sync marker traits cannot safely cross thread boundaries. The compiler prevents data races by raising compile errors E0277 (trait Send is not implemented).

Incorrect:

use std::rc::Rc;
use std::thread;

let rc = Rc::new(42);
// thread::spawn(move || { println!("{}", rc); }); // ❌ Error E0277: `Rc` cannot be sent between threads safely

Fix:

use std::sync::Arc;
use std::thread;

let arc = Arc::new(42);
thread::spawn(move || {
    println!("{}", arc); // Correct: `Arc` implements `Send` and `Sync`
});

5. Practice Exercises

Exercise 1: Multi-Source Config Ingestion Pipeline with Implicit From Error Conversion

Scenario: In a microservice engine, runtime configurations are aggregated from environment variable tables and raw JSON text snippets. The ingestion process must validate and parse multiple fields (BIND_ADDR as a SocketAddr, MAX_CONNECTIONS as u32, and timeout_ms from JSON). Each step can fail with different error types (std::env::VarError, std::net::AddrParseError, std::num::ParseIntError, or custom JSON syntax errors).

Task: Define a unified application error enum ConfigError with variants for MissingKey(String), InvalidPort(ParseIntError), InvalidAddress(AddrParseError), and InvalidJson(String). Implement std::fmt::Display, std::error::Error, and From trait conversions for ParseIntError and AddrParseError. Write a function parse_app_config that extracts and converts configuration entries using the ? operator to cleanly propagate and coerce lower-level errors into ConfigError.

use std::collections::HashMap;
use std::fmt;
use std::net::SocketAddr;
use std::num::ParseIntError;

#[derive(Debug, PartialEq)]
pub enum ConfigError {
    MissingKey(String),
    InvalidPort(ParseIntError),
    InvalidAddress(std::net::AddrParseError),
    InvalidJson(String),
}

impl fmt::Display for ConfigError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ConfigError::MissingKey(key) => write!(f, "Missing configuration key: {key}"),
            ConfigError::InvalidPort(err) => write!(f, "Invalid port number: {err}"),
            ConfigError::InvalidAddress(err) => write!(f, "Invalid IP socket address: {err}"),
            ConfigError::InvalidJson(err) => write!(f, "Malformed JSON structure: {err}"),
        }
    }
}

impl std::error::Error for ConfigError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            ConfigError::InvalidPort(err) => Some(err),
            ConfigError::InvalidAddress(err) => Some(err),
            _ => None,
        }
    }
}

impl From<ParseIntError> for ConfigError {
    fn from(err: ParseIntError) -> Self {
        ConfigError::InvalidPort(err)
    }
}

impl From<std::net::AddrParseError> for ConfigError {
    fn from(err: std::net::AddrParseError) -> Self {
        ConfigError::InvalidAddress(err)
    }
}

#[derive(Debug, PartialEq, Eq)]
pub struct AppConfig {
    pub socket: SocketAddr,
    pub max_connections: u32,
    pub timeout_ms: u64,
}

pub fn parse_app_config(
    env_vars: &HashMap<String, String>,
    raw_payload: &str,
) -> Result<AppConfig, ConfigError> {
    // 1. Extract socket address string; bridge Option to Result with ok_or_else
    let socket_str = env_vars
        .get("BIND_ADDR")
        .ok_or_else(|| ConfigError::MissingKey("BIND_ADDR".to_string()))?;
    
    // 2. Parse SocketAddr using ? -> implicitly calls From<AddrParseError>::from
    let socket: SocketAddr = socket_str.parse()?;

    // 3. Extract max connections string
    let max_conn_str = env_vars
        .get("MAX_CONNECTIONS")
        .ok_or_else(|| ConfigError::MissingKey("MAX_CONNECTIONS".to_string()))?;

    // 4. Parse u32 using ? -> implicitly calls From<ParseIntError>::from
    let max_connections: u32 = max_conn_str.parse()?;

    // 5. Parse timeout from JSON text payload
    let timeout_ms = extract_json_number(raw_payload, "timeout_ms")?;

    Ok(AppConfig {
        socket,
        max_connections,
        timeout_ms,
    })
}

fn extract_json_number(raw_json: &str, key: &str) -> Result<u64, ConfigError> {
    let key_pattern = format!("\"{}\":", key);
    let idx = raw_json
        .find(&key_pattern)
        .ok_or_else(|| ConfigError::InvalidJson(format!("Key '{key}' not found")))?;
    
    let remainder = &raw_json[idx + key_pattern.len()..];
    let val_str = remainder
        .trim()
        .split(&[',', '}', ' '][..])
        .next()
        .ok_or_else(|| ConfigError::InvalidJson("Empty value after key".to_string()))?;
        
    // Parse u64 using ? -> implicitly converts ParseIntError via From
    let val: u64 = val_str.parse()?;
    Ok(val)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_valid_config_ingestion() {
        let mut env = HashMap::new();
        env.insert("BIND_ADDR".to_string(), "127.0.0.1:8080".to_string());
        env.insert("MAX_CONNECTIONS".to_string(), "1024".to_string());
        let json = r#"{"timeout_ms": 5000}"#;

        let config = parse_app_config(&env, json).expect("Configuration parsing failed");
        assert_eq!(config.socket, "127.0.0.1:8080".parse().unwrap());
        assert_eq!(config.max_connections, 1024);
        assert_eq!(config.timeout_ms, 5000);
        assert_ne!(config.max_connections, 512);
    }

    #[test]
    fn test_missing_env_var() {
        let env = HashMap::new();
        let json = r#"{"timeout_ms": 5000}"#;
        let res = parse_app_config(&env, json);
        assert!(res.is_err());
        assert!(matches!(res, Err(ConfigError::MissingKey(ref k)) if k == "BIND_ADDR"));
    }

    #[test]
    fn test_invalid_socket_addr() {
        let mut env = HashMap::new();
        env.insert("BIND_ADDR".to_string(), "invalid-ip-address".to_string());
        env.insert("MAX_CONNECTIONS".to_string(), "1024".to_string());
        let json = r#"{"timeout_ms": 5000}"#;

        let res = parse_app_config(&env, json);
        assert!(res.is_err());
        assert!(matches!(res, Err(ConfigError::InvalidAddress(_))));
    }

    #[test]
    fn test_invalid_port_int() {
        let mut env = HashMap::new();
        env.insert("BIND_ADDR".to_string(), "127.0.0.1:8080".to_string());
        env.insert("MAX_CONNECTIONS".to_string(), "not_a_number".to_string());
        let json = r#"{"timeout_ms": 5000}"#;

        let res = parse_app_config(&env, json);
        assert!(res.is_err());
        assert!(matches!(res, Err(ConfigError::InvalidPort(_))));
    }
}

Exercise 2: Heterogeneous Trait Object Pipeline & Dynamic Early-Exit Error Propagation

Scenario: An enterprise telemetry platform processes dynamic event streams through an ordered collection of heterogeneous stages implemented via trait objects (Box<dyn PipelineStage>). Each stage evaluates incoming data and returns Result<PipelineData, Box<dyn std::error::Error + Send + Sync>>. If any stage encounters a validation failure or security violation, processing must halt instantly and propagate the error dynamically up through the pipeline execution engine.

Task: Define a PipelineStage trait with a process(&self, data: PipelineData) -> Result<PipelineData, Box<dyn std::error::Error + Send + Sync>> method. Implement concrete stages SanitizerStage (which trims whitespace or fails if empty) and SignatureVerifierStage (which checks for a required prefix). Build a PipelineRunner struct that iterates over a vector of Box<dyn PipelineStage> objects and uses the ? operator inside its execution loop to propagate early errors across dynamic dispatch boundaries.

use std::error::Error;
use std::fmt;

#[derive(Debug, Clone, PartialEq)]
pub struct PipelineData {
    pub id: u64,
    pub payload: String,
    pub verified: bool,
}

#[derive(Debug, PartialEq)]
pub enum PipelineError {
    ValidationFailed(String),
    TransformationError(String),
}

impl fmt::Display for PipelineError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            PipelineError::ValidationFailed(reason) => write!(f, "Validation error: {reason}"),
            PipelineError::TransformationError(reason) => write!(f, "Transformation error: {reason}"),
        }
    }
}

impl Error for PipelineError {}

pub trait PipelineStage: Send + Sync {
    fn name(&self) -> &'static str;
    fn process(&self, data: PipelineData) -> Result<PipelineData, Box<dyn Error + Send + Sync>>;
}

pub struct SanitizerStage;
impl PipelineStage for SanitizerStage {
    fn name(&self) -> &'static str {
        "SanitizerStage"
    }
    fn process(&self, mut data: PipelineData) -> Result<PipelineData, Box<dyn Error + Send + Sync>> {
        if data.payload.trim().is_empty() {
            return Err(Box::new(PipelineError::ValidationFailed(
                "Payload cannot be empty".into(),
            )));
        }
        data.payload = data.payload.trim().to_string();
        Ok(data)
    }
}

pub struct SignatureVerifierStage {
    pub required_prefix: String,
}

impl PipelineStage for SignatureVerifierStage {
    fn name(&self) -> &'static str {
        "SignatureVerifierStage"
    }
    fn process(&self, mut data: PipelineData) -> Result<PipelineData, Box<dyn Error + Send + Sync>> {
        if !data.payload.starts_with(&self.required_prefix) {
            return Err(Box::new(PipelineError::ValidationFailed(format!(
                "Payload missing signature prefix '{}'",
                self.required_prefix
            ))));
        }
        data.verified = true;
        Ok(data)
    }
}

pub struct PipelineRunner {
    stages: Vec<Box<dyn PipelineStage>>,
}

impl PipelineRunner {
    pub fn new(stages: Vec<Box<dyn PipelineStage>>) -> Self {
        Self { stages }
    }

    pub fn execute(&self, initial_data: PipelineData) -> Result<PipelineData, Box<dyn Error + Send + Sync>> {
        let mut current_data = initial_data;
        for stage in &self.stages {
            // Propagation across dynamic trait objects using ?
            current_data = stage.process(current_data)?;
        }
        Ok(current_data)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_successful_pipeline_execution() {
        let stages: Vec<Box<dyn PipelineStage>> = vec![
            Box::new(SanitizerStage),
            Box::new(SignatureVerifierStage {
                required_prefix: "SECURE:".to_string(),
            }),
        ];
        let runner = PipelineRunner::new(stages);
        let input = PipelineData {
            id: 101,
            payload: "  SECURE:payload_data  ".to_string(),
            verified: false,
        };

        let result = runner.execute(input).expect("Pipeline execution failed");
        assert_eq!(result.id, 101);
        assert_eq!(result.payload, "SECURE:payload_data");
        assert!(result.verified);
    }

    #[test]
    fn test_pipeline_early_exit_on_sanitizer() {
        let stages: Vec<Box<dyn PipelineStage>> = vec![
            Box::new(SanitizerStage),
            Box::new(SignatureVerifierStage {
                required_prefix: "SECURE:".to_string(),
            }),
        ];
        let runner = PipelineRunner::new(stages);
        let input = PipelineData {
            id: 102,
            payload: "   ".to_string(),
            verified: false,
        };

        let res = runner.execute(input);
        assert!(res.is_err());
        let err = res.unwrap_err();
        let downcasted = err.downcast_ref::<PipelineError>();
        assert!(downcasted.is_some());
        assert!(matches!(
            downcasted.unwrap(),
            PipelineError::ValidationFailed(ref msg) if msg == "Payload cannot be empty"
        ));
    }

    #[test]
    fn test_pipeline_early_exit_on_verification() {
        let stages: Vec<Box<dyn PipelineStage>> = vec![
            Box::new(SanitizerStage),
            Box::new(SignatureVerifierStage {
                required_prefix: "SECURE:".to_string(),
            }),
        ];
        let runner = PipelineRunner::new(stages);
        let input = PipelineData {
            id: 103,
            payload: "UNTRUSTED:data".to_string(),
            verified: false,
        };

        let res = runner.execute(input);
        assert!(res.is_err());
        let err = res.unwrap_err();
        assert_ne!(err.to_string(), "");
        assert!(err.to_string().contains("Payload missing signature prefix"));
    }
}

Exercise 3: Generic Stream Buffer Decoding with Zero-Copy Constraints & Checksum Validation

Scenario: A networking protocol driver decodes binary telemetry frames from generic byte streams (R: std::io::Read). Each frame contains a 2-byte magic header (0xAA55), a 4-byte stream ID, a 2-byte payload length indicator, variable payload bytes, and a trailing 4-byte CRC32 checksum. Decoding must fail fast if magic bytes mismatch, if the payload length exceeds maximum bounds (4096 bytes), if I/O reads truncate, or if checksum verification fails.

Task: Define a custom FrameError enum wrapping I/O errors, header mismatches, payload size violations, and checksum failures. Implement From<std::io::Error> for FrameError. Write a generic method FrameDecoder::decode_frame<R: Read>(reader: &mut R) -> Result<Frame, FrameError> that utilizes helper methods and the ? operator to decode fields sequentially, short-circuiting instantly upon stream error or format invalidity.

use std::io::{self, Read};
use std::fmt;

#[derive(Debug, PartialEq, Eq)]
pub enum FrameError {
    Io(String),
    InvalidMagic { expected: u16, found: u16 },
    InvalidChecksum { expected: u32, calculated: u32 },
    PayloadTooLarge { max: usize, actual: usize },
}

impl fmt::Display for FrameError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            FrameError::Io(e) => write!(f, "I/O read error: {e}"),
            FrameError::InvalidMagic { expected, found } => {
                write!(f, "Invalid magic bytes: expected 0x{expected:04X}, found 0x{found:04X}")
            }
            FrameError::InvalidChecksum { expected, calculated } => {
                write!(f, "Checksum failure: expected 0x{expected:08X}, calculated 0x{calculated:08X}")
            }
            FrameError::PayloadTooLarge { max, actual } => {
                write!(f, "Payload size {actual} bytes exceeds limit of {max} bytes")
            }
        }
    }
}

impl std::error::Error for FrameError {}

impl From<io::Error> for FrameError {
    fn from(err: io::Error) -> Self {
        FrameError::Io(err.to_string())
    }
}

#[derive(Debug, PartialEq, Eq)]
pub struct Frame {
    pub stream_id: u32,
    pub payload: Vec<u8>,
}

pub const MAGIC_BYTES: u16 = 0xAA55;
pub const MAX_PAYLOAD_SIZE: usize = 4096;

pub struct FrameDecoder;

impl FrameDecoder {
    pub fn decode_frame<R: Read>(reader: &mut R) -> Result<Frame, FrameError> {
        // 1. Read 2-byte magic header via helper using ?
        let magic = read_u16_be(reader)?;
        if magic != MAGIC_BYTES {
            return Err(FrameError::InvalidMagic {
                expected: MAGIC_BYTES,
                found: magic,
            });
        }

        // 2. Read 4-byte stream ID via helper using ?
        let stream_id = read_u32_be(reader)?;

        // 3. Read 2-byte payload length via helper using ?
        let payload_len = read_u16_be(reader)? as usize;
        if payload_len > MAX_PAYLOAD_SIZE {
            return Err(FrameError::PayloadTooLarge {
                max: MAX_PAYLOAD_SIZE,
                actual: payload_len,
            });
        }

        // 4. Read payload payload bytes into vector; ? converts io::Error to FrameError
        let mut payload = vec![0u8; payload_len];
        reader.read_exact(&mut payload)?;

        // 5. Read 4-byte expected CRC32 checksum
        let expected_crc = read_u32_be(reader)?;
        let calculated_crc = compute_simple_crc32(&payload);

        if expected_crc != calculated_crc {
            return Err(FrameError::InvalidChecksum {
                expected: expected_crc,
                calculated: calculated_crc,
            });
        }

        Ok(Frame { stream_id, payload })
    }
}

fn read_u16_be<R: Read>(reader: &mut R) -> Result<u16, io::Error> {
    let mut buf = [0u8; 2];
    reader.read_exact(&mut buf)?;
    Ok(u16::from_be_bytes(buf))
}

fn read_u32_be<R: Read>(reader: &mut R) -> Result<u32, io::Error> {
    let mut buf = [0u8; 4];
    reader.read_exact(&mut buf)?;
    Ok(u32::from_be_bytes(buf))
}

fn compute_simple_crc32(bytes: &[u8]) -> u32 {
    let mut crc: u32 = 0xFFFFFFFF;
    for &byte in bytes {
        crc ^= byte as u32;
        for _ in 0..8 {
            if crc & 1 != 0 {
                crc = (crc >> 1) ^ 0xEDB88320;
            } else {
                crc >>= 1;
            }
        }
    }
    !crc
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_valid_frame_decoding() {
        let payload = b"Hello Rust!";
        let crc = compute_simple_crc32(payload);

        let mut data = Vec::new();
        data.extend_from_slice(&MAGIC_BYTES.to_be_bytes());
        data.extend_from_slice(&42u32.to_be_bytes());
        data.extend_from_slice(&(payload.len() as u16).to_be_bytes());
        data.extend_from_slice(payload);
        data.extend_from_slice(&crc.to_be_bytes());

        let mut cursor = std::io::Cursor::new(data);
        let frame = FrameDecoder::decode_frame(&mut cursor).expect("Decode failed");

        assert_eq!(frame.stream_id, 42);
        assert_eq!(frame.payload, payload);
        assert_ne!(frame.stream_id, 0);
    }

    #[test]
    fn test_invalid_magic_header() {
        let mut data = Vec::new();
        data.extend_from_slice(&0x1234u16.to_be_bytes());
        data.extend_from_slice(&1u32.to_be_bytes());
        data.extend_from_slice(&0u16.to_be_bytes());
        data.extend_from_slice(&0u32.to_be_bytes());

        let mut cursor = std::io::Cursor::new(data);
        let result = FrameDecoder::decode_frame(&mut cursor);

        assert!(result.is_err());
        assert!(matches!(
            result,
            Err(FrameError::InvalidMagic { expected: 0xAA55, found: 0x1234 })
        ));
    }

    #[test]
    fn test_checksum_mismatch() {
        let payload = b"Corrupted Payload";
        let bad_crc = 0xDEADBEEF;

        let mut data = Vec::new();
        data.extend_from_slice(&MAGIC_BYTES.to_be_bytes());
        data.extend_from_slice(&7u32.to_be_bytes());
        data.extend_from_slice(&(payload.len() as u16).to_be_bytes());
        data.extend_from_slice(payload);
        data.extend_from_slice(&bad_crc.to_be_bytes());

        let mut cursor = std::io::Cursor::new(data);
        let result = FrameDecoder::decode_frame(&mut cursor);

        assert!(result.is_err());
        assert!(matches!(result, Err(FrameError::InvalidChecksum { .. })));
    }

    #[test]
    fn test_truncated_stream_io_error() {
        let mut data = Vec::new();
        data.extend_from_slice(&MAGIC_BYTES.to_be_bytes());

        let mut cursor = std::io::Cursor::new(data);
        let result = FrameDecoder::decode_frame(&mut cursor);

        assert!(result.is_err());
        assert!(matches!(result, Err(FrameError::Io(_))));
    }
}

6. Related Terms

• unwrap() / expect() — The dangerous alternative to ? that crashes the program entirely instead of safely returning the error.
• From / Into Traits — The hidden magic that allows ? to automatically convert different types of errors into a single unified error type before returning.
• let else Statement — Related concept: let else Statement.
• Result<T, E> — Related concept: Result<T, E>.
• std::error::Error Trait & Box<dyn Error> — Related concept: std::error::Error Trait & Box<dyn Error>.
• FromStr Trait & .parse() — Related concept: FromStr Trait & .parse().
• Read / Write / BufRead Traits — Related concept: Read / Write / BufRead Traits.

7. Key Takeaways

• The ? operator is syntactic sugar for "Return early on error, otherwise give me the inner value".
• It completely eliminates the need for deeply nested match blocks when handling errors.
• It works seamlessly on both Result and Option types.
• The function using the ? operator must return a Result or Option itself.
• You can chain multiple ? calls together for incredibly clean, concise, and perfectly safe code.