Enum Segment 

pub enum Segment<D, C> {
    Chunk(C),
    Delim(D),
}

A part of an identifier returned during segmentation.

The default type contents of a segment are:

• D: The delimiter from the fragment/identifier.
• C: A chunk formed from the type parameters (&Chunk<B, D, P>).

You have two main things you can control about how segmentation happens;

• Whether or not indices are returned along with the segments.
• Whether or not we return the entire chunk, versus further splitting the chunk into “words” based on the identifier’s defined Boundary.

	No Indices	Indices
Chunks	chunked_segments	chunked_segment_indices
Words	segments	segment_indices

Normally, you’ll want chunks broken into words. So we’ve named the variant that breaks chunks into words simply segments.

See the respective functions for more details.

Type Erasure

If you don’t need strong typing, you can use the type_erased methods to drop the type information (producing char and &str). There is a typedef associated with this type for convenience (StrSegment).

There are different levels of type-erasure, depending on which type information you want to drop.

Method	Delimiter Becomes…	Chunk Becomes…
type_erased	char	&str
type_erased_chunk	D (Unchanged)	&str
type_erased_delim	char	C (Unchanged)

Variants

Chunk(C)

A chunk (run of non-delimiter characters) of an identifier.

Delim(D)

A single delimiter.

Implementations

impl<D> Segment<D, &str>

pub fn into_owned(self) -> Segment<D, String>

Converts a type-erased segment into an owned representation.

Examples

let segment = CamelSegment::Delim(LowLine)
    .type_erased_chunk()
    .into_owned();
assert_eq!(segment, CamelSegment::Delim(LowLine).type_erased_chunk());

let segment = CamelSegment::Chunk(CamelChunk::new("Upper")?)
    .type_erased_chunk()
    .into_owned();
assert_eq!(segment, StringSegment::Chunk(String::from("Upper")));

impl<D: Delimiter> Segment<D, String>

pub fn len(&self) -> usize

Returns the byte length of the string representation of self.

For delimiters, this will first cast as a character, then return the UTF-8 length of the character. For chunks, the length of the chunk is used directly.

Examples

let segment = CamelSegment::Delim(LowLine)
    .type_erased_chunk()
    .into_owned();
assert_eq!(segment.len(), 1);

let segment = CamelSegment::Chunk(CamelChunk::new("Upper")?)
    .type_erased_chunk()
    .into_owned();
assert_eq!(segment.len(), 5);

impl Segment<char, String>

pub fn len(&self) -> usize

Returns the byte length of the string representation of self.

For delimiters, this will first cast as a character, then return the UTF-8 length of the character. For chunks, the length of the chunk is used directly.

Examples

let segment = CamelSegment::Delim(LowLine)
    .type_erased()
    .into_owned();
assert_eq!(segment.len(), 1);

let segment = CamelSegment::Chunk(CamelChunk::new("Upper")?)
    .type_erased()
    .into_owned();
assert_eq!(segment.len(), 5);

impl<'a, B, D: Delimiter, P> Segment<D, &'a Chunk<B, D, P>>

pub fn is_empty(&self) -> bool

Returns true if the contents of this segment is an empty chunk.

Since a delimiter can never be empty, if the segment is a delimiter, this will return false.

Examples

let segment = CamelSegment::Delim(LowLine);
assert_eq!(segment.is_empty(), false);

let segment = CamelSegment::Chunk(CamelChunk::new("Upper")?);
assert_eq!(segment.is_empty(), false);

let segment = CamelSegment::Chunk(CamelChunk::new("")?);
assert_eq!(segment.is_empty(), true);

pub fn len(&self) -> usize

Returns the byte length of the string representation of self.

For delimiters, this will first cast as a character, then return the UTF-8 length of the character. For chunks, the length of the chunk is used directly.

Examples

let segment = CamelSegment::Delim(LowLine);
assert_eq!(segment.len(), 1);

let segment = CamelSegment::Chunk(CamelChunk::new("Upper")?);
assert_eq!(segment.len(), 5);

pub fn type_erased(self) -> Segment<char, &'a str>

Converts the segment to a type-erased representation.

The Delim variant will be converted to a char, and the Chunk variant will be converted to a &str.

Examples

let segment = CamelSegment::Delim(LowLine).type_erased();
assert!(segment.is_delim_and(|c| *c == '_'));

let segment = CamelSegment::Chunk(CamelChunk::new("Upper")?).type_erased();
assert!(segment.is_chunk_and(|c| *c == "Upper"));

pub fn type_erased_delim(self) -> Segment<char, &'a Chunk<B, D, P>>

Converts a segment’s delimiter to a type-erased representation.

The Delim variant will be converted to a char, but the chunk will remain strongly-typed.

Examples

let segment = CamelSegment::Delim(LowLine).type_erased_delim();
assert!(segment.is_delim_and(|c| *c == '_'));

let segment = CamelSegment::Chunk(CamelChunk::new("Upper")?).type_erased_delim();
assert!(segment.is_chunk_and(|c| *c == "Upper"));

pub fn type_erased_chunk(self) -> Segment<D, &'a str>

Converts a segment’s chunk to a type-erased representation.

