Rust Error Handling Quiz

Rust

0 Passed

0% acceptance

Master Rust's robust error handling system with Result, Option, and the ? operator for reliable code

40 Questions

~80 minutes

Question 1

What is the Result type in Rust?

An enum representing either success (Ok) or failure (Err)

A type for optional values

A type for collections

Result doesn't exist

Question 2

What does this Result example show?

rust

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("Division by zero"))
    } else {
        Ok(a / b)
    }
}

Function returns Result with success value or error message

Compilation error

Function always succeeds

Runtime error

Question 3

What is the Option type?

An enum representing Some(value) or None for absence

A type for errors

A type for collections

Option doesn't exist

Question 4

What does this Option example show?

rust

fn find_first_even(nums: &[i32]) -> Option<i32> {
    for &num in nums {
        if num % 2 == 0 {
            return Some(num);
        }
    }
    None
}

Returns Some(first_even) or None if no even numbers found

Compilation error

Always returns Some value

Runtime error

Question 5

What is the ? operator used for?

Early return with error propagation from Result/Option

Unwrapping values

Creating errors

? operator doesn't exist

Question 6

What does this ? operator example do?

rust

fn read_file() -> Result<String, std::io::Error> {
    let content = std::fs::read_to_string("file.txt")?;
    Ok(content)
}

Returns error if file reading fails, otherwise returns content

Compilation error

Always succeeds

Runtime error

Question 7

What is the difference between unwrap() and expect()?

expect() provides custom panic message, unwrap() uses default

unwrap() is safer than expect()

They are identical

Neither exists

Question 8

When should you use unwrap() or expect()?

When you're certain the value exists and want to panic otherwise

For all error handling

When you want to ignore errors

Never, they're always wrong

Question 9

What does the map() method do on Result?

Transforms the Ok value if present

Transforms the Err value

Always returns Ok

map() doesn't exist on Result

Question 10

What does this Result map() example do?

rust

let result: Result<i32, &str> = Ok(5);
let doubled = result.map(|x| x * 2);

doubled is Ok(10), applying function to success value

Compilation error

doubled is Ok(5)

Runtime error

Question 11

What does map_err() do?

Transforms the error value in a Result

Transforms the success value

Always returns Err

map_err() doesn't exist

Question 12

What does this map_err() example do?

rust

let result: Result<i32, &str> = Err("error");
let mapped = result.map_err(|e| format!("Error: {}", e));

mapped is Err("Error: error"), transforming error message

Compilation error

mapped is Ok value

Runtime error

Question 13

What does and_then() do?

Chains operations that return Result, short-circuiting on error

Always executes both operations

Combines two Results

and_then() doesn't exist

Question 14

What does this and_then() example do?

rust

let result = Ok(5).and_then(|x| Ok(x * 2));

result is Ok(10), chaining successful operations

Compilation error

result is Ok(5)

Runtime error

Question 15

What does or_else() do?

Provides fallback for Err case, returns Result

Provides fallback for Ok case

Always returns Ok

or_else() doesn't exist

Question 16

What does unwrap_or() do for Option?

Returns inner value or provided default if None

Always panics

Returns None

unwrap_or() doesn't exist

Question 17

What does this unwrap_or() example return?

rust

let option: Option<i32> = None;
let value = option.unwrap_or(42);

42, using the default value

Compilation error

Panics

Question 18

What does unwrap_or_else() do?

Calls closure to provide default value if None

Always calls the closure

Never calls the closure

unwrap_or_else() doesn't exist

Question 19

What is a custom error enum?

User-defined enum implementing std::error::Error for rich error types

Built-in error type

Error without variants

Custom error enums don't exist

Question 20

What does this custom error enum example show?

rust

#[derive(Debug)]
enum MyError {
    Io(std::io::Error),
    Parse(std::num::ParseIntError),
    Custom(String),
}

Enum wrapping different error types for unified error handling

Compilation error

Single error type

Runtime error

Question 21

How do you implement std::error::Error for custom errors?

Implement Error, Display, and Debug traits

Only implement Error trait

Use derive macro

No implementation needed

Question 22

What is the From trait used for in error handling?

Automatic conversion between error types

Creating errors

Displaying errors

From trait isn't used for errors

Question 23

What does this From implementation enable?

rust

impl From<std::io::Error> for MyError {
    fn from(error: std::io::Error) -> Self {
        MyError::Io(error)
    }
}

? operator can convert io::Error to MyError automatically

Compilation error

Manual conversion only

Runtime error

Question 24

What is the Box<dyn std::error::Error> pattern?

Trait object allowing any error type that implements Error

Boxed error values

Error without type information

This pattern doesn't exist

Question 25

What does this Box<dyn Error> example show?

rust

fn dynamic_error() -> Result<(), Box<dyn std::error::Error>> {
    Err(Box::new(std::io::Error::new(std::io::ErrorKind::Other, "error")))
}

