Unit-like structs in Rust - Deep Dive

Overview - Unit-like structs

What is it?

Unit-like structs in Rust are a special kind of struct that have no fields. They look like empty containers and are defined with just a name and a semicolon. Despite having no data inside, they can be useful to represent concepts or types without any associated values. They behave like a type with exactly one possible value.

Why it matters

Unit-like structs exist to let programmers create distinct types that carry no data but still have meaning in the program. Without them, you might have to use other types like empty tuples or enums, which can be less clear or flexible. They help make code more readable and type-safe by giving names to concepts that don't need extra information.

Where it fits

Before learning unit-like structs, you should understand basic Rust structs and types. After this, you can explore tuple structs, classic structs with fields, and enums. Unit-like structs are a foundation for advanced Rust features like marker traits and zero-sized types.

Mental Model

Core Idea

A unit-like struct is a named type with no data, representing a single unique value.

Think of it like...

It's like a labeled empty box that you carry around to show you have something, even though the box holds nothing inside.

Unit-like struct:
┌───────────────┐
│ StructName;   │  <-- No fields inside
└───────────────┘

Usage:
StructName  <-- Only one possible value of this type

Build-Up - 6 Steps

1

Foundation

What is a Unit-like Struct

Concept: Introducing the simplest struct form with no fields.

In Rust, a unit-like struct is declared by writing the struct name followed by a semicolon, without any curly braces or fields. For example: struct Marker; This defines a new type called Marker that has exactly one value, also called Marker.

Result

You get a new type Marker that you can use in your code but it holds no data.

Understanding that structs can exist without fields expands the idea of types beyond just data containers.

2

Foundation

Creating and Using Unit-like Structs

Concept: How to create instances and use unit-like structs in code.

Since unit-like structs have no fields, you create an instance by just writing its name followed by a semicolon: let m = Marker; You can pass this value around, use it as a type marker, or implement traits on it.

Result

You can create and use values of unit-like struct types just like any other type, but they carry no data.

Knowing how to instantiate unit-like structs shows they behave like singletons with a unique value.

3

Intermediate

Unit-like Structs as Markers

🤔Before reading on: do you think unit-like structs can hold data? Commit to yes or no.

Concept: Using unit-like structs to mark or tag types without storing data.

Unit-like structs are often used as markers to indicate some property or behavior. For example, you might define: struct ReadOnly; and then use this type to mark functions or structs that are read-only. This helps the compiler and readers understand intent without extra data.

Result

You get clearer, safer code by using types to express concepts, not just data.

Understanding that types can represent ideas, not just data, unlocks powerful design patterns.

4

Intermediate

Implementing Traits on Unit-like Structs

🤔Before reading on: do you think you can add behavior to unit-like structs? Commit to yes or no.

Concept: Adding methods and traits to unit-like structs to give them behavior.

Even though unit-like structs have no data, you can implement traits or methods on them: impl Marker { fn describe(&self) { println!("I am a marker type."); } } This lets you use them like any other type with behavior.

Result

Unit-like structs can carry behavior, making them useful beyond just empty labels.

Knowing that behavior is separate from data helps you design flexible types.

5

Advanced

Unit-like Structs as Zero-Sized Types

🤔Before reading on: do you think unit-like structs use memory at runtime? Commit to yes or no.

Concept: Understanding that unit-like structs occupy no space in memory and how Rust optimizes them.

Unit-like structs are zero-sized types (ZSTs), meaning they take up no space at runtime. Rust uses this to optimize code, for example, by not allocating memory for them. This is useful in generic programming and marker traits where you want type information without runtime cost.

Result

You get efficient code that uses types for safety without extra memory overhead.

Understanding zero-sized types explains why unit-like structs are both meaningful and efficient.

6

Expert

Unit-like Structs in Advanced Rust Patterns

🤔Before reading on: do you think unit-like structs can be used in trait bounds and generics? Commit to yes or no.

Concept: Using unit-like structs as markers in traits, generics, and compile-time checks.

In advanced Rust, unit-like structs are used as marker types in traits to enable or disable functionality. For example, you might have: trait Readable {} impl Readable for ReadOnly {} and use generic bounds to restrict functions to certain markers. This pattern helps enforce rules at compile time without runtime cost.

Result

You can write safer, more expressive code that the compiler checks thoroughly.

Knowing how unit-like structs integrate with Rust's type system unlocks powerful compile-time guarantees.

Under the Hood

Unit-like structs are represented internally as zero-sized types, meaning they occupy no memory space. The Rust compiler treats them as unique types with exactly one possible value. When compiled, instances of unit-like structs do not generate data storage but serve as type-level information. This allows the compiler to optimize away any runtime overhead while preserving type safety and behavior.

