Rust Enums Quiz

0 Passed

0% acceptance

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.

40 Questions

~80 minutes

Question 1

What is an enum in Rust and why are they useful?

A type that can represent one of several possible variants, providing compile-time guarantees that all cases are handled

A way to create arrays with different types

A replacement for if-else statements

A way to define constants

Question 2

How do you define a simple enum with unit variants in Rust?

enum Name { Variant1, Variant2, Variant3 }

enum Name(Variant1, Variant2, Variant3)

enum Name { Variant1(), Variant2(), Variant3() }

enum Name = { Variant1, Variant2, Variant3 }

Question 3

What are data-carrying variants in enums?

Enum variants that can hold associated data of different types

Variants that carry metadata about the enum

Variants that automatically implement traits

Variants that can be converted to other types

Question 4

How do you define an enum variant that carries a single value?

VariantName(Type)

VariantName { value: Type }

VariantName = Type

VariantName(Type value)

Question 5

What will this enum definition create?

rust

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

An enum with four variants: unit, struct-like, tuple-like, and tuple-like variants

An enum with only unit variants

An enum with only data-carrying variants

Compilation error - mixed variant types not allowed

Question 6

How do you create instances of enum variants?

EnumName::VariantName for unit variants, EnumName::VariantName(data) for data-carrying variants

VariantName for all variants

new EnumName(VariantName)

EnumName.VariantName

Question 7

What is the key benefit of using enums over constants or integers for representing different states?

Type safety and exhaustiveness checking ensure all possible states are handled

Enums use less memory

Enums are faster to compare

Enums can be easily serialized

Question 8

How do you implement methods on enums?

Use impl EnumName { fn method_name(&self) { ... } }

Use enum EnumName { ... fn method_name(&self) { ... } }

Methods cannot be implemented on enums

Use trait implementations only

Question 9

What will this enum method implementation do?

rust

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

impl Coin {
    fn value_in_cents(&self) -> u32 {
        match self {
            Coin::Penny => 1,
            Coin::Nickel => 5,
            Coin::Dime => 10,
            Coin::Quarter => 25,
        }
    }
}

Adds a method to return the monetary value of each coin variant

Creates static methods for each variant

Compilation error - enums cannot have methods

Adds associated constants to the enum

Question 10

What is the Option enum and why is it commonly used?

An enum representing optional values with Some(T) and None variants, used to handle potentially missing data safely

An enum for boolean options

An enum for configuration options

An enum for command-line arguments

Question 11

How is the Option enum defined in Rust's standard library?

enum Option<T> { Some(T), None }

enum Option<T> { Some(T), Null }

enum Option<T> { Value(T), Empty }

Option is built into the language, not an enum

Question 12

What is the Result enum used for?

Representing operation outcomes with Ok(T) for success and Err(E) for errors

Representing mathematical results

Representing boolean results

Representing search results

Question 13

How do you handle Option values in practice?

Use match or if let to handle Some and None cases safely

Use .unwrap() to get the value directly

Check if the value is null

Use try-catch blocks

Question 14

What will this Option handling code output?

rust

fn main() {
    let some_number = Some(42);
    let absent_number: Option<i32> = None;
    
    match some_number {
        Some(value) => println!("Got a value: {}", value),
        None => println!("No value"),
    }
    
    match absent_number {
        Some(value) => println!("Got a value: {}", value),
        None => println!("No value"),
    }
}

Got a value: 42, No value

Got a value: 42, Got a value: 0

Compilation error

Runtime panic

Question 15

How do you use if let for concise Option handling?

if let Some(value) = option { ... } to execute code only when the option contains a value

if option.is_some() { ... }

if option != None { ... }

if let is not used with Option

Question 16

What is the ? operator used for with Result?

Propagating errors early by returning Err from the current function if a Result is Err

Unwrapping Results unsafely

Converting Results to Options

Creating Result values

Question 17

In a scenario where you're implementing a function that might fail, how should you design its return type?

Use Result<T, ErrorType> to indicate success or failure with specific error information

Use Option<T> for all error cases

Return T and panic on errors

Use exceptions like other languages

Question 18

How do you implement the Display trait for an enum?

Use impl Display for EnumName and implement fmt method with match on variants

Enums automatically implement Display

Use #[derive(Display)]

Display cannot be implemented for enums

Question 19

What is enum variant visibility and how does it work?

Enum variants are public if the enum is public, but can be restricted with pub(crate) or private modules

Variants have independent visibility from the enum

All variants are always public

Variants cannot be made private

Question 20

How do you create associated functions (static methods) on enums?

Use impl EnumName { fn new() -> Self { ... } } without &self parameter

Use static fn in the enum definition

Associated functions cannot be created on enums

Use class methods syntax

Question 21

What will this associated function on an enum create?

rust

enum Color {
    Red,
    Green,
    Blue,
}

impl Color {
    fn from_rgb(r: u8, g: u8, b: u8) -> Option<Self> {
        match (r, g, b) {
            (255, 0, 0) => Some(Color::Red),
            (0, 255, 0) => Some(Color::Green),
            (0, 0, 255) => Some(Color::Blue),
            _ => None,
        }
    }
}

A constructor function that creates Color variants from RGB values, returning None for invalid combinations

An instance method that converts colors to RGB

A method that validates RGB values

Compilation error - enums cannot have constructors