Function can return any error type through trait object

Compilation error

Specific error type only

Runtime error

Question 26

What is error propagation?

Passing errors up the call stack using ? or manual returns

Ignoring errors

Converting errors

Error propagation doesn't exist

Question 27

What does this error propagation example show?

rust

fn outer() -> Result<(), std::io::Error> {
    inner()?;
    Ok(())
}

fn inner() -> Result<(), std::io::Error> {
    Err(std::io::Error::new(std::io::ErrorKind::Other, "error"))
}

Error from inner() propagates to outer() via ?

Compilation error

No error propagation

Runtime error

Question 28

What is the difference between panic! and returning Result?

panic! is for unrecoverable errors, Result for recoverable ones

They are identical

Result is for unrecoverable errors

panic! doesn't exist

Question 29

What is the Result<T, E> syntax sugar?

Result<!, E> means Result<(), E> for functions returning only errors

Result<T, !> means infallible operations

Both A and B

No syntax sugar exists

Question 30

What does Ok(()) represent?

Success with no meaningful return value

Error condition

Empty Result

Ok(()) doesn't make sense

Question 31

What is the try! macro?

Older version of ? operator for error propagation

Macro for trying operations

Macro for creating Results

try! doesn't exist

Question 32

What does this pattern matching on Result show?

rust

match divide(10, 2) {
    Ok(result) => println!("Result: {}", result),
    Err(error) => println!("Error: {}", error),
}

Explicit handling of both success and error cases

Compilation error

Only handles success

Runtime error

Question 33

What does if let work with Results?

rust

if let Ok(value) = divide(10, 2) {
    println!("Success: {}", value);
}

Conditionally executes code only on success

Compilation error

Always executes

Runtime error

Question 34

What is error chaining?

Using ? operator to propagate errors through multiple function calls

Linking error types together

Creating error chains manually

Error chaining doesn't exist

Question 35

What does this error chaining example show?

rust

fn complex_operation() -> Result<i32, std::io::Error> {
    let file = std::fs::File::open("data.txt")?;
    let content = read_content(file)?;
    let result = parse_number(content)?;
    Ok(result)
}

Any step failing causes early return with error

Compilation error

All operations always succeed

Runtime error

Question 36

What is the main advantage of Result over exceptions?

Errors are explicit in function signatures, compiler enforces handling

Result is faster than exceptions

Result uses less memory

No advantages

Question 37

What is the main advantage of Option over null?

Type system forces checking for None before use

Option is faster than null

Option uses less memory

No advantages

Question 38

What does expect() do differently from unwrap()?

rust

let value = Some(5).expect("Value should exist");

Provides custom panic message: 'Value should exist'

Compilation error

Same as unwrap()

Runtime error

Question 39

What is error downcasting?

Converting Box<dyn Error> back to concrete error types

Converting errors to strings

Ignoring errors

Error downcasting doesn't exist

Question 40

In a complex application where you have multiple layers (database, business logic, API), how should you handle errors to maintain good separation of concerns while providing meaningful error messages to users?

Use custom error enums at each layer with From implementations, map errors to user-friendly messages at API boundary

Use String for all errors to keep it simple

Panic at every layer for immediate failure

Use unwrap() everywhere and handle panics globally

Other Quiz Categories

JavaScript

47 quizzes

Basics

Variables & Data Types

Operators & Expressions

Python

29 quizzes

Introduction & Core Fundamentals

Data Types & Zero Values

Operators & Expressions

C++

26 quizzes

Basics

Variables & Data Types

Operators & Expression

Java

22 quizzes

Java Basics & JVM Fundamentals

Variables, Data Types & Type Casting

Operators & Expressions

Matlab

21 quizzes

Basics & Environment

Variables and Data Type

Arrays and Matric

TypeScript

19 quizzes

Introduction and Overview

Installation and Configuration

Basic Types and Type Annotations

SQL Database

15 quizzes

Foundations and Basics

Basic Query Selection

Filter, Sort, and Alias Essentials

PHP

15 quizzes

Syntax Building Blocks

Node Structure and Pointer Fundamentals

Singly Linked List

QUIZZES IN Rust

Cargo and Project Setup

40 comprehensive questions on Rust's package manager Cargo, covering project initialization, building, running, project structure, and dependency management — with 15 code examples demonstrating practical Cargo usage.

Variables and Mutability

40 comprehensive questions on Rust's variable system, covering let bindings, mut keyword, shadowing, type inference, and constants — with 12 code examples demonstrating practical variable usage patterns.

Data Types

45 comprehensive questions on Rust's type system, covering scalar types, compound types, type conversions, numeric operations, and string types — with 15 code examples demonstrating practical type usage patterns.

Control Flow

