Enum unicode_types::coptic::Coptic

pub enum Coptic {
    CapitalLetterAlfa,
    SmallLetterAlfa,
    CapitalLetterVida,
    SmallLetterVida,
    CapitalLetterGamma,
    SmallLetterGamma,
    CapitalLetterDalda,
    SmallLetterDalda,
    CapitalLetterEie,
    SmallLetterEie,
    CapitalLetterSou,
    SmallLetterSou,
    CapitalLetterZata,
    SmallLetterZata,
    CapitalLetterHate,
    SmallLetterHate,
    CapitalLetterThethe,
    SmallLetterThethe,
    CapitalLetterIauda,
    SmallLetterIauda,
    CapitalLetterKapa,
    SmallLetterKapa,
    CapitalLetterLaula,
    SmallLetterLaula,
    CapitalLetterMi,
    SmallLetterMi,
    CapitalLetterNi,
    SmallLetterNi,
    CapitalLetterKsi,
    SmallLetterKsi,
    CapitalLetterO,
    SmallLetterO,
    CapitalLetterPi,
    SmallLetterPi,
    CapitalLetterRo,
    SmallLetterRo,
    CapitalLetterSima,
    SmallLetterSima,
    CapitalLetterTau,
    SmallLetterTau,
    CapitalLetterUa,
    SmallLetterUa,
    CapitalLetterFi,
    SmallLetterFi,
    CapitalLetterKhi,
    SmallLetterKhi,
    CapitalLetterPsi,
    SmallLetterPsi,
    CapitalLetterOou,
    SmallLetterOou,
    CapitalLetterDialectDashPAlef,
    SmallLetterDialectDashPAlef,
    CapitalLetterOldAin,
    SmallLetterOldAin,
    CapitalLetterCryptogrammicEie,
    SmallLetterCryptogrammicEie,
    CapitalLetterDialectDashPKapa,
    SmallLetterDialectDashPKapa,
    CapitalLetterDialectDashPNi,
    SmallLetterDialectDashPNi,
    CapitalLetterCryptogrammicNi,
    SmallLetterCryptogrammicNi,
    CapitalLetterOldOou,
    SmallLetterOldOou,
    CapitalLetterSampi,
    SmallLetterSampi,
    CapitalLetterCrossedShei,
    SmallLetterCrossedShei,
    CapitalLetterOldShei,
    SmallLetterOldShei,
    CapitalLetterOldEsh,
    SmallLetterOldEsh,
    CapitalLetterAkhmimicKhei,
    SmallLetterAkhmimicKhei,
    CapitalLetterDialectDashPHori,
    SmallLetterDialectDashPHori,
    CapitalLetterOldHori,
    SmallLetterOldHori,
    CapitalLetterOldHa,
    SmallLetterOldHa,
    CapitalLetterLDashShapedHa,
    SmallLetterLDashShapedHa,
    CapitalLetterOldHei,
    SmallLetterOldHei,
    CapitalLetterOldHat,
    SmallLetterOldHat,
    CapitalLetterOldGangia,
    SmallLetterOldGangia,
    CapitalLetterOldDja,
    SmallLetterOldDja,
    CapitalLetterOldShima,
    SmallLetterOldShima,
    CapitalLetterOldNubianShima,
    SmallLetterOldNubianShima,
    CapitalLetterOldNubianNgi,
    SmallLetterOldNubianNgi,
    CapitalLetterOldNubianNyi,
    SmallLetterOldNubianNyi,
    CapitalLetterOldNubianWau,
    SmallLetterOldNubianWau,
    SymbolKai,
    SymbolMiRo,
    SymbolPiRo,
    SymbolStauros,
    SymbolTauRo,
    SymbolKhiRo,
    SymbolShimaSima,
    CapitalLetterCryptogrammicShei,
    SmallLetterCryptogrammicShei,
    CapitalLetterCryptogrammicGangia,
    SmallLetterCryptogrammicGangia,
    CombiningNiAbove,
    CombiningSpiritusAsper,
    CombiningSpiritusLenis,
    CapitalLetterBohairicKhei,
    SmallLetterBohairicKhei,
    OldNubianFullStop,
    OldNubianDirectQuestionMark,
    OldNubianIndirectQuestionMark,
    OldNubianVerseDivider,
    FractionOneHalf,
    FullStop,
}

An enum to represent all characters in the Coptic block.

Variants

CapitalLetterAlfa

\u{2c80}: 'Ⲁ'

SmallLetterAlfa

\u{2c81}: 'ⲁ'

CapitalLetterVida

\u{2c82}: 'Ⲃ'

SmallLetterVida

\u{2c83}: 'ⲃ'

CapitalLetterGamma

