Implement From and Into for str, String, borrowed and owned - rust

Question

I am trying to reduce the boilerplate in my code. I have tried to use Cow, Borrow or AsRef to combine these implementations together, but the compiler complains that Address does not implement the trait sized.
To implement all the cases &str vs String and Address vs &Address, my current code feels excessive
pub struct Address(String);
impl From<String> for Address {
fn from(bytes: String) -> Self {
Self(String::from_utf8(Vec::from(bytes)).unwrap())
}
}
impl From<String> for &Address {
fn from(bytes: String) -> Self {
&Address(String::from_utf8(Vec::from(bytes)).unwrap())
}
}
impl From<&str> for Address {
fn from(str: &str) -> Self {
Self(str.to_string())
}
}
impl From<&str> for &Address {
fn from(str: &str) -> Self {
&Address(str.to_string())
}
}
impl<'b> Into<&'b str> for Address {
fn into(self) -> &'b str {
self.0.as_str()
}
}
impl<'b> Into<&'b str> for &Address {
fn into(self) -> &'b str {
self.0.as_str()
}
}
impl<'b> Into<String> for Address {
fn into(self) -> String {
self.0.to_string()
}
}
impl<'b> Into<String> for &Address {
fn into(self) -> String {
self.0.to_string()
}
}

Answer 1

You should probably only have the following four impls:
pub struct Address(String);
impl From<String> for Address {
fn from(s: String) -> Self {
Self(s)
}
}
impl<'a> From<&'a str> for Address {
fn from(s: &'a str) -> Self {
Address(s.to_string())
}
}
impl From<Address> for String {
fn from(a: Address) -> Self {
a.0
}
}
impl<'a> From<&'a Address> for &'a str {
fn from(a: &'a Address) -> Self {
&a.0
}
}

Answer 2

String::from_utf8(Vec::from(bytes)).unwrap() makes no sense. bytes in your case is already a UTF8 String, so this entire line is redundant. Did you mean bytes to be Vec<u8>?
impl From<X> for &Address makes no sense. References don't own an object, and someone has to own the Address object. impl From<X> for Address is what you really want and already have.
impl Into<&str> makes no sense, Into takes ownership. You can't consume an object and then return a reference to it. Again, someone has to own it. You probably want AsRef<str> and Deref<Target=str>.
impl Into<String> for &Address is also unusual. AsRef<str> and Deref<Target=str> is sufficient for almost all cases, and if you want a consuming conversion, use impl From<Address> for String. Never implement Into, always implement From instead. (From implies Into)
So this is what I would do:
use std::ops::Deref;
pub struct Address(String);
impl From<String> for Address {
fn from(s: String) -> Self {
Self(s)
}
}
impl From<&str> for Address {
fn from(s: &str) -> Self {
Self(s.to_string())
}
}
impl AsRef<str> for Address {
fn as_ref(&self) -> &str {
&self.0
}
}
impl Deref for Address {
type Target = str;
fn deref(&self) -> &str {
&self.0
}
}
// Unusual, but of course possible:
impl From<Address> for String {
fn from(addr: Address) -> String {
addr.0
}
}
This is how to perform the conversions then, which is in line with usual Rust behaviour:
fn main() {
// String to Address
let s: String = "AAA".to_string();
let _addr: Address = s.into();
//or
let s: String = "AAA".to_string();
let _addr = Address::from(s);
// &str to Address
let s: &str = "AAA";
let _addr: Address = s.into();
// or
let _addr = Address::from(s);
// Address to &str
let addr: Address = Address("AAA".to_string());
let _s: &str = &addr;
// Address to String
let addr: Address = Address("AAA".to_string());
let _s: String = addr.to_string();
// Or also:
let _s: String = addr.into();
}