Enum unicode_types::basic_latin::BasicLatin

pub enum BasicLatin {
    Control0000,
    Control0001,
    Control0002,
    Control0003,
    Control0004,
    Control0005,
    Control0006,
    Control0007,
    Control0008,
    Control0009,
    Control000a,
    Control000b,
    Control000c,
    Control000d,
    Control000e,
    Control000f,
    Control0010,
    Control0011,
    Control0012,
    Control0013,
    Control0014,
    Control0015,
    Control0016,
    Control0017,
    Control0018,
    Control0019,
    Control001a,
    Control001b,
    Control001c,
    Control001d,
    Control001e,
    Control001f,
    Space,
    ExclamationMark,
    QuotationMark,
    NumberSign,
    DollarSign,
    PercentSign,
    Ampersand,
    Apostrophe,
    LeftParenthesis,
    RightParenthesis,
    Asterisk,
    PlusSign,
    Comma,
    HyphenDashMinus,
    FullStop,
    Solidus,
    DigitZero,
    DigitOne,
    DigitTwo,
    DigitThree,
    DigitFour,
    DigitFive,
    DigitSix,
    DigitSeven,
    DigitEight,
    DigitNine,
    Colon,
    Semicolon,
    LessDashThanSign,
    EqualsSign,
    GreaterDashThanSign,
    QuestionMark,
    CommercialAt,
    LatinCapitalLetterA,
    LatinCapitalLetterB,
    LatinCapitalLetterC,
    LatinCapitalLetterD,
    LatinCapitalLetterE,
    LatinCapitalLetterF,
    LatinCapitalLetterG,
    LatinCapitalLetterH,
    LatinCapitalLetterI,
    LatinCapitalLetterJ,
    LatinCapitalLetterK,
    LatinCapitalLetterL,
    LatinCapitalLetterM,
    LatinCapitalLetterN,
    LatinCapitalLetterO,
    LatinCapitalLetterP,
    LatinCapitalLetterQ,
    LatinCapitalLetterR,
    LatinCapitalLetterS,
    LatinCapitalLetterT,
    LatinCapitalLetterU,
    LatinCapitalLetterV,
    LatinCapitalLetterW,
    LatinCapitalLetterX,
    LatinCapitalLetterY,
    LatinCapitalLetterZ,
    LeftSquareBracket,
    ReverseSolidus,
    RightSquareBracket,
    CircumflexAccent,
    LowLine,
    GraveAccent,
    LatinSmallLetterA,
    LatinSmallLetterB,
    LatinSmallLetterC,
    LatinSmallLetterD,
    LatinSmallLetterE,
    LatinSmallLetterF,
    LatinSmallLetterG,
    LatinSmallLetterH,
    LatinSmallLetterI,
    LatinSmallLetterJ,
    LatinSmallLetterK,
    LatinSmallLetterL,
    LatinSmallLetterM,
    LatinSmallLetterN,
    LatinSmallLetterO,
    LatinSmallLetterP,
    LatinSmallLetterQ,
    LatinSmallLetterR,
    LatinSmallLetterS,
    LatinSmallLetterT,
    LatinSmallLetterU,
    LatinSmallLetterV,
    LatinSmallLetterW,
    LatinSmallLetterX,
    LatinSmallLetterY,
    LatinSmallLetterZ,
    LeftCurlyBracket,
    VerticalLine,
    RightCurlyBracket,
    Tilde,
}

An enum to represent all characters in the BasicLatin block.

Variants

Control0000

\u{0}: '�'

Control0001

\u{1}: '
'

Control0002

\u{2}: ''

Control0003

\u{3}: ''

Control0004

\u{4}: ''

Control0005

\u{5}: ''

Control0006

\u{6}: ''

Control0007

\u{7}: ''

Control0008

\u{8}: ''

Control0009

\u{9}: '\t'

Control000a

\u{a}: '\n'

Control000b

\u{b}: ''

Control000c

\u{c}: ''

Control000d

\u{d}: '\r'

Control000e

\u{e}: ''

Control000f

\u{f}: ''

Control0010

\u{10}: ''

Control0011

\u{11}: ''

Control0012

\u{12}: ''

Control0013

\u{13}: ''

Control0014

\u{14}: ''

Control0015

\u{15}: ''

Control0016

\u{16}: ''

Control0017

\u{17}: ''

Control0018

\u{18}: ''

Control0019

\u{19}: ''

Control001a

\u{1a}: ''

Control001b

\u{1b}: ''

Control001c

\u{1c}: ''

Control001d

\u{1d}: ''

Control001e

\u{1e}: ''

Control001f

\u{1f}: ''

Space

\u{20}: ' '

