Unit-like structs in Rust - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a unit-like struct in Rust?

A unit-like struct is a struct without any fields. It looks like a name followed by a semicolon, for example: struct MyStruct;. It is used when you want to create a type without data, often for marking or signaling.

beginner

How do you define a unit-like struct in Rust?

You define it by writing the struct name followed by a semicolon, without any fields or braces. For example: struct Marker;

intermediate

Why would you use a unit-like struct instead of an empty tuple or enum?

Unit-like structs can be used to create distinct types for type safety, even if they hold no data. They are clearer than empty tuples and more flexible than enums when you want to mark or tag something without data.

beginner

How do you create an instance of a unit-like struct?

You create an instance by just writing the struct name followed by empty parentheses. For example, if you have <code>struct Marker;</code>, you create an instance with <code>let m = Marker();</code>.

intermediate

Can unit-like structs implement traits in Rust?

Yes, unit-like structs can implement traits just like any other struct. This allows you to add behavior to them even though they hold no data.

How do you define a unit-like struct named Flag in Rust?

A struct Flag;

B struct Flag {}

C struct Flag();

D enum Flag {}

A unit-like struct is defined with the struct name followed by a semicolon and no braces or fields.

What is the main characteristic of a unit-like struct?

A It has no fields.

B It has exactly one field.

C It can only hold integers.

D It is an enum variant.

Unit-like structs have no fields; they are just a name representing a type.

How do you create an instance of a unit-like struct named Marker?

A let m = Marker;

B let m = Marker[];

C let m = Marker{};

D let m = Marker();

You create an instance by writing the struct name followed by empty parentheses.

Can unit-like structs implement traits in Rust?

A No, they cannot implement traits.

B Yes, they can implement traits.

C Only if they have fields.

D Only if they are enums.

Unit-like structs can implement traits just like other structs.

Which of these is a good use case for unit-like structs?

A To hold configuration settings.

B To store multiple values.

C To create a marker type for type safety.

D To replace enums with data.

Unit-like structs are often used as marker types to add type safety without storing data.

Explain what a unit-like struct is and how you define one in Rust.

Think about a struct without any data inside.

Describe how you create an instance of a unit-like struct and why you might use it.

Remember it’s like a tag without data.

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