Generic function for both OsStr and Path

[marcus_rs]

Hello,

Could you please tell me, is it possible to write a generic function that take OsStr(ing) and Path(Buf) and return OsStr/Path?

I'm trying to write strip_prefix and split_once that work some as the &str functions. So far I was able to write strip_prefix that works:

pub trait OsStrUtil {
    fn osstr_strip_prefix(&self, prefix: &OsStr) -> Option<&OsStr>;
}
impl<Y> OsStrUtil for Y
where
    Y: ?Sized + AsRef<OsStr>,
{
    fn osstr_strip_prefix(&self, prefix: &OsStr) -> Option<&OsStr> {
        self.as_ref()
            .as_bytes()
            .strip_prefix(prefix.as_bytes())
            .map(|inp| OsStr::from_bytes(inp))
    }
}

pub trait PathUtil {
    fn path_strip_prefix(&self, prefix: &Path) -> Option<&Path>;
}
impl<Y> PathUtil for Y
where
    Y: ?Sized + AsRef<Path>,
{
    fn path_strip_prefix(&self, prefix: &Path) -> Option<&Path> {
        self.as_ref()
            .as_os_str()
            .as_bytes()
            .strip_prefix(prefix.as_os_str().as_bytes())
            .map(|inp| Path::new(OsStr::from_bytes(inp)))
    }
}

fn main() {
    let x = OsStr::new("abcdef");
    let x = x.osstr_strip_prefix(OsStr::new("abc"));
    assert_eq!(x, Some(OsStr::new("def")));

    let x = Path::new("abcdef");
    let x = x.path_strip_prefix(Path::new("abc"));
    assert_eq!(x, Some(Path::new("def")));
}

but I was unable to create a single generic function without compiler complaining about something.

Maybe that's not possible and that's OK too!

Thank you!

[drewtato]

How about this

pub fn strip_prefix<'a, S>(s: &'a S, prefix: &S) -> Option<&'a S>
where
    S: AsRef<OsStr> + ?Sized,
    OsStr: AsRef<S>,
{
    s.as_ref()
        .as_bytes()
        .strip_prefix(prefix.as_ref().as_bytes())
        .map(|inp| OsStr::from_bytes(inp).as_ref())
}

[marcus_rs]

That's awesome @drewtato ! Thank you! I had no idea I can write OsStr: AsRef<S>.

Do you know what's wrong with the trait implementation? For some reason I have problems to turn it into a trait...

pub trait OsStrUtil<S> {
    fn strip_prefix<'a>(&'a self, prefix: &S) -> Option<&'a S>
    where
        Self: AsRef<OsStr>,
        S: AsRef<OsStr>,
        OsStr: AsRef<S>;
}
impl<S> OsStrUtil<S> for S {
    fn strip_prefix<'a>(&'a self, prefix: &S) -> Option<&'a S>
    where
        Self: AsRef<OsStr>,
        S: AsRef<OsStr>,
        OsStr: AsRef<S>,
    {
        self.as_ref()
            .as_bytes()
            .strip_prefix(prefix.as_ref().as_bytes())
            .map(|inp| OsStr::from_bytes(inp).as_ref())
    }
}

fn main() {
    let x = OsStr::new("abcdef");
    let x = x.strip_prefix(OsStr::new("abc"));
    assert_eq!(x, Some(OsStr::new("def")));

    let x = Path::new("abcdef");
    let x = x.strip_prefix(Path::new("abc"));
    assert_eq!(x, Some(Path::new("def")));
}

[drewtato]

I'd probably do it like this:

pub trait OsStrUtil: AsRef<OsStr>
where
    OsStr: AsRef<Self>,
{
    fn strip_prefix<'a>(&'a self, prefix: &Self) -> Option<&'a Self>;
}

impl<S> OsStrUtil for S
where
    S: AsRef<OsStr> + ?Sized,
    OsStr: AsRef<Self>,
{
    fn strip_prefix<'a>(&'a self, prefix: &Self) -> Option<&'a Self> {
        self.as_ref()
            .as_bytes()
            .strip_prefix(prefix.as_ref().as_bytes())
            .map(|inp| OsStr::from_bytes(inp).as_ref())
    }
}

Or if you want to be able to pass a different prefix type than Self, you can put a generic on the function.

pub trait OsStrUtil: AsRef<OsStr>
where
    OsStr: AsRef<Self>,
{
    fn strip_prefix<'a, P: AsRef<OsStr> + ?Sized>(&'a self, prefix: &P) -> Option<&'a Self>;
}