ExclamationMark

\u{21}: '!'

QuotationMark

\u{22}: '"'

NumberSign

\u{23}: '#'

DollarSign

\u{24}: '$'

PercentSign

\u{25}: '%'

Ampersand

\u{26}: '&'

Apostrophe

\u{27}: '''

LeftParenthesis

\u{28}: '('

RightParenthesis

\u{29}: ')'

Asterisk

\u{2a}: '*'

PlusSign

\u{2b}: '+'

Comma

\u{2c}: ','

HyphenDashMinus

\u{2d}: '-'

FullStop

\u{2e}: '.'

Solidus

\u{2f}: '/'

DigitZero

\u{30}: '0'

DigitOne

\u{31}: '1'

DigitTwo

\u{32}: '2'

DigitThree

\u{33}: '3'

DigitFour

\u{34}: '4'

DigitFive

\u{35}: '5'

DigitSix

\u{36}: '6'

DigitSeven

\u{37}: '7'

DigitEight

\u{38}: '8'

DigitNine

\u{39}: '9'

Colon

\u{3a}: ':'

Semicolon

\u{3b}: ';'

LessDashThanSign

\u{3c}: '<'

EqualsSign

\u{3d}: '='

GreaterDashThanSign

\u{3e}: '>'

QuestionMark

\u{3f}: '?'

CommercialAt

\u{40}: '@'

LatinCapitalLetterA

\u{41}: 'A'

LatinCapitalLetterB

\u{42}: 'B'

LatinCapitalLetterC

\u{43}: 'C'

LatinCapitalLetterD

\u{44}: 'D'

LatinCapitalLetterE

\u{45}: 'E'

LatinCapitalLetterF

\u{46}: 'F'

LatinCapitalLetterG

\u{47}: 'G'

LatinCapitalLetterH

\u{48}: 'H'

LatinCapitalLetterI

\u{49}: 'I'

LatinCapitalLetterJ

\u{4a}: 'J'

LatinCapitalLetterK

\u{4b}: 'K'

LatinCapitalLetterL

\u{4c}: 'L'

LatinCapitalLetterM

\u{4d}: 'M'

LatinCapitalLetterN

\u{4e}: 'N'

LatinCapitalLetterO

\u{4f}: 'O'

LatinCapitalLetterP

\u{50}: 'P'

LatinCapitalLetterQ

\u{51}: 'Q'

LatinCapitalLetterR

\u{52}: 'R'

LatinCapitalLetterS

\u{53}: 'S'

LatinCapitalLetterT

\u{54}: 'T'

LatinCapitalLetterU

\u{55}: 'U'

LatinCapitalLetterV

\u{56}: 'V'

LatinCapitalLetterW

\u{57}: 'W'

LatinCapitalLetterX

\u{58}: 'X'

LatinCapitalLetterY

\u{59}: 'Y'

LatinCapitalLetterZ

\u{5a}: 'Z'

LeftSquareBracket

\u{5b}: '['

ReverseSolidus

\u{5c}: '\'

RightSquareBracket

\u{5d}: ']'

CircumflexAccent

\u{5e}: '^'

LowLine

\u{5f}: '_'

GraveAccent

\u{60}: '`'

LatinSmallLetterA

\u{61}: 'a'

LatinSmallLetterB

\u{62}: 'b'

LatinSmallLetterC

\u{63}: 'c'

LatinSmallLetterD

\u{64}: 'd'

LatinSmallLetterE

\u{65}: 'e'

LatinSmallLetterF

\u{66}: 'f'

LatinSmallLetterG

\u{67}: 'g'

LatinSmallLetterH

\u{68}: 'h'

LatinSmallLetterI

\u{69}: 'i'

LatinSmallLetterJ

\u{6a}: 'j'

LatinSmallLetterK

\u{6b}: 'k'

LatinSmallLetterL

\u{6c}: 'l'

LatinSmallLetterM

\u{6d}: 'm'

LatinSmallLetterN

\u{6e}: 'n'

LatinSmallLetterO

\u{6f}: 'o'

LatinSmallLetterP

\u{70}: 'p'

LatinSmallLetterQ

\u{71}: 'q'

LatinSmallLetterR

\u{72}: 'r'

LatinSmallLetterS

\u{73}: 's'

LatinSmallLetterT

\u{74}: 't'

LatinSmallLetterU

\u{75}: 'u'

LatinSmallLetterV

\u{76}: 'v'

LatinSmallLetterW

\u{77}: 'w'

LatinSmallLetterX

\u{78}: 'x'

LatinSmallLetterY

\u{79}: 'y'

LatinSmallLetterZ

\u{7a}: 'z'

LeftCurlyBracket

\u{7b}: '{'

VerticalLine

\u{7c}: '|'

RightCurlyBracket

\u{7d}: '}'

Tilde

\u{7e}: '~'

Methods

impl BasicLatin

pub fn new() -> Self

The character with the lowest index in this unicode block

pub fn name(&self) -> &str

The character's name, all lowercase and space-separated

Trait Implementations

impl Iterator for BasicLatin

type Item = Self

The type of the elements being iterated over.

fn next(&mut self) -> Option<Self>

Advances the iterator and returns the next value.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn count(self) -> usize

Consumes the iterator, counting the number of iterations and returning it.

fn last(self) -> Option<Self::Item>

Consumes the iterator, returning the last element.

fn nth(&mut self, n: usize) -> Option<Self::Item>

Returns the nth element of the iterator.

fn step_by(self, step: usize) -> StepBy<Self>

Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
    U: IntoIterator<Item = Self::Item>, 

Takes two iterators and creates a new iterator over both in sequence.

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
    U: IntoIterator, 

'Zips up' two iterators into a single iterator of pairs.

fn map<B, F>(self, f: F) -> Map<Self, F> where
    F: FnMut(Self::Item) -> B, 

Takes a closure and creates an iterator which calls that closure on each element.

fn for_each<F>(self, f: F) where
    F: FnMut(Self::Item), 

Calls a closure on each element of an iterator.

fn filter<P>(self, predicate: P) -> Filter<Self, P> where
    P: FnMut(&Self::Item) -> bool, 

Creates an iterator which uses a closure to determine if an element should be yielded.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
    F: FnMut(Self::Item) -> Option<B>, 

Creates an iterator that both filters and maps.

fn enumerate(self) -> Enumerate<Self>

Creates an iterator which gives the current iteration count as well as the next value.

fn peekable(self) -> Peekable<Self>

Creates an iterator which can use peek to look at the next element of the iterator without consuming it.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
    P: FnMut(&Self::Item) -> bool, 

Creates an iterator that [skip]s elements based on a predicate.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
    P: FnMut(&Self::Item) -> bool, 

Creates an iterator that yields elements based on a predicate.

fn skip(self, n: usize) -> Skip<Self>

Creates an iterator that skips the first n elements.

fn take(self, n: usize) -> Take<Self>

Creates an iterator that yields its first n elements.

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
    F: FnMut(&mut St, Self::Item) -> Option<B>, 

An iterator adaptor similar to [fold] that holds internal state and produces a new iterator.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
    F: FnMut(Self::Item) -> U,
    U: IntoIterator, 

Creates an iterator that works like map, but flattens nested structure.

fn flatten(self) -> Flatten<Self> where
    Self::Item: IntoIterator, 

Creates an iterator that flattens nested structure.

fn fuse(self) -> Fuse<Self>

Creates an iterator which ends after the first [None].

fn inspect<F>(self, f: F) -> Inspect<Self, F> where
    F: FnMut(&Self::Item), 

Do something with each element of an iterator, passing the value on.

fn by_ref(&mut self) -> &mut Self

Borrows an iterator, rather than consuming it.

#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]

fn collect<B>(self) -> B where
    B: FromIterator<Self::Item>, 

Transforms an iterator into a collection.

fn partition<B, F>(self, f: F) -> (B, B) where
    B: Default + Extend<Self::Item>,
    F: FnMut(&Self::Item) -> bool, 

Consumes an iterator, creating two collections from it.

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
    F: FnMut(B, Self::Item) -> R,
    R: Try<Ok = B>, 

An iterator method that applies a function as long as it returns successfully, producing a single, final value.

fn try_for_each<F, R>(&mut self, f: F) -> R where
    F: FnMut(Self::Item) -> R,
    R: Try<Ok = ()>, 

An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error.

fn fold<B, F>(self, init: B, f: F) -> B where
    F: FnMut(B, Self::Item) -> B, 

An iterator method that applies a function, producing a single, final value.

fn all<F>(&mut self, f: F) -> bool where
    F: FnMut(Self::Item) -> bool, 

Tests if every element of the iterator matches a predicate.

fn any<F>(&mut self, f: F) -> bool where
    F: FnMut(Self::Item) -> bool, 

Tests if any element of the iterator matches a predicate.

fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
    P: FnMut(&Self::Item) -> bool, 

Searches for an element of an iterator that satisfies a predicate.

fn find_map<B, F>(&mut self, f: F) -> Option<B> where
    F: FnMut(Self::Item) -> Option<B>, 

Applies function to the elements of iterator and returns the first non-none result.

fn position<P>(&mut self, predicate: P) -> Option<usize> where
    P: FnMut(Self::Item) -> bool, 

Searches for an element in an iterator, returning its index.

fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
    P: FnMut(Self::Item) -> bool,
    Self: ExactSizeIterator + DoubleEndedIterator, 

Searches for an element in an iterator from the right, returning its index.

fn max(self) -> Option<Self::Item> where
    Self::Item: Ord, 

Returns the maximum element of an iterator.

fn min(self) -> Option<Self::Item> where
    Self::Item: Ord, 

Returns the minimum element of an iterator.

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
    B: Ord,
    F: FnMut(&Self::Item) -> B, 

Returns the element that gives the maximum value from the specified function.

fn max_by<F>(self, compare: F) -> Option<Self::Item> where
    F: FnMut(&Self::Item, &Self::Item) -> Ordering, 

Returns the element that gives the maximum value with respect to the specified comparison function.

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
    B: Ord,
    F: FnMut(&Self::Item) -> B, 

Returns the element that gives the minimum value from the specified function.

fn min_by<F>(self, compare: F) -> Option<Self::Item> where
    F: FnMut(&Self::Item, &Self::Item) -> Ordering, 

Returns the element that gives the minimum value with respect to the specified comparison function.

fn rev(self) -> Rev<Self> where
    Self: DoubleEndedIterator, 

Reverses an iterator's direction.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    Self: Iterator<Item = (A, B)>, 

Converts an iterator of pairs into a pair of containers.

fn copied<'a, T>(self) -> Copied<Self> where
    Self: Iterator<Item = &'a T>,
    T: 'a + Copy, 

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

Creates an iterator which copies all of its elements.

fn cloned<'a, T>(self) -> Cloned<Self> where
    Self: Iterator<Item = &'a T>,
    T: 'a + Clone, 

Creates an iterator which [clone]s all of its elements.

fn cycle(self) -> Cycle<Self> where
    Self: Clone, 

Repeats an iterator endlessly.

fn sum<S>(self) -> S where
    S: Sum<Self::Item>, 

Sums the elements of an iterator.

fn product<P>(self) -> P where
    P: Product<Self::Item>, 

Iterates over the entire iterator, multiplying all the elements

fn cmp<I>(self, other: I) -> Ordering where
    I: IntoIterator<Item = Self::Item>,
    Self::Item: Ord, 

Lexicographically compares the elements of this Iterator with those of another.

fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

Lexicographically compares the elements of this Iterator with those of another.

fn eq<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialEq<<I as IntoIterator>::Item>, 

Determines if the elements of this Iterator are equal to those of another.

fn ne<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialEq<<I as IntoIterator>::Item>, 

Determines if the elements of this Iterator are unequal to those of another.

fn lt<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

Determines if the elements of this Iterator are lexicographically less than those of another.

fn le<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

Determines if the elements of this Iterator are lexicographically less or equal to those of another.

fn gt<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

Determines if the elements of this Iterator are lexicographically greater than those of another.

fn ge<I>(self, other: I) -> bool where
    I: IntoIterator,
    Self::Item: PartialOrd<<I as IntoIterator>::Item>, 

Determines if the elements of this Iterator are lexicographically greater than or equal to those of another.

fn is_sorted(self) -> bool where
    Self::Item: PartialOrd<Self::Item>, 

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

new API

Checks if the elements of this iterator are sorted.

fn is_sorted_by<F>(self, compare: F) -> bool where
    F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>, 

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

new API

Checks if the elements of this iterator are sorted using the given comparator function.

fn is_sorted_by_key<F, K>(self, f: F) -> bool where
    F: FnMut(&Self::Item) -> K,
    K: PartialOrd<K>, 

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

new API

Checks if the elements of this iterator are sorted using the given key extraction function.

impl PartialEq<BasicLatin> for BasicLatin

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

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

#[must_use]

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

This method tests for !=.

impl Clone for BasicLatin

Important traits for BasicLatin

impl Iterator for BasicLatin type Item = Self;

fn clone(&self) -> BasicLatin

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Into<char> for BasicLatin

fn into(self) -> char

Performs the conversion.

impl Into<u32> for BasicLatin

fn into(self) -> u32

Performs the conversion.

impl Eq for BasicLatin

impl Copy for BasicLatin

impl Hash for BasicLatin

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, 

Feeds a slice of this type into the given [Hasher].

impl Debug for BasicLatin

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

Formats the value using the given formatter.

impl TryFrom<char> for BasicLatin

type Error = ()

The type returned in the event of a conversion error.

fn try_from(c: char) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<u32> for BasicLatin

type Error = ()

The type returned in the event of a conversion error.

fn try_from(u: u32) -> Result<Self, Self::Error>

Performs the conversion.