Enum unicode_types::georgian::Georgian

pub enum Georgian {
    CapitalLetterAn,
    CapitalLetterBan,
    CapitalLetterGan,
    CapitalLetterDon,
    CapitalLetterEn,
    CapitalLetterVin,
    CapitalLetterZen,
    CapitalLetterTan,
    CapitalLetterIn,
    CapitalLetterKan,
    CapitalLetterLas,
    CapitalLetterMan,
    CapitalLetterNar,
    CapitalLetterOn,
    CapitalLetterPar,
    CapitalLetterZhar,
    CapitalLetterRae,
    CapitalLetterSan,
    CapitalLetterTar,
    CapitalLetterUn,
    CapitalLetterPhar,
    CapitalLetterKhar,
    CapitalLetterGhan,
    CapitalLetterQar,
    CapitalLetterShin,
    CapitalLetterChin,
    CapitalLetterCan,
    CapitalLetterJil,
    CapitalLetterCil,
    CapitalLetterChar,
    CapitalLetterXan,
    CapitalLetterJhan,
    CapitalLetterHae,
    CapitalLetterHe,
    CapitalLetterHie,
    CapitalLetterWe,
    CapitalLetterHar,
    CapitalLetterHoe,
    CapitalLetterYn,
    CapitalLetterAen,
    LetterAn,
    LetterBan,
    LetterGan,
    LetterDon,
    LetterEn,
    LetterVin,
    LetterZen,
    LetterTan,
    LetterIn,
    LetterKan,
    LetterLas,
    LetterMan,
    LetterNar,
    LetterOn,
    LetterPar,
    LetterZhar,
    LetterRae,
    LetterSan,
    LetterTar,
    LetterUn,
    LetterPhar,
    LetterKhar,
    LetterGhan,
    LetterQar,
    LetterShin,
    LetterChin,
    LetterCan,
    LetterJil,
    LetterCil,
    LetterChar,
    LetterXan,
    LetterJhan,
    LetterHae,
    LetterHe,
    LetterHie,
    LetterWe,
    LetterHar,
    LetterHoe,
    LetterFi,
    LetterYn,
    LetterElifi,
    LetterTurnedGan,
    LetterAin,
    ParagraphSeparator,
    ModifierLetterNar,
    LetterAen,
    LetterHardSign,
}

An enum to represent all characters in the Georgian block.

Variants

CapitalLetterAn

\u{10a0}: 'Ⴀ'

CapitalLetterBan

\u{10a1}: 'Ⴁ'

CapitalLetterGan

\u{10a2}: 'Ⴂ'

CapitalLetterDon

\u{10a3}: 'Ⴃ'

CapitalLetterEn

\u{10a4}: 'Ⴄ'

CapitalLetterVin

\u{10a5}: 'Ⴅ'

CapitalLetterZen

\u{10a6}: 'Ⴆ'

CapitalLetterTan

\u{10a7}: 'Ⴇ'

CapitalLetterIn

\u{10a8}: 'Ⴈ'

CapitalLetterKan

\u{10a9}: 'Ⴉ'

CapitalLetterLas

\u{10aa}: 'Ⴊ'

CapitalLetterMan

\u{10ab}: 'Ⴋ'

CapitalLetterNar

\u{10ac}: 'Ⴌ'

CapitalLetterOn

\u{10ad}: 'Ⴍ'

CapitalLetterPar

\u{10ae}: 'Ⴎ'

CapitalLetterZhar

\u{10af}: 'Ⴏ'

CapitalLetterRae

\u{10b0}: 'Ⴐ'

CapitalLetterSan

\u{10b1}: 'Ⴑ'

CapitalLetterTar

\u{10b2}: 'Ⴒ'

CapitalLetterUn

\u{10b3}: 'Ⴓ'

CapitalLetterPhar

\u{10b4}: 'Ⴔ'

CapitalLetterKhar

\u{10b5}: 'Ⴕ'

CapitalLetterGhan

\u{10b6}: 'Ⴖ'

CapitalLetterQar

\u{10b7}: 'Ⴗ'

CapitalLetterShin

\u{10b8}: 'Ⴘ'

CapitalLetterChin

\u{10b9}: 'Ⴙ'