The Chunk variant will be converted to a &str, but the delimiter will remain strongly-typed.

Examples

let segment = CamelSegment::Delim(LowLine).type_erased_chunk();
assert!(segment.is_delim_and(|c| *c == '_'));

let segment = CamelSegment::Chunk(CamelChunk::new("Upper")?).type_erased_chunk();
assert!(segment.is_chunk_and(|c| *c == "Upper"));

impl<'a, D: Delimiter> Segment<D, &'a str>

pub fn is_empty(&self) -> bool

Returns true if the contents of this segment is an empty chunk.

Examples

let segment = CamelSegment::Delim(LowLine)
    .type_erased_chunk();
assert_eq!(segment.is_empty(), false);

let segment = CamelSegment::Chunk(CamelChunk::new("Upper")?)
    .type_erased_chunk();
assert_eq!(segment.is_empty(), false);

let segment = CamelSegment::Chunk(CamelChunk::new("")?)
    .type_erased_chunk();
assert_eq!(segment.is_empty(), true);

pub fn len(&self) -> usize

Returns the byte length of the string representation of self.

For delimiters, this will first cast as a character, then return the UTF-8 length of the character. For chunks, the length of the chunk is used directly.

Examples

let segment = CamelSegment::Delim(LowLine)
    .type_erased_chunk();
assert_eq!(segment.len(), 1);

let segment = CamelSegment::Chunk(CamelChunk::new("Upper")?)
    .type_erased_chunk();
assert_eq!(segment.len(), 5);

pub fn type_erased(self) -> Segment<char, &'a str>

Converts the segment to a type-erased representation.

The Delim variant will be converted to a char, and the Chunk variant will be converted to a &str.

Examples

let segment = CamelSegment::Delim(LowLine)
    .type_erased_chunk().type_erased();
assert!(segment.is_delim_and(|c| *c == '_'));

let segment = CamelSegment::Chunk(CamelChunk::new("Upper")?)
    .type_erased_chunk().type_erased();
assert!(segment.is_chunk_and(|c| *c == "Upper"));

impl<'a, B, D, P> Segment<char, &'a Chunk<B, D, P>>

pub fn is_empty(&self) -> bool

Returns true if the contents of this segment is an empty chunk.

Examples

let segment = CamelSegment::Delim(LowLine)
    .type_erased_delim();
assert_eq!(segment.is_empty(), false);

let segment = CamelSegment::Chunk(CamelChunk::new("Upper")?)
    .type_erased_delim();
assert_eq!(segment.is_empty(), false);

let segment = CamelSegment::Chunk(CamelChunk::new("")?)
    .type_erased_delim();
assert_eq!(segment.is_empty(), true);

pub fn len(&self) -> usize

Returns the byte length of the string representation of self.

For character delimiters, this will return the UTF-8 length of the character. For chunks, the length of the chunk is used directly.

Examples

let segment = CamelSegment::Delim(LowLine)
    .type_erased_delim();
assert_eq!(segment.len(), 1);

let segment = CamelSegment::Chunk(CamelChunk::new("Upper")?)
    .type_erased_delim();
assert_eq!(segment.len(), 5);

pub fn type_erased(self) -> Segment<char, &'a str>

Converts the segment to a type-erased representation.

The Chunk variant will be converted to a &str.

Examples

let segment = CamelSegment::Delim(LowLine)
    .type_erased_delim().type_erased();
assert!(segment.is_delim_and(|c| *c == '_'));

let segment = CamelSegment::Chunk(CamelChunk::new("Upper")?)
    .type_erased_delim().type_erased();
assert!(segment.is_chunk_and(|c| *c == "Upper"));

impl Segment<char, &str>

pub fn is_empty(&self) -> bool

Returns true if the contents of this segment is an empty chunk.

Examples

let segment = CamelSegment::Delim(LowLine)
    .type_erased();
assert_eq!(segment.is_empty(), false);

let segment = CamelSegment::Chunk(CamelChunk::new("Upper")?)
    .type_erased();
assert_eq!(segment.is_empty(), false);

let segment = CamelSegment::Chunk(CamelChunk::new("")?)
    .type_erased();
assert_eq!(segment.is_empty(), true);

pub fn len(&self) -> usize

Returns the byte length of the string representation of self.

For character delimiters, this will return the UTF-8 length of the character. For chunks, the length of the chunk is used directly.

Examples

let segment = CamelSegment::Delim(LowLine)
    .type_erased();
assert_eq!(segment.len(), 1);

let segment = CamelSegment::Chunk(CamelChunk::new("Upper")?)
    .type_erased();
assert_eq!(segment.len(), 5);

impl<D, C> Segment<D, C>

pub fn as_str(&self) -> &str

where D: AsRef<str>, C: AsRef<str>,

Returns the original string representation of this segment.

Examples

let delim = CamelSegment::Delim(LowLine);
assert_eq!(delim.as_str(), "_");

let chunk = CamelSegment::Chunk(CamelChunk::new("chunk")?);
assert_eq!(chunk.as_str(), "chunk");

pub const fn is_delim(&self) -> bool

Returns true for every delimiter.

