Enum `Pattern`

pub enum Pattern

Transformations on a list of words.

A pattern is a function that maps a list of words into another list after changing the casing of each letter. How a patterns mutates each letter can be dependent on the word the letters are present in.

Custom Pattern

A pattern is a function that maps from a borrowed list of words &[&str] to an owned list of owned words Vec<String> by applying a transformation. One example of custom behavior might be a pattern that detects a fixed list of two-letter acronyms, and capitalizes them appropriately on output.

use convert_case::{Converter, Pattern};

fn pascal_upper_acronyms(words: &[&str]) -> Vec<String> {
    Pattern::Capital.mutate(words).into_iter()
        .map(|word| match word.as_ref() {
            "Io" | "Xml" => word.to_uppercase(),
            _ => word,
        })
        .collect()
}

let acronym_converter = Converter::new()
    .set_pattern(Pattern::Custom(pascal_upper_acronyms));

assert_eq!(acronym_converter.convert("io_stream"), "IOStream");
assert_eq!(acronym_converter.convert("xml request"), "XMLRequest");

Another example might be a one that explicitly adds leading and trailing double underscores. We do this by modifying the words directly, which will get passed as-is to the join function.

use convert_case::{Converter, Pattern};

fn snake_dunder(mut words: &[&str]) -> Vec<String> {
    words
        .into_iter()
        .map(|word| word.to_lowercase())
        .enumerate()
        .map(|(i, word)| {
            if words.len() == 1 {
                format!("__{}__", word)
            } else if i == 0 {
                format!("__{}", word)
            } else if i == words.len() - 1 {
                format!("{}__", word)
            } else {
                word
            }
        })
        .collect()
}

let dunder_converter = Converter::new()
    .set_pattern(Pattern::Custom(snake_dunder))
    .set_delim("_");

assert_eq!(dunder_converter.convert("getAttr"), "__get_attr__");
assert_eq!(dunder_converter.convert("ITER"), "__iter__");

Variants

Noop

The no-op pattern performs no mutations.

# use convert_case::Pattern;
assert_eq!(
    Pattern::Noop.mutate(&["Case", "CONVERSION", "library"]),
    vec!["Case", "CONVERSION", "library"],
);

Lowercase

Makes all words lowercase.

# use convert_case::Pattern;
assert_eq!(
    Pattern::Lowercase.mutate(&["Case", "CONVERSION", "library"]),
    vec!["case", "conversion", "library"],
);

Uppercase

Makes all words uppercase.

# use convert_case::Pattern;
assert_eq!(
    Pattern::Uppercase.mutate(&["Case", "CONVERSION", "library"]),
    vec!["CASE", "CONVERSION", "LIBRARY"],
);

Capital

Makes the first letter of each word uppercase and the remaining letters of each word lowercase.

# use convert_case::Pattern;
assert_eq!(
    Pattern::Capital.mutate(&["Case", "CONVERSION", "library"]),
    vec!["Case", "Conversion", "Library"],
);

Camel

Makes the first non-empty word lowercase and the remaining capitalized.

# use convert_case::Pattern;
assert_eq!(
    Pattern::Camel.mutate(&["Case", "CONVERSION", "library"]),
    vec!["case", "Conversion", "Library"],
);

Sentence

Makes the first non-empty word capitalized and the remaining lowercase.

# use convert_case::Pattern;
assert_eq!(
    Pattern::Sentence.mutate(&["Case", "CONVERSION", "library"]),
    vec!["Case", "conversion", "library"],
);

Custom(fn(&[&str]) -> Vec<String>)

Define custom behavior to transform a set of words.

See the Pattern documentation for examples.

Implementations

`impl Pattern`

fn mutate(&self, words: &[&str]) -> Vec<String>: Applies the pattern transformation to a list of words.

Trait Implementations

`impl Clone for Pattern`

fn clone(&self) -> Pattern

`impl Copy for Pattern`

`impl Debug for Pattern`

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

`impl Eq for Pattern`

`impl Hash for Pattern`

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

`impl PartialEq for Pattern`

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

`impl StructuralPartialEq for Pattern`

Auto Trait Implementations

`impl Freeze for Pattern`

`impl RefUnwindSafe for Pattern`

`impl Send for Pattern`

`impl Sync for Pattern`

`impl Unpin for Pattern`

`impl UnsafeUnpin for Pattern`

`impl UnwindSafe for Pattern`

Blanket Implementations

`impl<T> Any for Pattern where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for Pattern where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for Pattern where T: ?Sized,`

fn borrow_mut(&mut self) -> &mut T

`impl<T> CloneToUninit for Pattern where T: Clone,`

unsafe fn clone_to_uninit(&self, dest: *mut u8)

`impl<T> From<T> for Pattern`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for Pattern where T: Clone,`

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

`impl<T, U> Into for Pattern where U: From<T>,`

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Pattern where U: Into<T>,`

type Error = Infallible;
fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

`impl<T, U> TryInto for Pattern where U: TryFrom<T>,`

type Error = >::Error;
fn try_into(self) -> Result<U, >::Error>