Enum spinoso_symbol::CaseFold

pub enum CaseFold {
    Full,
    Ascii,
    Turkic,
    Lithuanian,
}

Available on crate feature artichoke only.

Unicode case folding strategies.

Unicode case folding data supports both implementations that require simple case foldings (where string lengths don’t change), and implementations that allow full case folding (where string lengths may grow). Note that where they can be supported, the full case foldings are superior: for example, they allow “MASSE” and “Maße” to match.

The CaseFold enum supports the folding strategies available in Ruby.

Examples

For Unicode text, the default folding scheme is Full. To make a comparison:

let fold = CaseFold::Full;
assert_eq!(fold.casecmp("MASSE", "Maße"), Ordering::Equal);
assert_eq!(fold.casecmp("São Paulo", "Sao Paulo"), Ordering::Greater);

assert!(fold.case_eq("MASSE", "Maße"));
assert!(!fold.case_eq("São Paulo", "Sao Paulo"));

For text known to be ASCII, Focaccia can make a more performant comparison check:

let fold = CaseFold::Ascii;
assert_eq!(fold.casecmp("Crate: focaccia", "Crate: FOCACCIA"), Ordering::Equal);
assert_eq!(fold.casecmp("Fabled", "failed"), Ordering::Less);

assert!(fold.case_eq("Crate: focaccia", "Crate: FOCACCIA"));
assert!(!fold.case_eq("Fabled", "failed"));

Turkic case folding is similar to full case folding with additional mappings for dotted and dotless I:

let fold = CaseFold::Turkic;
assert_eq!(fold.casecmp("İstanbul", "istanbul"), Ordering::Equal);
assert_ne!(fold.casecmp("İstanbul", "Istanbul"), Ordering::Equal);

assert!(fold.case_eq("İstanbul", "istanbul"));
assert!(!fold.case_eq("İstanbul", "Istanbul"));

Variants

Full

Full Unicode case mapping, suitable for most languages (see Turkic and Lithuanian strategies for exceptions). Context-dependent case mapping as described in Table 3-14 of the Unicode standard is currently not supported.

Ascii

Only the ASCII region, i.e. the characters “A” to “Z” and “a” to “z”, are affected.

Turkic

Full Unicode case mapping, adapted for Turkic languages (Turkish, Azerbaijani, …). This means that upper case I is mapped to lower case dotless i, and so on.

Lithuanian

Currently, just full Unicode case mapping. In the future, full Unicode case mapping adapted for Lithuanian (keeping the dot on the lower case i even if there is an accent on top).

Implementations

impl CaseFold

pub const fn new() -> CaseFold

Construct a new full Unicode case folding.

See CaseFold::Full.

Examples

const FOLD: CaseFold = CaseFold::new();

assert_eq!(CaseFold::new(), CaseFold::Full);

assert!(CaseFold::new().case_eq("MASSE", "Maße"));
assert!(!CaseFold::new().case_eq("São Paulo", "Sao Paulo"));

pub fn casecmp(self, left: &str, right: &str) -> Ordering

Make a case-insensitive string comparison based on the dispatching folding strategy.

Return Ordering::Equal if the given strings match when folding case. For example, when using CaseFold::Full, ß is considered equal to ss. The differences between the folding strategies are documented on the variants of the CaseFold enum.

This function is a wrapper around the underlying scheme-specific functions.

Examples – Full case folding

let fold = CaseFold::Full;
assert_eq!(fold.casecmp("MASSE", "Maße"), Ordering::Equal);
assert_eq!(fold.casecmp("São Paulo", "Sao Paulo"), Ordering::Greater);

Examples – ASCII case folding

let fold = CaseFold::Ascii;
assert_eq!(fold.casecmp("Crate: focaccia", "Crate: FOCACCIA"), Ordering::Equal);
assert_eq!(fold.casecmp("Fabled", "failed"), Ordering::Less);

Examples – Turkic case folding

let fold = CaseFold::Turkic;
assert_eq!(fold.casecmp("İstanbul", "istanbul"), Ordering::Equal);
assert_ne!(fold.casecmp("İstanbul", "Istanbul"), Ordering::Equal);

pub fn case_eq(self, left: &str, right: &str) -> bool

Make a case-insensitive string equality check based on the dispatching folding strategy.

Return true if the given strings match when folding case. For example, when using CaseFold::Full, ß is considered equal to ss. The differences between the folding strategies are documented on the variants of the CaseFold enum.

This function is a wrapper around the underlying scheme-specific functions.

Examples – Full case folding

let fold = CaseFold::Full;
assert!(fold.case_eq("MASSE", "Maße"));
assert!(!fold.case_eq("São Paulo", "Sao Paulo"));

Examples – ASCII case folding

let fold = CaseFold::Ascii;
assert!(fold.case_eq("Crate: focaccia", "Crate: FOCACCIA"));
assert!(!fold.case_eq("Fabled", "failed"));

Examples – Turkic case folding

let fold = CaseFold::Turkic;
assert!(fold.case_eq("İstanbul", "istanbul"));
assert!(!fold.case_eq("İstanbul", "Istanbul"));

Trait Implementations

impl Clone for CaseFold

fn clone(&self) -> CaseFold

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CaseFold

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for CaseFold

fn default() -> CaseFold

Default to full Unicode case folding.

See CaseFold::Full.

Examples

assert_eq!(CaseFold::default(), CaseFold::Full);

assert!(CaseFold::default().case_eq("MASSE", "Maße"));
assert!(!CaseFold::default().case_eq("São Paulo", "Sao Paulo"));

impl Hash for CaseFold

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

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 Ord for CaseFold

fn cmp(&self, other: &CaseFold) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<CaseFold> for CaseFold

fn eq(&self, other: &CaseFold) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<CaseFold> for CaseFold

fn partial_cmp(&self, other: &CaseFold) -> Option<Ordering>

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

fn lt(&self, other: &Rhs) -> bool

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

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

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

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 TryFrom<Option<&[u8]>> for CaseFold

type Error = NoSuchCaseFoldingScheme

The type returned in the event of a conversion error.

fn try_from(
    value: Option<&[u8]>
) -> Result<CaseFold, <CaseFold as TryFrom<Option<&[u8]>>>::Error>

Performs the conversion.

impl TryFrom<Option<&str>> for CaseFold

type Error = NoSuchCaseFoldingScheme

The type returned in the event of a conversion error.

fn try_from(
    value: Option<&str>
) -> Result<CaseFold, <CaseFold as TryFrom<Option<&str>>>::Error>

Performs the conversion.

impl Copy for CaseFold

impl Eq for CaseFold

impl StructuralEq for CaseFold

impl StructuralPartialEq for CaseFold