use std::borrow::{Borrow, BorrowMut};
use std::fmt::Debug;
use std::fmt::Error;
use std::fmt::Formatter;
use std::borrow::ToOwned;
use std::ops::{Deref, DerefMut};

#[derive(PartialEq, Eq)]
struct MyString(String);

impl Debug for MyString {
    fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
        write!(f, "MyString")
    }
}

impl From<String> for MyString {
    fn from(s: String) -> MyString {
        MyString(s)
    }
}

#[derive(PartialEq, Eq)]
struct MyStr(str);

impl<'a> Debug for &'a MyStr {
    fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
        write!(f, "MyStr")
    }
}

impl<'a> From<&'a str> for &'a MyStr {
    fn from(s: &'a str) -> &'a MyStr {
        unsafe { std::mem::transmute(s) }
    }
}

impl<'a> From<&'a mut str> for &'a mut MyStr {
    fn from(s: &'a mut str) -> &'a mut MyStr {
        unsafe { std::mem::transmute(s) }
    }
}

impl<'a> Borrow<MyStr> for MyString {
    fn borrow<'b>(&'b self) -> &'b MyStr {
        self.0.as_str().into()
    }
}

impl<'a> BorrowMut<MyStr> for MyString {
    fn borrow_mut<'b>(&'b mut self) -> &'b mut MyStr {
        self.0.as_mut_str().into()
    }
}

impl ToOwned for MyStr {
    type Owned = MyString;
    fn to_owned(&self) -> Self::Owned {
        MyString(self.0.to_owned())
    }
}

impl Deref for MyString {
    type Target = MyStr;
    fn deref(&self) -> &Self::Target {
        self.borrow()
    }
}

impl DerefMut for MyString {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.borrow_mut()
    }
}

fn main() {
    let s: MyString = "foo".to_string().into();
    println!("{:?}", s);
    let s: &MyStr = "foo".into();
    println!("{:?}", s);
}