Create a type that is basically String, but incompatible with String?

user_1091116 0
Viewed 152

I noticed that in my projects, I use a lot of String types where I don't really mean Strings, but specific types of values contained within a String, that can't be told apart e.g. by using regular expressions, but should be differentiated from a code perspective. Is there a way to make compiler help me? For example, consider this function:

fn do_something(val1: String, val2: String) {}

fn main() {
    let val1: String = "hello";
    let val2: String = "hello2";
    do_something(val1, val2);
}

Is there a way to create SpecificStringType1 and SpecificStringType2 so the first do_something call compiles, but the second doesn't?

fn do_something(val1: SpecificStringType1, val2: SpecificStringType2) {}

fn main() {
    let val1: SpecificStringType1 = "hello";
    let val2: SpecificStringType2 = "hello2";
    let val3: SpecificStringType2 = "hello2";
    let val4: SpecificStringType2 = "hello2";
    do_something(val1, val2);
    do_something(val3, val4);
}
rust types
2 Answers

You could just wrap String with a tuple struct, creating a new distinct type:

// This is a custom type which just wraps String,
// however you can choose what it derives again.
#[derive(Clone, Debug)]
struct MyString(String);

// Since they are distinct types, type check will prevent using
// String as MyString and vice versa.
fn f1(s: &String, t: &String) -> bool {
    return true;    
}

fn f2(s: &String, t: &MyString) -> bool {
    return false;
}

fn main() {
    let s: String = "hello".to_string();
    let ms = MyString("goodbye".to_string());
    let MyString(ms_inner) = ms.clone();

    println!("{:?}", &s);
    println!("{:?}", &ms);

    // Here is proof that it works.
    println!("{}", f1(&s, &ms_inner));
    println!("{}", f2(&s, &ms));
}

https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=a32994fab2cabb6495807726f246da1e

user_38198500

Tuple struct

Someone already graciously answered with this newtype pattern. I provide boilerplate for a simple api and automatic deconstruction. Run the code on play.rust...

struct SpecificStringType1(&'static str);
struct SpecificStringType2(&'static str);

fn do_something(x: SpecificStringType1, y: SpecificStringType2) {
    let val_1: String = x.to_string(); // No expensive cloning.
    let val_2: &str = y.as_str(); // No runtime penalty.

    println!("{}", val_1);
    println!("{}", val_2);
}

fn main() {
     let val_1 = SpecificStringType1("hello");
     let val_2 = SpecificStringType2("hello2");

     do_something(val_1, val_2);
     //do_something(val_1, val_1);
}

impl SpecificStringType1 {
    fn to_string(&self) -> String {
        let SpecificStringType1(value) = self;
        value.to_string()
    }

    fn as_str(&self) -> &str {
        let SpecificStringType1(value) = self;
        &value
    }
}

impl SpecificStringType2 {
    fn to_string(&self) -> String {
        let SpecificStringType2(value) = self;
        value.to_string()
    }

    fn as_str(&self) -> &str {
        let SpecificStringType2(value) = self;
        &value
    }
}

FromStr trait

Run the code on play.rust...

use std::str::FromStr;
use std::fmt;

fn do_something(x: SpecificStringType1, y: SpecificStringType2) {
    let x_string = x.to_string();
    let y_string = y.to_string();

    println!("{}", x_string);
    println!("{}", y_string);
}


fn main() {
    let val_1: SpecificStringType1 = "hello".parse().unwrap();
    let val_2: SpecificStringType2 = "hello_2".parse().unwrap();
    let val_3: SpecificStringType2 = "hello_2".parse().unwrap();
    let val_4: SpecificStringType2 = "hello".parse().unwrap();

    do_something(val_1, val_2);
    //do_something(val_3, val_4);

    assert_eq!(val_3.to_string(), "hello_2".to_string());
    assert_eq!(&val_4.to_string(), "hello");
    //assert_eq!(
    //    "hello",
    //    "hello".parse::<SpecificStringType1>().unwrap()
    //)
}

#[derive(Debug, PartialEq)]
struct SpecificStringType1 {
    value: String
}

#[derive(Debug, PartialEq)]
struct SpecificStringType2 {
    value: String
}

impl FromStr for SpecificStringType1 {
    type Err = ();

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(SpecificStringType1 {
            value: s.to_string()
        })
    }
}

impl FromStr for SpecificStringType2 {
    type Err = ();

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(SpecificStringType2 {
            value: s.to_string()
        })
    }
}

impl fmt::Display for SpecificStringType1 {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        let str = self.value.as_ref();
        fmt.write_str(str)
    }
}

impl fmt::Display for SpecificStringType2 {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        let str = self.value.as_ref();
        fmt.write_str(str)
    }
}
user_100618640
Related