What is a Rust wrapper type with a public inner?

In Rust, a wrapper type with a public inner field is a struct or enum that encapsulates another type, making the inner type accessible directly through a public field. This pattern is often used to add functionality or constraints to an existing type without modifying it directly.

Here's a breakdown of what this means:

Wrapper Type: A wrapper type is a type that holds another type within it. It's a way to add a layer of abstraction or to provide additional behavior to an existing type.

Public Inner Field: The "inner" field refers to the field within the wrapper type that holds the wrapped value. When this field is declared as `pub`, it means that it can be accessed directly from outside the wrapper type.

Example:

struct PublicWrapper {
  pub inner: i32,
}

fn main() {
  let wrapper = PublicWrapper { inner: 42 };
  println!("The inner value is: {}", wrapper.inner); // Accessing the public inner field
}

In this example, `PublicWrapper` is a struct that wraps an `i32`. The `inner` field is declared as `pub`, so it can be accessed directly using the dot operator (`.`) from outside the struct.

Use Cases:

1. Newtype Pattern: This is a common use case where you want to create a new type that is semantically different from the underlying type, even though they have the same representation. For example, you might have a `struct Miles(f64)` and a `struct Kilometers(f64)`, both wrapping `f64`, but representing different units.

2. Adding Methods: You can add methods to the wrapper type to provide additional functionality without modifying the original type. This is particularly useful when you don't own the original type.

3. Enforcing Constraints: You can use the wrapper type to enforce constraints on the inner value. For example, you might have a wrapper that only allows positive numbers.

4. Type Safety: By wrapping a type, you can create a more specific type that prevents accidental mixing of values that should be treated differently.

Considerations:

While making the inner field public provides direct access, it also means that the wrapper type loses some control over how the inner value is used. If you need to enforce invariants or provide controlled access, you might prefer to use methods to access or modify the inner value instead of making it public.

In summary, a Rust wrapper type with a public inner field is a way to encapsulate a value while still allowing direct access to it. This pattern is useful for creating new types, adding functionality, and enforcing constraints, but it should be used judiciously to maintain control over the wrapped value.

Learn more about this