Why designed this way?

Rust was designed to be both safe and efficient. Unit-like structs provide a way to represent concepts purely at the type level without runtime cost. Alternatives like enums or tuples would either carry unnecessary data or complicate the type system. This design balances expressiveness with zero-cost abstractions, a core Rust philosophy.

┌───────────────────────────────┐
│ Unit-like Struct Type          │
│ ┌───────────────────────────┐ │
│ │ No fields, zero size       │ │
│ └───────────────────────────┘ │
│                               │
│ Compiler treats as unique type │
│ with one possible value        │
│                               │
│ Runtime: no memory allocated   │
└───────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do unit-like structs store data at runtime? Commit to yes or no.

Common Belief: Unit-like structs store some hidden data even if no fields are declared.

Reality: Unit-like structs are zero-sized types and do not occupy any memory at runtime.

Why it matters: Believing they use memory can lead to inefficient designs or misunderstandings about performance.

Quick: Can unit-like structs be instantiated with different values? Commit to yes or no.

Common Belief: You can create multiple distinct instances of a unit-like struct with different data.

Reality: Unit-like structs have exactly one possible value; they carry no data and cannot differ.

Why it matters: Expecting different instances can cause confusion when trying to store or compare them.

Quick: Are unit-like structs only useful for empty placeholders? Commit to yes or no.

Common Belief: Unit-like structs are just empty placeholders with no practical use.

Reality: They are powerful tools for marking types, enabling compile-time checks, and zero-cost abstractions.

Why it matters: Ignoring their usefulness can lead to less safe or less expressive code.

Quick: Can unit-like structs have methods and implement traits? Commit to yes or no.

Common Belief: Since they have no data, unit-like structs cannot have methods or implement traits.

Reality: They can have methods and implement traits just like any other struct.

Why it matters: Missing this limits how you can use unit-like structs in real-world Rust code.

Expert Zone

1

Unit-like structs can be used as marker types in generic programming to enable or disable functionality at compile time without runtime cost.

2

Because they are zero-sized, unit-like structs can be used in tuples or arrays without increasing memory usage, enabling efficient type-level programming.

3

Implementing traits on unit-like structs allows you to attach behavior to concepts rather than data, which is a powerful design pattern in Rust.

When NOT to use

Avoid using unit-like structs when you need to store actual data or multiple distinct values. Instead, use classic structs with fields or enums. Also, if you need runtime polymorphism with data, consider trait objects or enums.

Production Patterns

In production Rust code, unit-like structs are commonly used as marker types for traits to enforce compile-time constraints, as zero-sized types in generic parameters to optimize performance, and as simple flags or tags in APIs to improve code clarity and safety.

Connections

Zero-sized types (ZSTs)

Unit-like structs are a specific example of zero-sized types in Rust.

Understanding unit-like structs helps grasp the broader concept of zero-sized types, which are key to Rust's zero-cost abstractions.

Type-level programming

Unit-like structs enable encoding information purely at the type level without runtime data.

Knowing unit-like structs clarifies how Rust uses types to enforce rules and constraints at compile time.

Mathematics: Singleton sets

Unit-like structs correspond to singleton sets containing exactly one element.

Recognizing this connection helps understand why unit-like structs have exactly one value and how they represent unique concepts.

Common Pitfalls

#1 Trying to store data in a unit-like struct.

Wrong approach:

struct Marker;
let m = Marker { value: 5 };

Correct approach:

struct Marker;
let m = Marker;

Root cause:

Misunderstanding that unit-like structs cannot have fields or store data.

#2 Assuming unit-like structs consume memory like normal structs.

Wrong approach:

let arr = [Marker; 1000]; // expecting large memory usage

Correct approach:

let arr = [Marker; 1000]; // zero-sized, no extra memory used

Root cause:

Not knowing that unit-like structs are zero-sized types optimized away by the compiler.

#3 Not implementing traits on unit-like structs to add behavior.

Wrong approach:

struct Flag;
// no impl block, so no methods

Correct approach:

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

Root cause:

Believing unit-like structs cannot have methods or behavior.

Key Takeaways

Unit-like structs are named types with no fields and exactly one possible value.

They are zero-sized types, meaning they use no memory at runtime but carry important type information.

Unit-like structs are powerful for marking types, enabling compile-time checks, and adding behavior without data.

Understanding unit-like structs unlocks advanced Rust patterns like marker traits and zero-cost abstractions.

They help write clearer, safer, and more efficient Rust code by separating type meaning from 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