CapitalLetterCan

\u{10ba}: 'Ⴚ'

CapitalLetterJil

\u{10bb}: 'Ⴛ'

CapitalLetterCil

\u{10bc}: 'Ⴜ'

CapitalLetterChar

\u{10bd}: 'Ⴝ'

CapitalLetterXan

\u{10be}: 'Ⴞ'

CapitalLetterJhan

\u{10bf}: 'Ⴟ'

CapitalLetterHae

\u{10c0}: 'Ⴠ'

CapitalLetterHe

\u{10c1}: 'Ⴡ'

CapitalLetterHie

\u{10c2}: 'Ⴢ'

CapitalLetterWe

\u{10c3}: 'Ⴣ'

CapitalLetterHar

\u{10c4}: 'Ⴤ'

CapitalLetterHoe

\u{10c5}: 'Ⴥ'

CapitalLetterYn

\u{10c7}: 'Ⴧ'

CapitalLetterAen

\u{10cd}: 'Ⴭ'

LetterAn

\u{10d0}: 'ა'

LetterBan

\u{10d1}: 'ბ'

LetterGan

\u{10d2}: 'გ'

LetterDon

\u{10d3}: 'დ'

LetterEn

\u{10d4}: 'ე'

LetterVin

\u{10d5}: 'ვ'

LetterZen

\u{10d6}: 'ზ'

LetterTan

\u{10d7}: 'თ'

LetterIn

\u{10d8}: 'ი'

LetterKan

\u{10d9}: 'კ'

LetterLas

\u{10da}: 'ლ'

LetterMan

\u{10db}: 'მ'

LetterNar

\u{10dc}: 'ნ'

LetterOn

\u{10dd}: 'ო'

LetterPar

\u{10de}: 'პ'

LetterZhar

\u{10df}: 'ჟ'

LetterRae

\u{10e0}: 'რ'

LetterSan

\u{10e1}: 'ს'

LetterTar

\u{10e2}: 'ტ'

LetterUn

\u{10e3}: 'უ'

LetterPhar

\u{10e4}: 'ფ'

LetterKhar

\u{10e5}: 'ქ'

LetterGhan

\u{10e6}: 'ღ'

LetterQar

\u{10e7}: 'ყ'

LetterShin

\u{10e8}: 'შ'

LetterChin

\u{10e9}: 'ჩ'

LetterCan

\u{10ea}: 'ც'

LetterJil

\u{10eb}: 'ძ'

LetterCil

\u{10ec}: 'წ'

LetterChar

\u{10ed}: 'ჭ'

LetterXan

\u{10ee}: 'ხ'

LetterJhan

\u{10ef}: 'ჯ'

LetterHae

\u{10f0}: 'ჰ'

LetterHe

\u{10f1}: 'ჱ'

LetterHie

\u{10f2}: 'ჲ'

LetterWe

\u{10f3}: 'ჳ'

LetterHar

\u{10f4}: 'ჴ'

LetterHoe

\u{10f5}: 'ჵ'

LetterFi

\u{10f6}: 'ჶ'

LetterYn

\u{10f7}: 'ჷ'

LetterElifi

\u{10f8}: 'ჸ'

LetterTurnedGan

\u{10f9}: 'ჹ'

LetterAin

\u{10fa}: 'ჺ'

ParagraphSeparator

\u{10fb}: '჻'

ModifierLetterNar

\u{10fc}: 'ჼ'

LetterAen

\u{10fd}: 'ჽ'

LetterHardSign

\u{10fe}: 'ჾ'

Methods

impl Georgian

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 Georgian

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<Georgian> for Georgian

fn eq(&self, other: &Georgian) -> 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 Georgian

Important traits for Georgian

impl Iterator for Georgian type Item = Self;

fn clone(&self) -> Georgian

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Into<char> for Georgian

fn into(self) -> char

Performs the conversion.

impl Into<u32> for Georgian

fn into(self) -> u32

Performs the conversion.

impl Eq for Georgian

impl Copy for Georgian

impl Hash for Georgian

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 Georgian

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

Formats the value using the given formatter.

impl TryFrom<char> for Georgian

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 Georgian

type Error = ()

The type returned in the event of a conversion error.

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

Performs the conversion.