Rust中Scala value classes的等价机制及URI场景实现方案

Great question! Scala's value classes are fantastic for adding type safety without runtime bloat, and Rust has idiomatic ways to hit exactly the same goals—especially for wrapping strings like URIs. Let’s break down the best approaches for your use case:

1. The newtype Pattern (Rust’s "Value Class" Workhorse) #

Your initial idea of a single-field struct is actually Rust’s standard zero-overhead type safety tool, called the newtype pattern. Unlike some languages, Rust doesn’t add any runtime overhead to single-field structs (no extra object headers or indirection)—the compiler optimizes them to match the underlying type’s memory layout exactly.

To fix the "usage friction" you mentioned (like not fitting into places expecting String or &str), you can implement common traits to make your Uri type feel seamless:

Example Implementation #

// #[repr(transparent)] guarantees the struct has the exact same memory layout as String
#[repr(transparent)]
struct Uri(String);

// Enable automatic conversion to &str (works with any function expecting a string slice)
impl std::ops::Deref for Uri {
    type Target = str;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

// Easy conversion from String to Uri (no manual wrapping needed)
impl From<String> for Uri {
    fn from(raw_string: String) -> Self {
        Uri(raw_string)
    }
}

// Convert Uri back to String when you need ownership of the underlying data
impl Into<String> for Uri {
    fn into(self) -> String {
        self.0
    }
}

// Optional: Add validation logic to ensure the string is a valid URI
impl Uri {
    fn new(raw_string: String) -> Result<Self, &'static str> {
        if raw_string.starts_with("http://") || raw_string.starts_with("https://") {
            Ok(Self(raw_string))
        } else {
            Err("Invalid URI scheme: must start with http:// or https://")
        }
    }
}

How This Solves Your Problems #

• Zero Overhead: #[repr(transparent)] tells the compiler Uri is identical to String in memory. No extra allocations or runtime checks beyond what you explicitly add.
• Seamless Usage: Thanks to Deref, you can pass &Uri to any function expecting &str without manual conversion. From/Into traits make switching between Uri and String trivial.
• Type Safety: Function signatures will clearly signal when a Uri is required, preventing accidental use of arbitrary strings where a valid URI is needed.

2. Why Not Type Aliases? #

You might think type Uri = String; would work, but type aliases are just synonyms—Rust treats Uri and String as the exact same type. This means you lose the type safety you’re aiming for (you could pass any random String to a function expecting a Uri without checks). The newtype pattern avoids this by creating a distinct type.

3. Edge Case: Borrowed URI References #

If you only need to wrap borrowed strings (&str) instead of owned String, you can create a lightweight newtype for references:

#[repr(transparent)]
struct UriRef<'a>(&'a str);

impl<'a> std::ops::Deref for UriRef<'a> {
    type Target = str;
    fn deref(&self) -> &Self::Target {
        self.0
    }
}

This is even lighter, as it doesn’t involve ownership—perfect for cases where you just need to annotate a borrowed string as a URI.

内容的提问来源于stack exchange，提问作者Dominykas Mostauskis