Enum convert_case::Case

source ·
pub enum Case {
Show 16 variants Upper, Lower, Title, Toggle, Camel, Pascal, UpperCamel, Snake, UpperSnake, ScreamingSnake, Kebab, Cobol, Train, Flat, UpperFlat, Alternating,
}
Expand description

Defines the type of casing a string can be.

use convert_case::{Case, Casing};

let super_mario_title: String = "super_mario_64".to_case(Case::Title);
assert_eq!("Super Mario 64", super_mario_title);

Variants§

§

Upper

Uppercase strings are delimited by spaces and all characters are uppercase.

use convert_case::{Case, Casing};
assert_eq!("MY VARIABLE NAME", "My variable NAME".to_case(Case::Upper))
§

Lower

Lowercase strings are delimited by spaces and all characters are lowercase.

use convert_case::{Case, Casing};
assert_eq!("my variable name", "My variable NAME".to_case(Case::Lower))
§

Title

Title case strings are delimited by spaces. Only the leading character of each word is uppercase. No inferences are made about language, so words like “as”, “to”, and “for” will still be capitalized.

use convert_case::{Case, Casing};
assert_eq!("My Variable Name", "My variable NAME".to_case(Case::Title))
§

Toggle

Toggle case strings are delimited by spaces. All characters are uppercase except for the leading character of each word, which is lowercase.

use convert_case::{Case, Casing};
assert_eq!("mY vARIABLE nAME", "My variable NAME".to_case(Case::Toggle))
§

Camel

Camel case strings are lowercase, but for every word except the first the first letter is capitalized.

use convert_case::{Case, Casing};
assert_eq!("myVariableName", "My variable NAME".to_case(Case::Camel))
§

Pascal

Pascal case strings are lowercase, but for every word the first letter is capitalized.

use convert_case::{Case, Casing};
assert_eq!("MyVariableName", "My variable NAME".to_case(Case::Pascal))
§

UpperCamel

Upper camel case is an alternative name for Pascal case.

§

Snake

Snake case strings are delimited by underscores _ and are all lowercase.

use convert_case::{Case, Casing};
assert_eq!("my_variable_name", "My variable NAME".to_case(Case::Snake))
§

UpperSnake

Upper snake case strings are delimited by underscores _ and are all uppercase.

use convert_case::{Case, Casing};
assert_eq!("MY_VARIABLE_NAME", "My variable NAME".to_case(Case::UpperSnake))
§

ScreamingSnake

Screaming snake case is an alternative name for upper snake case.

§

Kebab

Kebab case strings are delimited by hyphens - and are all lowercase.

use convert_case::{Case, Casing};
assert_eq!("my-variable-name", "My variable NAME".to_case(Case::Kebab))
§

Cobol

Cobol case strings are delimited by hyphens - and are all uppercase.

use convert_case::{Case, Casing};
assert_eq!("MY-VARIABLE-NAME", "My variable NAME".to_case(Case::Cobol))
§

Train

Train case strings are delimited by hyphens -. All characters are lowercase except for the leading character of each word.

use convert_case::{Case, Casing};
assert_eq!("My-Variable-Name", "My variable NAME".to_case(Case::Train))
§

Flat

Flat case strings are all lowercase, with no delimiter. Converting to this case is lossy. That is, word boundaries are lost.

use convert_case::{Case, Casing};
assert_eq!("myvariablename", "My variable NAME".to_case(Case::Flat))
§

UpperFlat

Upper flat case strings are all uppercase, with no delimiter. Converting to this case is lossy. That is, word boundaries are lost.

use convert_case::{Case, Casing};
assert_eq!("MYVARIABLENAME", "My variable NAME".to_case(Case::UpperFlat))
§

Alternating

Alternating case strings are delimited by spaces. Characters alternate between uppercase and lowercase.

use convert_case::{Case, Casing};
assert_eq!("mY vArIaBlE nAmE", "My variable NAME".to_case(Case::Alternating));

Implementations§

source§

impl Case

source

pub fn all_cases() -> Vec<Case>

Returns a vector with all case enum variants. This was created for use in the ccase binary.

Trait Implementations§

source§

impl Clone for Case

source§

fn clone(&self) -> Case

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for Case

source§

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

Formats the value using the given formatter. Read more
source§

impl PartialEq<Case> for Case

source§

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

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

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.
source§

impl Copy for Case

source§

impl Eq for Case

source§

impl StructuralEq for Case

source§

impl StructuralPartialEq for Case

Auto Trait Implementations§

§

impl RefUnwindSafe for Case

§

impl Send for Case

§

impl Sync for Case

§

impl Unpin for Case

§

impl UnwindSafe for Case

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

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

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

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

source§

impl<T> ToOwned for Twhere T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.