Struct unic_char_range::CharRange

pub struct CharRange {
    pub low: char,
    pub high: char,
}

A range of unicode code points.

The most idiomatic way to construct this range is through the use of the chars! macro:

#[macro_use] extern crate unic_char_range;
use unic_char_range::CharRange;

assert_eq!(chars!('a'..='z'), CharRange::closed('a', 'z'));
assert_eq!(chars!('a'..'z'), CharRange::open_right('a', 'z'));
assert_eq!(chars!(..), CharRange::all());

If constructed in reverse order, such that self.high is ordered before self.low, the range is empty. If you want to iterate in decreasing order, use .iter().rev(). All empty ranges are considered equal no matter the internal state.

Fields

low: char

The lowest character in this range (inclusive).

high: char

The highest character in this range (inclusive).

Methods

impl CharRange

Constructors

fn closed(start: char, stop: char) -> CharRange

Construct a closed range of characters.

If stop is ordered before start, the resulting range will be empty.

Example

assert_eq!(
    CharRange::closed('a', 'd').iter().collect::<Vec<_>>(),
    vec!['a', 'b', 'c', 'd']
)

fn open_right(start: char, stop: char) -> CharRange

Construct a half open (right) range of characters.

Example

assert_eq!(
    CharRange::open_right('a', 'd').iter().collect::<Vec<_>>(),
    vec!['a', 'b', 'c']
)

fn open_left(start: char, stop: char) -> CharRange

Construct a half open (left) range of characters.

Example

assert_eq!(
    CharRange::open_left('a', 'd').iter().collect::<Vec<_>>(),
    vec!['b', 'c', 'd']
)

fn open(start: char, stop: char) -> CharRange

Construct a fully open range of characters.

Example

assert_eq!(
    CharRange::open('a', 'd').iter().collect::<Vec<_>>(),
    vec!['b', 'c']
)

fn bound(start: Bound<char>, stop: Bound<char>) -> CharRange

Construct a range of characters from bounds.

fn all() -> CharRange

Construct a range over all characters.

impl CharRange

Collection-like fn

fn contains(&self, ch: char) -> bool

Does this range include a character?

Examples

assert!(   CharRange::closed('a', 'g').contains('d'));
assert!( ! CharRange::closed('a', 'g').contains('z'));

assert!( ! CharRange:: open ('a', 'a').contains('a'));
assert!( ! CharRange::closed('z', 'a').contains('g'));

fn cmp(&self, ch: char) -> Ordering

Determine the ordering of this range and a character.

Panics

Panics if the range is empty. This fn may be adjusted in the future to not panic in optimized builds. Even if so, an empty range will never compare as Ordering::Equal.

fn len(&self) -> usize

How many characters are in this range?

fn is_empty(&self) -> bool

Is this range empty?

fn iter(&self) -> CharIter

Create an iterator over this range.

Trait Implementations

impl Copy for CharRange

impl Clone for CharRange

fn clone(&self) -> CharRange

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CharRange

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Eq for CharRange

impl IntoIterator for CharRange

type Item = char

The type of the elements being iterated over.

type IntoIter = CharIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> CharIter

Creates an iterator from a value.

impl PartialEq<CharRange> for CharRange

fn eq(&self, other: &CharRange) -> 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 !=.

impl From<CharIter> for CharRange

fn from(iter: CharIter) -> CharRange

Performs the conversion.