{"@context":"https://schema.org","@type":"FAQPage","mainEntity":[{"@type":"Question","name":"Which Rust type represents a value that may or may not be present?","acceptedAnswer":{"@type":"Answer","text":"Option is an enum that can be either Some(T) containing a value, or None indicating the absence of a value. This type replaces null values found in other languages and forces the developer to explicitly handle the case where the value is absent, thus avoiding null pointer errors at runtime."}},{"@type":"Question","name":"Which Rust type represents an operation that can succeed or fail with an error?","acceptedAnswer":{"@type":"Answer","text":"Result is an enum with two variants: Ok(T) for success containing the return value, and Err(E) for failure containing the error. This type forces explicit error handling rather than using exceptions, making code more predictable and errors more visible."}},{"@type":"Question","name":"What does the unwrap() method do on an Option?","acceptedAnswer":{"@type":"Answer","text":"unwrap() returns the value contained in Some(T) if it exists. If the Option is None, the program panics (panic!) and stops immediately. This method is convenient for prototyping but should be avoided in production as it does not gracefully handle the None case."}},{"@type":"Question","name":"What is the difference between unwrap() and expect()?","acceptedAnswer":{"@type":"Answer","text":"expect() works like unwrap() but allows specifying a custom error message that will be displayed in case of panic. This makes debugging easier by clearly indicating why the program panicked. expect() is preferred over unwrap() as it provides more context when errors occur."}},{"@type":"Question","name":"What does the ? operator do in a function that returns Result?","acceptedAnswer":{"@type":"Answer","text":"The ? operator applied to a Result extracts the Ok(T) value if successful, or automatically propagates the Err(E) error to the calling function if failed. This avoids writing repetitive match blocks and makes code more readable while ensuring errors are properly propagated."}},{"@type":"Question","name":"Which method should be used to provide a default value if an Option is None?","acceptedAnswer":{"@type":"Answer","text":"unwrap_or() returns the value contained in Some if it exists, otherwise returns the default value provided as argument. unwrap_or_default() uses the Default trait to obtain a default value. These methods are safer than unwrap() as they never panic."}},{"@type":"Question","name":"How to create a custom error type in Rust?","acceptedAnswer":{"@type":"Answer","text":"To create a custom error type, define an enum or struct and implement the std::fmt::Display (for display) and std::error::Error (for interoperability) traits. The derive attribute can automate Debug. This approach allows for typed and informative errors."}},{"@type":"Question","name":"What is the correct return signature for a main() function that can fail?","acceptedAnswer":{"@type":"Answer","text":"main() can return Result<(), E> where E implements std::error::Error. If main returns Err, the program displays the error and terminates with a non-zero exit code. This allows using the ? operator directly in main to propagate errors cleanly."}},{"@type":"Question","name":"What does the map() method do on an Option?","acceptedAnswer":{"@type":"Answer","text":"map() applies a function to the value contained in Some and returns an Option with the result. If the Option is None, map() returns None without calling the function. This is a functional pattern that allows transforming optional values without writing explicit conditions."}},{"@type":"Question","name":"Which method should be used to convert an Option to Result?","acceptedAnswer":{"@type":"Answer","text":"ok_or() converts Some(T) to Ok(T) and None to Err(E) with the provided error. ok_or_else() does the same but accepts a closure to create the error lazily, avoiding building the error if the Option contains Some."}},{"@type":"Question","name":"How does the ? operator handle conversion between different error types?","acceptedAnswer":{"@type":"Answer","text":"The ? operator uses the From trait to automatically convert the source error type to the function's error type. If impl From for TargetError exists, the conversion is automatic. This allows propagating errors of different types to a unified error type."}},{"@type":"Question","name":"What is the difference between and_then() and map() on Option?","acceptedAnswer":{"@type":"Answer","text":"map() applies a function that returns T and wraps the result in Some. and_then() (also called flat_map) applies a function that already returns Option, thus avoiding double wrapping Option>. and_then() is useful for chaining operations that may themselves fail."}},{"@type":"Question","name":"What happens if the ? operator is used on a Result in a function that returns Option?","acceptedAnswer":{"@type":"Answer","text":"The code does not compile because the ? operator requires the function's return type to be compatible with the type it is applied to. A function returning Option cannot use ? on a Result directly. You must first convert the Result to Option with ok() or err()."}},{"@type":"Question","name":"Which method allows executing code only if a Result is Err?","acceptedAnswer":{"@type":"Answer","text":"map_err() applies a function only on the Err variant, allowing to transform or enrich the error. If the Result is Ok, the value is returned unchanged. This is useful for adding context to an error or converting it to another type."}},{"@type":"Question","name":"Why doesn't Rust use exceptions for error handling?","acceptedAnswer":{"@type":"Answer","text":"Rust avoids exceptions because they have hidden costs (stack unwinding), make control flow implicit, and can be accidentally ignored. Result forces explicit error handling at compile time, making code more predictable with no overhead if the error is not raised."}},{"@type":"Question","name":"What is the difference between panic! and returning an error with Result?","acceptedAnswer":{"@type":"Answer","text":"panic! stops thread execution immediately (unrecoverable error), while Result allows the caller to handle the error (recoverable error). panic! is reserved for bugs and impossible states, Result for expected errors like file not found or invalid input."}},{"@type":"Question","name":"How to retrieve the value of a Result while providing a recovery function in case of error?","acceptedAnswer":{"@type":"Answer","text":"unwrap_or_else() accepts a closure that receives the error and returns a replacement value. Unlike unwrap_or() which always evaluates the default value, unwrap_or_else() only executes the closure when needed, allowing lazy and customized recovery."}},{"@type":"Question","name":"How to combine multiple Results to continue only if all succeed?","acceptedAnswer":{"@type":"Answer","text":"Using the ? operator successively allows chaining operations: if one fails, the error is propagated immediately. You can also use and_then() to chain dependent operations. To collect multiple Results, the collect() method on an iterator of Results returns Result, E>."}}]}