Unit-like structs in Rust - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a unit-like struct named Marker.

Rust

struct [1];

Drag options to blanks, or click blank then click option'

Amarker

BMarkStruct

CMark

DMarker

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting the semicolon at the end of the struct definition.

Using lowercase names for the struct.

The correct syntax to define a unit-like struct is struct Marker; where Marker is the struct name.

2fill in blank

medium

Complete the code to create an instance of the unit-like struct Marker.

Rust

let m = [1];

Drag options to blanks, or click blank then click option'

AMarker()

BMarker{}

CMarker

Dnew Marker()

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to instantiate with parentheses or braces like a tuple or classic struct.

Using a constructor function that does not exist.

Unit-like structs are instantiated by just writing their name without parentheses or braces, like Marker.

3fill in blank

hard

Fix the error in the code by completing the blank to correctly implement the Debug trait for the unit-like struct Marker.

Rust

#[derive([1])]
struct Marker;

Drag options to blanks, or click blank then click option'

ADebug

BClone

CCopy

DDisplay

Attempts:

3 left

💡 Hint

Common Mistakes

Using Display instead of Debug in derive.

Forgetting to derive any trait and causing compile errors.

The Debug trait allows printing the struct with {:?}. It is derived using #[derive(Debug)].

4fill in blank

hard

Fill both blanks to implement a function that takes a unit-like struct Marker as a parameter and returns a string.

Rust

fn describe([1]: [2]) -> &'static str {
    "This is a unit-like struct"
}

Drag options to blanks, or click blank then click option'

Am

Bmarker

CMarker

DUnit

Attempts:

3 left

💡 Hint

Common Mistakes

Using the struct name as the parameter name (capitalized).

Using a variable name that is the same as the type.

The function parameter name can be any valid variable name like m, and the type is the unit-like struct Marker.

5fill in blank

hard

Fill all three blanks to create a unit-like struct Flag, instantiate it, and print it using debug formatting.

Rust

#[derive([1])]
struct [2];

fn main() {
    let f = [3];
    println!("{:?}", f);
}

Drag options to blanks, or click blank then click option'

ADebug

BFlag

DFlag()

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to instantiate with parentheses like Flag().

Forgetting to derive Debug and causing a compile error on println!.

Derive Debug to print the struct, define the struct Flag, and instantiate it by just writing Flag.

Practice

1. What is a unit-like struct in Rust?

easy

A. A struct that can only be used inside functions.

B. A struct with exactly one field.

C. A struct that holds only unit type values.

D. A struct without any fields, used as a marker.

Solution

1. Step 1: Understand struct definitions

   Structs in Rust can have fields or no fields. A unit-like struct has no fields.

2. Step 2: Identify the purpose of unit-like structs

   They are used as markers or labels without storing data.

3. Final Answer:

   A struct without any fields, used as a marker. -> Option D

4. Quick Check:

   Unit-like struct = marker struct [OK]

Hint: No fields means unit-like struct, used as marker [OK]

Common Mistakes:

• Thinking unit-like structs must have fields
• Confusing unit-like structs with tuple structs
• Assuming unit-like structs hold unit type values

2. Which of the following is the correct syntax to declare a unit-like struct named Marker in Rust?

easy

A. struct Marker;

B. struct Marker();

C. struct Marker {}

D. struct Marker[];

Solution

1. Step 1: Recall unit-like struct syntax

   Unit-like structs are declared with just the name and a semicolon, no parentheses or braces.

2. Step 2: Compare options

   struct Marker; matches the syntax: struct Marker;

3. Final Answer:

   struct Marker; -> Option A

4. Quick Check:

   Unit-like struct syntax = struct Name; [OK]

Hint: Unit-like struct ends with semicolon, no braces [OK]

Common Mistakes:

• Using parentheses like tuple structs
• Using braces like normal structs
• Adding square brackets which are invalid

3. What will be the output of this Rust code?

struct Flag;

impl Flag {
    fn is_set(&self) -> bool {
        true
    }
}

fn main() {
    let f = Flag;
    println!("{}", f.is_set());
}

medium

A. false

B. true

C. Compilation error

D. Runtime panic

Solution

1. Step 1: Understand the struct and method

   Flag is a unit-like struct with a method is_set that always returns true.

2. Step 2: Trace the main function

   We create an instance f of Flag and call f.is_set(), which returns true, printed as "true".

3. Final Answer:

   true -> Option B

4. Quick Check:

   Method returns true, output is true [OK]

Hint: Unit-like structs can have methods returning values [OK]

Common Mistakes:

• Expecting a compilation error due to no fields
• Thinking unit-like structs cannot have methods
• Confusing output with false or panic

4. Identify the error in this Rust code using a unit-like struct:

struct Label;

fn main() {
    let l = Label();
    println!("Label created");
}

medium

A. Unit-like structs must have at least one field.

B. Missing semicolon after struct declaration.

C. Unit-like structs cannot be instantiated with parentheses.

D. The println! macro is used incorrectly.

Solution

1. Step 1: Check struct instantiation

   Unit-like structs are instantiated without parentheses, just by name.

2. Step 2: Identify the error

   The code uses Label() which is invalid; it should be Label.

3. Final Answer:

   Unit-like structs cannot be instantiated with parentheses. -> Option C

4. Quick Check:

   Instantiate unit-like struct without () [OK]

Hint: Instantiate unit-like structs by name only, no () [OK]

Common Mistakes:

• Adding parentheses when creating unit-like struct instances
• Forgetting semicolon after struct declaration (not in this code)
• Misusing println! macro syntax

5. Given this code, what is the output?

struct Marker;

impl Marker {
    fn label(&self) -> &'static str {
        "Unit Marker"
    }
}

fn main() {
    let markers = vec![Marker, Marker];
    for m in markers {
        println!("{}", m.label());
    }
}

hard

A. Unit Marker\nUnit Marker

B. Compilation error due to vector of unit-like structs

C. Unit Marker printed once

D. Runtime panic due to missing fields

Solution

1. Step 1: Understand vector of unit-like structs

   Unit-like structs can be stored in vectors as they are zero-sized but valid types.

2. Step 2: Trace the loop and method calls

   The loop prints the label for each Marker instance, which returns "Unit Marker" twice.

3. Final Answer:

   Unit Marker\nUnit Marker -> Option A

4. Quick Check:

   Two markers print label twice [OK]

Hint: Unit-like structs can be stored and iterated like normal structs [OK]

Common Mistakes:

• Assuming unit-like structs cannot be stored in collections
• Expecting compilation error due to zero-sized type
• Thinking only one print occurs