Deep Dive into Rust's Sized Trait and Dynamically Sized Types

Introduction

Rust is a systems programming language known for its safety and performance. In Rust, determining the size of types at compile time is critically important. However, some types do not have a known size at compile time, which introduces the concept of dynamically sized types (DST) in Rust. To ensure that the size of a type can be known at compile time, Rust introduces the Sized trait.

This article will delve into the Sized trait in Rust, including its definition, purpose, usage, and how it relates to dynamically sized types.

What Is the Sized Trait?

In Rust, Sized is a special trait that indicates whether a type's size is known at compile time. The Sized trait is defined as follows:

pub trait Sized {
    // This trait has no methods; it's used to indicate that a type has a known size
}

It's important to note that all types are Sized by default, unless explicitly marked as dynamically sized using special syntax.

Relationship Between Dynamically Sized Types and the Sized Trait

In Rust, dynamically sized types (DSTs) are special types whose size cannot be determined at compile time and must be known at runtime. The main examples of DSTs are reference types and trait objects. The Sized trait serves as an indicator of whether a type has a known size at compile time.

Reference Types and the Sized Trait

Reference types are one form of dynamically sized types in Rust. In Rust, a reference is created using & to refer to the value of another type. The size of a reference type itself is not based on the referenced value’s size.

fn main() {
    let x = 42;
    let reference = &x; // Reference to x
}

In the above example, we create a variable x, then use & to create a reference reference to the value of x. The size of the reference itself does not depend on the size of the referenced value.

However, reference types are not considered DSTs because the size of a reference (&T) is always fixed — it is the size of a pointer. This is because the referenced value lives elsewhere (typically on the stack or heap), and only the reference is stored.

Trait Objects and the Sized Trait

Trait objects are another kind of dynamically sized type in Rust. Trait objects allow values of different concrete types to be handled through a common interface (a trait). The size of a trait object is not known at compile time because it depends on the specific type being referenced.

trait Shape {
    fn area(&self) -> f64;
}

struct Circle {
    radius: f64,
}

impl Shape for Circle {
    fn area(&self) -> f64 {
        self.radius * self.radius * std::f64::consts::PI
    }
}

fn main() {
    let circle: Circle = Circle { radius: 5.0 };
    let shape: &dyn Shape = &circle; // Reference to concrete type via trait object
}

In the example above, we define a trait Shape and implement it for the Circle struct. We then create a trait object &dyn Shape to refer to a value of the concrete type Circle. Because the actual size depends on the concrete type, the size of the trait object is not known at compile time.

Trait objects contain a hidden pointer to the concrete value and use it to invoke methods. As a result, the size of a &dyn Trait is always that of a pointer.

Limitations of the Sized Trait

In Rust, dynamically sized types (DSTs) have some restrictions, especially when used with generics and trait implementations.

Limitations in Generics

When using generics with DSTs, you must explicitly allow for unsized types using the ?Sized syntax.

// Incorrect: cannot use DST as a generic parameter
fn process_data<T>(data: &[T]) {
    // Process data
}

fn main() {
    let vec_data = vec![1, 2, 3, 4, 5];
    process_data(&vec_data); // Compile error: DST cannot be used as a generic parameter
}

In the incorrect example above, we attempted to use the DST [T] as a parameter in a generic function, which is not allowed by default. To allow for DSTs, we must mark the generic parameter with ?Sized.

// Correct: allowing DST as a generic parameter
fn process_data<T: ?Sized>(data: &[T]) {
    // Process data
}

fn main() {
    let vec_data = vec![1, 2, 3, 4, 5];
    process_data(&vec_data); // Correct: DST used as a generic parameter
}

In this correct example, the use of ?Sized on the type parameter T permits it to be a dynamically sized type.

Limitations in Trait Implementations

For safety reasons, when implementing a trait for a DST in Rust, you must use the ?Sized syntax to allow unsized types. This is because for trait objects, the compiler must determine the size of the concrete type at runtime, not compile time.

trait Shape {
    fn area(&self) -> f64;
}

struct Circle {
    radius: f64,
}

impl Shape for Circle {
    fn area(&self) -> f64 {
        self.radius * self.radius * std::f64::consts::PI
    }
}

// Incorrect: cannot implement a trait for a DST without `?Sized`
impl Shape for dyn Shape {
    fn area(&self) -> f64 {
        // Implement trait method
    }
}