impl<S> OsStrUtil for S
where
    S: AsRef<OsStr> + ?Sized,
    OsStr: AsRef<Self>,
{
    fn strip_prefix<'a, P: AsRef<OsStr> + ?Sized>(&'a self, prefix: &P) -> Option<&'a Self> {
        self.as_ref()
            .as_bytes()
            .strip_prefix(prefix.as_ref().as_bytes())
            .map(|inp| OsStr::from_bytes(inp).as_ref())
    }
}

[marcus_rs]

Thank you very much @drewtato . Unfortunately there is a problem converting into Path

fn main() {
    let x = OsStr::new("abcdef");
    let x = x.strip_prefix(OsStr::new("abc"));
    assert_eq!(x, Some(OsStr::new("def")));

    let x = Path::new("abcdef");
    let x = x.strip_prefix(Path::new("abc"));
    assert_eq!(x, Some(Path::new("def")));
    //            ^^^^^^^^^^^^^^^^^^^^^^ expected `Result<&Path, StripPrefixError>`, found `Option<&Path>`
}

That probably has something to do with more restrictions on Path...

[parasyte]

That's because Path has an inherent method with the same name but returns a different value. Changing the method name in your extension trait is the simplest solution.

[marcus_rs]

Yes, thank you very much folks!

pub trait OsStrUtil: AsRef<OsStr>
where
    OsStr: AsRef<Self>,
{
    fn strip_prefix_os<'a, P: AsRef<OsStr> + ?Sized>(&'a self, prefix: &P) -> Option<&'a Self>;
}

impl<S> OsStrUtil for S
where
    S: AsRef<OsStr> + ?Sized,
    OsStr: AsRef<Self>,
{
    fn strip_prefix_os<'a, P: AsRef<OsStr> + ?Sized>(&'a self, prefix: &P) -> Option<&'a Self> {
        self.as_ref()
            .as_bytes()
            .strip_prefix(prefix.as_ref().as_bytes())
            .map(|inp| OsStr::from_bytes(inp).as_ref())
    }
}

fn main() {
    let x = OsStr::new("abcdef");
    let x = x.strip_prefix_os(OsStr::new("abc"));
    assert_eq!(x, Some(OsStr::new("def")));

    let x = Path::new("abcdef");
    let x = x.strip_prefix_os(Path::new("abc"));
    assert_eq!(x, Some(Path::new("def")));
}

[marcus_rs]

@parasyte , @drewtato do you think you could please help me with the second function? I thought split_once will be easy after strip_prefix but apparently not

use std::ffi::OsStr;
use std::os::unix::ffi::OsStrExt;
use std::path::Path;

pub trait OsStrUtil: AsRef<OsStr>
where
    OsStr: AsRef<Self>,
{
    fn split_once_os<'a, P: AsRef<OsStr> + ?Sized>(&'a self, separator: &P) -> Option<(&'a Self, &'a Self)>;
}

impl<S> OsStrUtil for S
where
    S: AsRef<OsStr> + ?Sized,
    OsStr: AsRef<Self>,
{
    fn split_once_os<'a, P: AsRef<OsStr> + ?Sized>(&'a self, separator: &P) -> Option<(&'a Self, &'a Self)> {
        self.as_ref()
            .as_bytes()
            //////////////
            ////.split_once(separator.as_ref().as_bytes())
            ///  use of unstable library feature 'slice_split_once': newly added
            //////////////
            .map(|(left, right)| (OsStr::from_bytes(left).as_ref(), OsStr::from_bytes(right).as_ref()))
    }
}

fn main() {
    let x = OsStr::new("abcdef");
    let x = x.split_once_os(OsStr::new("cd"));
    assert_eq!(x, Some((OsStr::new("ab"), OsStr::new("ef"))));

    let x = Path::new("abcdef");
    let x = x.split_once_os(Path::new("cd"));
    assert_eq!(x, Some((Path::new("ab"), Path::new("ef"))));
}

[drewtato]

split_once doesn't even do what you want it to, it takes a single element while you want to split on a string. You just have to do it yourself.

fn split_once_os<'a, P: AsRef<OsStr> + ?Sized>(
    &'a self,
    separator: &P,
) -> Option<(&'a Self, &'a Self)> {
    let slice = self.as_ref().as_bytes();
    let separator = separator.as_ref().as_bytes();

    let index = std::iter::successors(Some(slice), |slice| slice.get(1..))
        .map_while(|slice| slice.get(..separator.len()))
        .position(|slice| slice == separator)?;

    let (left, rest) = slice.split_at(index);
    let right = &rest[separator.len()..];

    Some((
        OsStr::from_bytes(left).as_ref(),
        OsStr::from_bytes(right).as_ref(),
    ))
}

[marcus_rs]

That's fantastic, thank you.