Question 22

How do you handle Result values in a match expression?

Match on Ok(value) for success and Err(error) for failure cases

Use if let Ok(value) = result for success handling

Both A and B are correct approaches

Result values cannot be matched

Question 23

What is the difference between Option and Result enums?

Option represents optional values (Some/None), Result represents operation outcomes (Ok/Err with error details)

Option is for errors, Result is for optional values

They are identical

Option has more variants than Result

Question 24

How do you chain operations that return Result using the ? operator?

fn process() -> Result<T, E> { let x = operation1()?; let y = operation2(x)?; Ok(y) }

Use try! macro instead of ?

The ? operator cannot be chained

Use match for each operation separately

Question 25

In a scenario where you're parsing user input that might be invalid, how should you structure the parsing function?

fn parse_input(s: &str) -> Result<ParsedData, ParseError> with specific error types for different failure modes

fn parse_input(s: &str) -> Option<ParsedData> for all error cases

fn parse_input(s: &str) -> ParsedData and panic on invalid input

Use exceptions for parsing errors

Question 26

What is enum discriminant and how does it work?

An integer value automatically assigned to each variant, starting from 0, used for memory representation

A string identifier for each variant

The data type associated with each variant

The visibility modifier for each variant

Question 27

How do you customize enum discriminants?

Use #[repr(u8)] or similar on the enum and assign values like Variant = 1

Discriminants cannot be customized

Use discriminant = value in the variant definition

Use const values for discriminants

Question 28

What is the memory layout of enums in Rust?

A discriminant tag plus enough space for the largest variant's data

Separate memory for each variant

Dynamic memory allocation for each variant

Enums use the same memory as their variants

Question 29

How do you implement From or Into traits for enums?

Use impl From<OtherType> for EnumName to define conversions, often with match expressions

Enums automatically implement conversion traits

Use #[derive(From)]

Conversions are not possible for enums

Question 30

What will this enum conversion implementation do?

rust

enum Status {
    Active,
    Inactive,
}

impl From<bool> for Status {
    fn from(b: bool) -> Self {
        if b { Status::Active } else { Status::Inactive }
    }
}

Allows converting bool values to Status variants using .into() or From::from()

Allows converting Status to bool

Creates a new Status variant

Compilation error - invalid conversion

Question 31

How do you handle C-style enums with custom discriminants?

enum MyEnum { Variant1 = 1, Variant2 = 5, Variant3 = 10 } with #[repr(C)] or similar

Use const values for discriminants

Custom discriminants are not supported

Use separate constants

Question 32

What is the difference between tuple variants and struct variants in enums?

Tuple variants use (type1, type2), struct variants use { field1: type1, field2: type2 }

Tuple variants are unnamed, struct variants are named

Both A and B are correct

There is no functional difference

Question 33

How do you pattern match on struct variants?

Use EnumName::VariantName { field1, field2 } => expression to destructure named fields

Use EnumName::VariantName(field1, field2) for struct variants

Struct variants cannot be pattern matched

Use dot notation for field access

Question 34

What will this struct variant matching code do?

rust

enum Shape {
    Circle { radius: f64 },
    Rectangle { width: f64, height: f64 },
}

fn main() {
    let shape = Shape::Rectangle { width: 10.0, height: 20.0 };
    match shape {
        Shape::Circle { radius } => println!("Circle with radius {}", radius),
        Shape::Rectangle { width, height } => println!("Rectangle {}x{}", width, height),
    }
}

Print 'Rectangle 10x20'

Print 'Circle with radius 10'

Compilation error

Runtime error

Question 35

How do you implement Default trait for an enum?

Use impl Default for EnumName { fn default() -> Self { EnumName::SomeVariant } }

Use #[derive(Default)] if the first variant should be default

Both A and B are valid approaches

Default cannot be implemented for enums

Question 36

What is the advantage of using enums over inheritance hierarchies?

Enums provide exhaustiveness checking and cannot be extended at runtime, ensuring type safety

Enums use less memory

Enums are faster to create

Enums support dynamic dispatch

Question 37

How do you handle nested enums in pattern matching?

Use nested match expressions or combine patterns with destructuring

Flatten the enum structure first

Use separate functions for each level

Nested enums cannot be matched

Question 38

What will this nested enum matching demonstrate?

rust

enum Result {
    Ok(i32),
    Err(String),
}

fn main() {
    let result = Result::Ok(42);
    match result {
        Result::Ok(n) if n > 0 => println!("Positive number: {}", n),
        Result::Ok(n) => println!("Zero or negative: {}", n),
        Result::Err(msg) => println!("Error: {}", msg),
    }
}

Shows how guards work with enum variants to add conditional logic

Demonstrates nested enum matching

Shows error handling patterns

All of the above

Question 39

How do you create recursive enums (enums that contain themselves)?

Use Box<EnumName> for recursive variants to avoid infinite size

Use Rc<EnumName> for shared ownership

Recursive enums are not allowed

Use &EnumName references

Question 40

In a complex application where you need to represent different types of user interface events, how would you design the event enum?

enum UiEvent { Click { x: i32, y: i32 }, KeyPress(char), Resize { width: u32, height: u32 }, Close } with appropriate data for each event type

Use separate structs for each event type

Use a single struct with optional fields

Use inheritance with a base Event class

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

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 Enums 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

About This Enums Quiz

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