45 comprehensive questions on Rust's control flow constructs, covering if expressions, loops, and control flow keywords — with 15 code examples demonstrating practical control flow usage.

Functions

40 questions covering function parameters, return values, expressions, diverging functions, and function scope in Rust.

Ownership

45 in-depth questions covering Rust's ownership system, move semantics, copy types, resource cleanup through Drop trait, precise drop timing, and ownership transfer patterns — with 12 code examples to solidify understanding.

Borrowing

45 in-depth questions covering Rust's borrowing system, immutable and mutable references, aliasing rules, reference scopes, and borrow checker validation — with 13 code examples to solidify understanding.

Lifetimes

40 in-depth questions covering Rust's lifetime system, lifetime annotations, elision rules, function signatures with lifetimes, struct references, and common lifetime errors — with 11 code examples to solidify understanding.

Strings

40 comprehensive questions on Rust's string types, covering String vs &str, UTF-8 behavior, slicing, mutating strings, and conversions — with 11 code examples demonstrating practical string handling patterns.

Collections

40 comprehensive questions on Rust's collection types, covering Vec, HashMap, VecDeque, iteration patterns, and capacity management — with 11 code examples demonstrating practical collection usage.

Slices

40 comprehensive questions on Rust's slice types, covering borrowed views, indexing, mutable slices, ranges, and slice methods — with 11 code examples demonstrating practical slice usage patterns.

Pattern Matching

40 comprehensive questions on Rust's pattern matching system, covering match expressions, destructuring, guards, wildcards, and enum matching — with 11 code examples demonstrating practical pattern matching techniques.

Enums

40 comprehensive questions on Rust's enum system, covering simple variants, data-carrying variants, enum matching, methods on enums, and Option/Result patterns — with 11 code examples demonstrating practical enum usage.

Struct

40 comprehensive questions on Rust's struct system, covering named fields, tuple structs, methods, associated functions, and field ownership — with 11 code examples demonstrating practical struct usage.

Modules

40 comprehensive questions on Rust's module system, covering module creation, visibility, imports, paths, and the use keyword — with 11 code examples demonstrating practical module organization patterns.

Traits

40 comprehensive questions on Rust's trait system, covering trait definitions, implementations, bounds, associated types, and trait objects — with 11 code examples demonstrating practical trait usage patterns.

Generic

40 comprehensive questions on Rust's generic programming system, covering generic functions, structs, enums, impl blocks, and monomorphization — with 11 code examples demonstrating practical generic usage patterns.

Iterators

Master Rust's powerful iterator system for efficient data processing and transformation

Closures

Master Rust's closure system for capturing environment variables and creating flexible function-like constructs

Error Handling

Master Rust's robust error handling system with Result, Option, and the ? operator for reliable code

File and I/O Operations

Master Rust's file system operations and I/O handling for robust data persistence and streaming

Smart Pointers

Master Rust's smart pointer types for automatic memory management and safe heap allocation

Concurrency

Master Rust's concurrency model with threads, channels, and synchronization primitives for safe parallel programming

Async Programming

Master asynchronous programming in Rust with futures, async/await, and concurrent execution patterns

Memory Management

Deep dive into Rust's ownership system, borrowing rules, and advanced memory management patterns for safe and efficient code

Macros

Master Rust's metaprogramming system with declarative and procedural macros for code generation and compile-time programming

Attributes

Master Rust's attribute system for conditional compilation, testing, documentation, and code generation

Testing

Master comprehensive testing strategies in Rust including unit tests, integration tests, documentation tests, and testing best practices

Crate Architecture

Master the design and organization of Rust crates including module systems, workspace management, dependency handling, and publishing strategies

Performance and Optimization

Master advanced performance techniques in Rust including profiling, benchmarking, memory optimization, and compiler optimizations

Rust Error Handling Quiz

Question 1

Question 2

Question 3

Question 4

Question 5

Question 6

Question 7

Question 8

Question 9

Question 10

Question 11

Question 12

Question 13

Question 14

Question 15

Question 16

Question 17

Question 18

Question 19

Question 20

Question 21

Question 22

Question 23

Question 24

Question 25

Question 26

Question 27

Question 28

Question 29

Question 30

Question 31

Question 32

Question 33

Question 34

Question 35

Question 36

Question 37

Question 38

Question 39

Question 40

What Is Error Handling in Rust?

What You Will Practise

Other Quiz Categories

QUIZZES IN Rust

Cargo and Project Setup

Variables and Mutability

Data Types

Control Flow

Functions

Ownership

Borrowing

Lifetimes

Strings

Collections

Slices

Pattern Matching

Enums

Struct

Modules

Traits

Generic

Iterators

Closures

Error Handling

File and I/O Operations

Smart Pointers

Concurrency

Async Programming

Memory Management

Macros

Attributes

Testing

Crate Architecture

Performance and Optimization