Support Borrow trait so UniCase can be used as a hashmap key

[lilith]

HashMap<UniCase<String>,String>::get(UniCase<&str>)

[Ryman]

For reference: there were issues with the soundness of this previously, it might be worth reinvestigating: #6

[lilith]

This works, but soundness is reliant on repr(transparent), which isn't implemented yet.
The heavy reliance on AsRef instead of Borrow means that most code would have to be duplicated.

Enums like Encoding also aren't compatible with this strategy.

impl Ascii<str> {
    fn borrowed(s: &str) -> &Self {
        unsafe {
            &*(s as *const str as *const Ascii<str>)
        }
    }
}

impl Borrow<Ascii<str>> for Ascii<String> {
    #[inline]
    fn borrow(&self) -> &Ascii<str> { Ascii::borrowed(&self.0) }
}

The approach in #6 still produces the same error. It also looks specific to Cow<>.

I'm currently using this instead:

// TODO: uncomment this when support lands in rustc for improved safety
//#[repr(transparent)]
#[derive(Copy,Clone,Debug)]
pub struct AsciiFolding<S: ?Sized>(S);

impl<S> AsciiFolding<S> {
    pub fn new(s: S) -> Self {
       AsciiFolding(s)
    }
}

impl<S: AsRef<str>> AsRef<str> for AsciiFolding<S> {
    #[inline]
    fn as_ref(&self) -> &str {
        self.0.as_ref()
    }
}

impl<S: fmt::Display> fmt::Display for AsciiFolding<S> {
    #[inline]
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt::Display::fmt(&self.0, fmt)
    }
}

impl<S: ?Sized> AsciiFolding<S> {
    pub fn borrowed(s: &S) -> &Self {
        unsafe { &*(s as *const S as *const AsciiFolding<S>) }
    }
}

impl Borrow<AsciiFolding<str>> for AsciiFolding<String> {
    #[inline]
    fn borrow(&self) -> &AsciiFolding<str> {
        AsciiFolding::borrowed(self.0.borrow())
    }
}

impl<S: Borrow<str> + ?Sized> PartialEq for AsciiFolding<S> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.0.borrow().eq_ignore_ascii_case(other.0.borrow())
    }
}

impl<S: Borrow<str> + ?Sized> Eq for AsciiFolding<S> {}

impl<S: Borrow<str> + ?Sized> Hash for AsciiFolding<S> {
    #[inline]
    fn hash<H: Hasher>(&self, hasher: &mut H) {
        for byte in self.0.borrow().bytes().map(|b| b.to_ascii_lowercase()) {
            hasher.write_u8(byte);
        }
    }
}

#[test]
fn test_hashmap_key() {
    let mut m = std::collections::HashMap::new();
    m.insert(AsciiFolding("v".to_owned()), "value");

    m.get(AsciiFolding::borrowed("v")).unwrap();
}

[troiganto]

Since repr(transparent) now exists (since 1.28.0), does this mean this is unblocked now? What would have to be done to get this into unicase?

[rushmorem]

I recently needed this. To work around it, I wrapped UniCase in an enum AnyCase:

enum AnyCase<'a> {
    Owned(UniCase<String>),
    Borrowed(UniCase<&'a str>),
}

This way, I can use the Owned variant (and 'static Borrowed) for insertions and the Borrowed one for lookups.

[vallentin]

Another alternative solution is also HashMap<UniCase<Cow<str>>, _> and then do .get(&UniCase::new(Cow::Borrowed(...)))

[rushmorem]

You are right. That was basically Cow. I have dropped the anycase module. Thanks for pointing that out!

[ijackson]

What we want is &Unicase<str> which would be a fat pointer like &str. But this is not really doable.

The problem is that Borrow requires that the returned pointer (&Unicase<str>, we are imagining) borrows only data from the original input. But <Unicase<String> as Borrow<Unicase<str>> has to borrow the discriminant, and also the actual string data, but they are in separate places.

In principle I think it might be possible to make some kind of custom fat pointer using the unstable pointer metadata API, but it would involve unsafe and be extremely hairy (and I can't see how to avoid stealing a bit from the length, since where else is that bit going to live?).

An alternative would be to have a nonoptimised UnicaseNoOpt<str> which could be transparent, so that &'s UnicaseNoOpt<str> can be made from &'s str with one transmute. (I like newtype wrappers around str so I do this quite often and it works well.) It is always fine to treat an ascii-only Unicase as a needing-unicode one, so this would be algorithmically correct. It would then be straightforward to impl Borrow<UnicaseNoOpt<str>> for Unicase<String>. The downside is that the optimisation goes away and also it would involve a new newtype with a whole matrix of trait impls and conversion methods and so on.

I may experiment with this.