fn main() {
    let circle: Circle = Circle { radius: 5.0 };
    let shape: &dyn Shape = &circle;
    shape.area();
}

In the incorrect example, we attempted to implement the Shape trait directly for dyn Shape, which is not allowed.

// Correct: implement trait for DST using `?Sized`
impl Shape for dyn Shape + ?Sized {
    fn area(&self) -> f64 {
        // Implement trait method
    }
}

fn main() {
    let circle: Circle = Circle { radius: 5.0 };
    let shape: &dyn Shape = &circle;
    shape.area();
}

In the correct example, ?Sized is used to indicate that dyn Shape may be dynamically sized, thus allowing trait implementation for it.

Usage

Checking Whether a Type Implements the Sized Trait

In Rust, you can use functions like std::mem::size_of to infer whether a type is Sized.

fn main() {
    println!("i32 is Sized: {}", std::mem::size_of::<i32>() == std::mem::size_of::<i32>());
    println!("&i32 is Sized: {}", std::mem::size_of::<&i32>() == std::mem::size_of::<usize>());
}

In the example above, we use size_of to compare type sizes. Since i32 is a Sized type, the output is true. The reference type &i32 is also Sized, because the size of a reference is always that of a pointer (usually the same as usize).

Constraining Generics with the Sized Trait

You can explicitly constrain generic parameters to only accept Sized types.

fn process_data<T: Sized>(data: &[T]) {
    // Process data
}

fn main() {
    let vec_data = vec![1, 2, 3, 4, 5];
    process_data(&vec_data); // Valid: only `Sized` types allowed as generic parameters
}

In the example above, the process_data function only accepts types that implement the Sized trait as its generic parameter T.

Using ?Sized to Support Dynamically Sized Types

If you want a trait to support DSTs, you can mark it with ?Sized.

trait Shape {
    fn area(&self) -> f64;
}

struct Circle {
    radius: f64,
}

impl Shape for Circle {
    fn area(&self) -> f64 {
        self.radius * self.radius * std::f64::consts::PI
    }
}

impl Shape for dyn Shape + ?Sized {
    fn area(&self) -> f64 {
        // Implement trait method
    }
}

fn main() {
    let circle: Circle = Circle { radius: 5.0 };
    let shape: &dyn Shape = &circle;
    shape.area();
}

In the above example, we used ?Sized to indicate that dyn Shape can be a DST, which makes it possible to implement the trait for it.

Comparison Between Dynamically Sized Types and the Sized Trait

Although dynamically sized types (DSTs) and the Sized trait both relate to the concept of type size, they have different meanings and purposes.

A dynamically sized type is a special kind of type whose size cannot be determined at compile time and must instead be resolved at runtime based on the actual data. DSTs mainly include reference types and trait objects. When working with DSTs, it’s important to be aware of their limitations — such as the fact that they cannot be directly instantiated and their use in generics is restricted.

On the other hand, the Sized trait is a special trait used to indicate whether a type’s size is known at compile time. All types in Rust are Sized by default unless explicitly marked otherwise. The Sized trait is particularly useful in generics and trait implementations for ensuring type safety regarding size constraints.

Conclusion

This article provided an in-depth explanation and analysis of the Sized trait in Rust, including its definition, purpose, usage, and its relationship with dynamically sized types.

The Sized trait plays an important role in Rust by ensuring that type sizes are known at compile time. By understanding and properly using the Sized trait, you can write safer and more efficient code.

---

We are Leapcell, your top choice for hosting Rust projects.

Leapcell is the Next-Gen Serverless Platform for Web Hosting, Async Tasks, and Redis:

Multi-Language Support

• Develop with Node.js, Python, Go, or Rust.

Deploy unlimited projects for free

• pay only for usage — no requests, no charges.

Unbeatable Cost Efficiency

• Pay-as-you-go with no idle charges.
• Example: $25 supports 6.94M requests at a 60ms average response time.

Streamlined Developer Experience

• Intuitive UI for effortless setup.
• Fully automated CI/CD pipelines and GitOps integration.
• Real-time metrics and logging for actionable insights.

Effortless Scalability and High Performance

• Auto-scaling to handle high concurrency with ease.
• Zero operational overhead — just focus on building.

Explore more in the Documentation!

Follow us on X: @LeapcellHQ