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>).

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

You have two main things you can control about how segmentation happens; whether or not a contiguous chunk is broken into it’s largest “words” (runs of characters with no natural boundaries as defined by B), and whether or not you are returned the byte offset to the segment from the original data.

Words \ Indices	No	Yes
No	chunked_segments	chunked_segment_indices
Yes	segments	segment_indices

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

See the respective functions for more details.

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.

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 if the segment contains a delimiter, false if not.

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 the segment contains a delimiter, and if the provided predicate passes. Returns false if not.

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 if the segment contains a delimiter, or if the segment contained a chunk, and provided predicate passes. Returns false otherwise.

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 if the segment contains a chunk, false if not.

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 the segment contains a chunk, and if the provided predicate passes. Returns false otherwise.

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 the segment contains a chunk, or if the segment contained a delimiter, and provided predicate passes. Returns false otherwise.

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: Profile> 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.