\u{2c84}: 'Ⲅ'

SmallLetterGamma

\u{2c85}: 'ⲅ'

CapitalLetterDalda

\u{2c86}: 'Ⲇ'

SmallLetterDalda

\u{2c87}: 'ⲇ'

CapitalLetterEie

\u{2c88}: 'Ⲉ'

SmallLetterEie

\u{2c89}: 'ⲉ'

CapitalLetterSou

\u{2c8a}: 'Ⲋ'

SmallLetterSou

\u{2c8b}: 'ⲋ'

CapitalLetterZata

\u{2c8c}: 'Ⲍ'

SmallLetterZata

\u{2c8d}: 'ⲍ'

CapitalLetterHate

\u{2c8e}: 'Ⲏ'

SmallLetterHate

\u{2c8f}: 'ⲏ'

CapitalLetterThethe

\u{2c90}: 'Ⲑ'

SmallLetterThethe

\u{2c91}: 'ⲑ'

CapitalLetterIauda

\u{2c92}: 'Ⲓ'

SmallLetterIauda

\u{2c93}: 'ⲓ'

CapitalLetterKapa

\u{2c94}: 'Ⲕ'

SmallLetterKapa

\u{2c95}: 'ⲕ'

CapitalLetterLaula

\u{2c96}: 'Ⲗ'

SmallLetterLaula

\u{2c97}: 'ⲗ'

CapitalLetterMi

\u{2c98}: 'Ⲙ'

SmallLetterMi

\u{2c99}: 'ⲙ'

CapitalLetterNi

\u{2c9a}: 'Ⲛ'

SmallLetterNi

\u{2c9b}: 'ⲛ'

CapitalLetterKsi

\u{2c9c}: 'Ⲝ'

SmallLetterKsi

\u{2c9d}: 'ⲝ'

CapitalLetterO

\u{2c9e}: 'Ⲟ'

SmallLetterO

\u{2c9f}: 'ⲟ'

CapitalLetterPi

\u{2ca0}: 'Ⲡ'

SmallLetterPi

\u{2ca1}: 'ⲡ'

CapitalLetterRo

\u{2ca2}: 'Ⲣ'

SmallLetterRo

\u{2ca3}: 'ⲣ'

CapitalLetterSima

\u{2ca4}: 'Ⲥ'

SmallLetterSima

\u{2ca5}: 'ⲥ'

CapitalLetterTau

\u{2ca6}: 'Ⲧ'

SmallLetterTau

\u{2ca7}: 'ⲧ'

CapitalLetterUa

\u{2ca8}: 'Ⲩ'

SmallLetterUa

\u{2ca9}: 'ⲩ'

CapitalLetterFi

\u{2caa}: 'Ⲫ'

SmallLetterFi

\u{2cab}: 'ⲫ'

CapitalLetterKhi

\u{2cac}: 'Ⲭ'

SmallLetterKhi

\u{2cad}: 'ⲭ'

CapitalLetterPsi

\u{2cae}: 'Ⲯ'

SmallLetterPsi

\u{2caf}: 'ⲯ'

CapitalLetterOou

\u{2cb0}: 'Ⲱ'

SmallLetterOou

\u{2cb1}: 'ⲱ'

CapitalLetterDialectDashPAlef

\u{2cb2}: 'Ⲳ'

SmallLetterDialectDashPAlef

\u{2cb3}: 'ⲳ'

CapitalLetterOldAin

\u{2cb4}: 'Ⲵ'

SmallLetterOldAin

\u{2cb5}: 'ⲵ'

CapitalLetterCryptogrammicEie

\u{2cb6}: 'Ⲷ'

SmallLetterCryptogrammicEie

\u{2cb7}: 'ⲷ'

CapitalLetterDialectDashPKapa

\u{2cb8}: 'Ⲹ'

SmallLetterDialectDashPKapa

\u{2cb9}: 'ⲹ'

CapitalLetterDialectDashPNi

\u{2cba}: 'Ⲻ'

SmallLetterDialectDashPNi

\u{2cbb}: 'ⲻ'

CapitalLetterCryptogrammicNi

\u{2cbc}: 'Ⲽ'

SmallLetterCryptogrammicNi

\u{2cbd}: 'ⲽ'

CapitalLetterOldOou

\u{2cbe}: 'Ⲿ'

SmallLetterOldOou

\u{2cbf}: 'ⲿ'

CapitalLetterSampi

\u{2cc0}: 'Ⳁ'

SmallLetterSampi

\u{2cc1}: 'ⳁ'

CapitalLetterCrossedShei

\u{2cc2}: 'Ⳃ'

SmallLetterCrossedShei

\u{2cc3}: 'ⳃ'

