Struct mownstr::MownStr

pub struct MownStr<'a>(_);

"Maybe own str":Option either a borrowed reference to a str or an own Box<str>.

It does not try to be mutable, nor generic, which makes it lighter than, for example, Cow<str>.

Panic

The drawback is that MownStr does not support strings with a length > usize::MAX/2. Trying to convert such a large string to a MownStr will panic.

Methods

impl<'a> MownStr<'a>

pub fn is_borrowed(&self) -> bool

pub fn is_owned(&self) -> bool

impl<'a> MownStr<'a>

pub fn to<T>(self) -> T where
    T: From<&'a str> + From<Box<str>>, 

Convert this MownStr to ant type T that can be created from either a &str or a Box<str>.

This can not be implemented with the From trait, because this would conflict with From<MownStr<'a>>.

Usage

let ms = MownStr::from("hello world");
let rc = ms.to::<Rc<str>>();

let o1 = Some(MownStr::from("hi there"));
let o2 = o1.map(MownStr::to::<Rc<str>>);

Trait Implementations

impl<'a> AsRef<str> for MownStr<'a>

fn as_ref(&self) -> &str

Performs the conversion.

impl<'a> Borrow<str> for MownStr<'a>

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl<'a> Clone for MownStr<'a>

fn clone(&self) -> MownStr<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for MownStr<'a>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'a> Deref for MownStr<'a>

type Target = str

The resulting type after dereferencing.

fn deref(&self) -> &str

Dereferences the value.

impl<'a> Display for MownStr<'a>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'a> Drop for MownStr<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> Eq for MownStr<'a>

impl<'a> From<&'a str> for MownStr<'a>

fn from(other: &'a str) -> MownStr<'a>

Performs the conversion.

impl<'a> From<Box<str>> for MownStr<'a>

fn from(other: Box<str>) -> MownStr<'a>

Performs the conversion.

impl<'a> From<Cow<'a, str>> for MownStr<'a>

fn from(other: Cow<'a, str>) -> MownStr<'a>

Performs the conversion.

impl<'a> From<MownStr<'a>> for Box<str>

fn from(other: MownStr<'a>) -> Box<str>

Performs the conversion.

impl<'a> From<MownStr<'a>> for String

fn from(other: MownStr<'a>) -> String

Performs the conversion.

impl<'a> From<MownStr<'a>> for Cow<'a, str>

fn from(other: MownStr<'a>) -> Cow<'a, str>

Performs the conversion.

impl<'a> From<String> for MownStr<'a>

fn from(other: String) -> MownStr<'a>

Performs the conversion.

impl<'a> Hash for MownStr<'a>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<'a> Ord for MownStr<'a>

fn cmp(&self, other: &MownStr<'a>) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<'a> PartialEq<&'a str> for MownStr<'a>

fn eq(&self, other: &&'a str) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<MownStr<'a>> for MownStr<'a>

fn eq(&self, other: &MownStr<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialEq<MownStr<'a>> for &'a str

fn eq(&self, other: &MownStr<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a> PartialOrd<&'a str> for MownStr<'a>

fn partial_cmp(&self, other: &&'a str) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> PartialOrd<MownStr<'a>> for MownStr<'a>

fn partial_cmp(&self, other: &MownStr<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> PartialOrd<MownStr<'a>> for &'a str

fn partial_cmp(&self, other: &MownStr<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.