Examples

let delim = CamelSegment::Delim(LowLine);
assert!(delim.is_delim());

let chunk = CamelSegment::Chunk(CamelChunk::new("chunk")?);
assert!(!chunk.is_delim());

pub fn is_delim_and(&self, pred: impl FnOnce(&D) -> bool) -> bool

Returns true if a delimiter and the predicate passes.

Examples

let delim = CamelSegment::Delim(LowLine);
assert!(delim.is_delim_and(|d| *d == '_'));
assert!(!delim.is_delim_and(|d| *d == '-'));

let chunk = CamelSegment::Chunk(CamelChunk::new("chunk")?);
assert!(!chunk.is_delim_and(|d| *d == '_'));

pub fn is_delim_or(&self, pred: impl FnOnce(&C) -> bool) -> bool

Returns true for every delimiter. For a chunk, returns the result of the predicate.

Examples

let delim = CamelSegment::Delim(LowLine);
assert!(delim.is_delim_or(|c| *c == "chunk"));

let chunk = CamelSegment::Chunk(CamelChunk::new("chunk")?);
assert!(chunk.is_delim_or(|c| *c == "chunk"));
assert!(!chunk.is_delim_or(|c| *c == "text"));

pub const fn is_chunk(&self) -> bool

Returns true for every chunk.

Examples

let delim = CamelSegment::Delim(LowLine);
assert!(!delim.is_chunk());

let chunk = CamelSegment::Chunk(CamelChunk::new("chunk")?);
assert!(chunk.is_chunk());

pub fn is_chunk_and(&self, pred: impl FnOnce(&C) -> bool) -> bool

Returns true if a chunk and the predicate passes.

Examples

let delim = CamelSegment::Delim(LowLine);
assert!(!delim.is_chunk_and(|c| *c == "chunk"));

let chunk = CamelSegment::Chunk(CamelChunk::new("chunk")?);
assert!(chunk.is_chunk_and(|c| *c == "chunk"));
assert!(!chunk.is_chunk_and(|c| *c == "text"));

pub fn is_chunk_or(&self, pred: impl FnOnce(&D) -> bool) -> bool

Returns true if a chunk. For a delimiter, returns the result of the predicate.

Examples

let delim = CamelSegment::Delim(LowLine);
assert!(delim.is_chunk_or(|d| *d == '_'));
assert!(!delim.is_chunk_or(|d| *d == '-'));

let chunk = CamelSegment::Chunk(CamelChunk::new("chunk")?);
assert!(chunk.is_chunk_or(|d| *d == '_'));

pub fn delim(self) -> Option<D>

Returns Some if the segment is a delim, otherwise returns None.

let delim = CamelSegment::Delim(LowLine);
assert_eq!(delim.delim(), Some(LowLine));

let chunk = CamelSegment::Chunk(CamelChunk::new("chunk")?);
assert_eq!(chunk.delim(), None);

pub fn chunk(self) -> Option<C>

Returns Some if the segment is a chunk, otherwise returns None.

let delim = CamelSegment::Delim(LowLine);
assert_eq!(delim.chunk(), None);

let chunk = CamelSegment::Chunk(CamelChunk::new("chunk")?);
assert_eq!(chunk.chunk(), Some(CamelChunk::new("chunk")?));

Trait Implementations

impl<D: AsRef<str>, C: AsRef<str>> AsRef<str> for Segment<D, C>

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl<D: Clone, C: Clone> Clone for Segment<D, C>

fn clone(&self) -> Segment<D, C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D: Copy, C: Copy> Copy for Segment<D, C>

impl<D: Debug, C: Debug> Debug for Segment<D, C>

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

Formats the value using the given formatter.

impl<D: Display, C: Display> Display for Segment<D, C>

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

Formats the value using the given formatter.

impl<D: Eq, C: Eq> Eq for Segment<D, C>

impl<'a, B, D, P> From<&'a Chunk<B, D, P>> for Segment<D, &'a Chunk<B, D, P>>

fn from(orig: &'a Chunk<B, D, P>) -> Self

Converts to this type from the input type.

impl<D: Delimiter, C> From<D> for Segment<D, C>

fn from(orig: D) -> Self

Converts to this type from the input type.

impl<D: Hash, C: Hash> Hash for Segment<D, C>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<D: Ord, C: Ord> Ord for Segment<D, C>

fn cmp(&self, other: &Segment<D, C>) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

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

Restrict a value to a certain range.

impl<D1, D2: PartialEq<D1>, C1, C2: PartialEq<C1>> PartialEq<Segment<D1, C1>> for Segment<D2, C2>

fn eq(&self, rhs: &Segment<D1, C1>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<D1, D2: PartialOrd<D1>, C1, C2: PartialOrd<C1>> PartialOrd<Segment<D1, C1>> for Segment<D2, C2>

fn partial_cmp(&self, rhs: &Segment<D1, C1>) -> Option<Ordering>

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<'a, B: Boundary, D: Delimiter, P: CasedProfile> TryFrom<&'a str> for Segment<D, &'a Chunk<B, D, P>>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(orig: &'a str) -> Result<Self, Error>

Performs the conversion.