CapitalLetterOldShei

\u{2cc4}: 'Ⳅ'

SmallLetterOldShei

\u{2cc5}: 'ⳅ'

CapitalLetterOldEsh

\u{2cc6}: 'Ⳇ'

SmallLetterOldEsh

\u{2cc7}: 'ⳇ'

CapitalLetterAkhmimicKhei

\u{2cc8}: 'Ⳉ'

SmallLetterAkhmimicKhei

\u{2cc9}: 'ⳉ'

CapitalLetterDialectDashPHori

\u{2cca}: 'Ⳋ'

SmallLetterDialectDashPHori

\u{2ccb}: 'ⳋ'

CapitalLetterOldHori

\u{2ccc}: 'Ⳍ'

SmallLetterOldHori

\u{2ccd}: 'ⳍ'

CapitalLetterOldHa

\u{2cce}: 'Ⳏ'

SmallLetterOldHa

\u{2ccf}: 'ⳏ'

CapitalLetterLDashShapedHa

\u{2cd0}: 'Ⳑ'

SmallLetterLDashShapedHa

\u{2cd1}: 'ⳑ'

CapitalLetterOldHei

\u{2cd2}: 'Ⳓ'

SmallLetterOldHei

\u{2cd3}: 'ⳓ'

CapitalLetterOldHat

\u{2cd4}: 'Ⳕ'

SmallLetterOldHat

\u{2cd5}: 'ⳕ'

CapitalLetterOldGangia

\u{2cd6}: 'Ⳗ'

SmallLetterOldGangia

\u{2cd7}: 'ⳗ'

CapitalLetterOldDja

\u{2cd8}: 'Ⳙ'

SmallLetterOldDja

\u{2cd9}: 'ⳙ'

CapitalLetterOldShima

\u{2cda}: 'Ⳛ'

SmallLetterOldShima

\u{2cdb}: 'ⳛ'

CapitalLetterOldNubianShima

\u{2cdc}: 'Ⳝ'

SmallLetterOldNubianShima

\u{2cdd}: 'ⳝ'

CapitalLetterOldNubianNgi

\u{2cde}: 'Ⳟ'

SmallLetterOldNubianNgi

\u{2cdf}: 'ⳟ'

CapitalLetterOldNubianNyi

\u{2ce0}: 'Ⳡ'

SmallLetterOldNubianNyi

\u{2ce1}: 'ⳡ'

CapitalLetterOldNubianWau

\u{2ce2}: 'Ⳣ'

SmallLetterOldNubianWau

\u{2ce3}: 'ⳣ'

SymbolKai

\u{2ce4}: 'ⳤ'

SymbolMiRo

\u{2ce5}: '⳥'

SymbolPiRo

\u{2ce6}: '⳦'

SymbolStauros

\u{2ce7}: '⳧'

SymbolTauRo

\u{2ce8}: '⳨'

SymbolKhiRo

\u{2ce9}: '⳩'

SymbolShimaSima

\u{2cea}: '⳪'

CapitalLetterCryptogrammicShei

\u{2ceb}: 'Ⳬ'

SmallLetterCryptogrammicShei

\u{2cec}: 'ⳬ'

CapitalLetterCryptogrammicGangia

\u{2ced}: 'Ⳮ'

SmallLetterCryptogrammicGangia

\u{2cee}: 'ⳮ'

CombiningNiAbove

\u{2cef}: '⳯'

CombiningSpiritusAsper

\u{2cf0}: '⳰'

CombiningSpiritusLenis

\u{2cf1}: '⳱'

CapitalLetterBohairicKhei

\u{2cf2}: 'Ⳳ'

SmallLetterBohairicKhei

\u{2cf3}: 'ⳳ'

OldNubianFullStop

\u{2cf9}: '⳹'

OldNubianDirectQuestionMark

\u{2cfa}: '⳺'

OldNubianIndirectQuestionMark

\u{2cfb}: '⳻'

OldNubianVerseDivider

\u{2cfc}: '⳼'

FractionOneHalf

\u{2cfd}: '⳽'

FullStop

\u{2cfe}: '⳾'

Methods

impl Coptic

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 Coptic

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

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

Important traits for Coptic

impl Iterator for Coptic type Item = Self;

fn clone(&self) -> Coptic

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Into<char> for Coptic

fn into(self) -> char

Performs the conversion.

impl Into<u32> for Coptic

fn into(self) -> u32

Performs the conversion.

impl Eq for Coptic

impl Copy for Coptic

impl Hash for Coptic

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 Coptic

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

Formats the value using the given formatter.

impl TryFrom<char> for Coptic

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 Coptic

type Error = ()

The type returned in the event of a conversion error.

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

Performs the conversion.