Enum unicode_types::phonetic_extensions::PhoneticExtensions

pub enum PhoneticExtensions {
    LatinLetterSmallCapitalA,
    LatinLetterSmallCapitalAe,
    LatinSmallLetterTurnedAe,
    LatinLetterSmallCapitalBarredB,
    LatinLetterSmallCapitalC,
    LatinLetterSmallCapitalD,
    LatinLetterSmallCapitalEth,
    LatinLetterSmallCapitalE,
    LatinSmallLetterTurnedOpenE,
    LatinSmallLetterTurnedI,
    LatinLetterSmallCapitalJ,
    LatinLetterSmallCapitalK,
    LatinLetterSmallCapitalLWithStroke,
    LatinLetterSmallCapitalM,
    LatinLetterSmallCapitalReversedN,
    LatinLetterSmallCapitalO,
    LatinLetterSmallCapitalOpenO,
    LatinSmallLetterSidewaysO,
    LatinSmallLetterSidewaysOpenO,
    LatinSmallLetterSidewaysOWithStroke,
    LatinSmallLetterTurnedOe,
    LatinLetterSmallCapitalOu,
    LatinSmallLetterTopHalfO,
    LatinSmallLetterBottomHalfO,
    LatinLetterSmallCapitalP,
    LatinLetterSmallCapitalReversedR,
    LatinLetterSmallCapitalTurnedR,
    LatinLetterSmallCapitalT,
    LatinLetterSmallCapitalU,
    LatinSmallLetterSidewaysU,
    LatinSmallLetterSidewaysDiaeresizedU,
    LatinSmallLetterSidewaysTurnedM,
    LatinLetterSmallCapitalV,
    LatinLetterSmallCapitalW,
    LatinLetterSmallCapitalZ,
    LatinLetterSmallCapitalEzh,
    LatinLetterVoicedLaryngealSpirant,
    LatinLetterAin,
    GreekLetterSmallCapitalGamma,
    GreekLetterSmallCapitalLamda,
    GreekLetterSmallCapitalPi,
    GreekLetterSmallCapitalRho,
    GreekLetterSmallCapitalPsi,
    CyrillicLetterSmallCapitalEl,
    ModifierLetterCapitalA,
    ModifierLetterCapitalAe,
    ModifierLetterCapitalB,
    ModifierLetterCapitalBarredB,
    ModifierLetterCapitalD,
    ModifierLetterCapitalE,
    ModifierLetterCapitalReversedE,
    ModifierLetterCapitalG,
    ModifierLetterCapitalH,
    ModifierLetterCapitalI,
    ModifierLetterCapitalJ,
    ModifierLetterCapitalK,
    ModifierLetterCapitalL,
    ModifierLetterCapitalM,
    ModifierLetterCapitalN,
    ModifierLetterCapitalReversedN,
    ModifierLetterCapitalO,
    ModifierLetterCapitalOu,
    ModifierLetterCapitalP,
    ModifierLetterCapitalR,
    ModifierLetterCapitalT,
    ModifierLetterCapitalU,
    ModifierLetterCapitalW,
    ModifierLetterSmallA,
    ModifierLetterSmallTurnedA,
    ModifierLetterSmallAlpha,
    ModifierLetterSmallTurnedAe,
    ModifierLetterSmallB,
    ModifierLetterSmallD,
    ModifierLetterSmallE,
    ModifierLetterSmallSchwa,
    ModifierLetterSmallOpenE,
    ModifierLetterSmallTurnedOpenE,
    ModifierLetterSmallG,
    ModifierLetterSmallTurnedI,
    ModifierLetterSmallK,
    ModifierLetterSmallM,
    ModifierLetterSmallEng,
    ModifierLetterSmallO,
    ModifierLetterSmallOpenO,
    ModifierLetterSmallTopHalfO,
    ModifierLetterSmallBottomHalfO,
    ModifierLetterSmallP,
    ModifierLetterSmallT,
    ModifierLetterSmallU,
    ModifierLetterSmallSidewaysU,
    ModifierLetterSmallTurnedM,
    ModifierLetterSmallV,
    ModifierLetterSmallAin,
    ModifierLetterSmallBeta,
    ModifierLetterSmallGreekGamma,
    ModifierLetterSmallDelta,
    ModifierLetterSmallGreekPhi,
    ModifierLetterSmallChi,
    LatinSubscriptSmallLetterI,
    LatinSubscriptSmallLetterR,
    LatinSubscriptSmallLetterU,
    LatinSubscriptSmallLetterV,
    GreekSubscriptSmallLetterBeta,
    GreekSubscriptSmallLetterGamma,
    GreekSubscriptSmallLetterRho,
    GreekSubscriptSmallLetterPhi,
    GreekSubscriptSmallLetterChi,
    LatinSmallLetterUe,
    LatinSmallLetterBWithMiddleTilde,
    LatinSmallLetterDWithMiddleTilde,
    LatinSmallLetterFWithMiddleTilde,
    LatinSmallLetterMWithMiddleTilde,
    LatinSmallLetterNWithMiddleTilde,
    LatinSmallLetterPWithMiddleTilde,
    LatinSmallLetterRWithMiddleTilde,
    LatinSmallLetterRWithFishhookAndMiddleTilde,
    LatinSmallLetterSWithMiddleTilde,
    LatinSmallLetterTWithMiddleTilde,
    LatinSmallLetterZWithMiddleTilde,
    LatinSmallLetterTurnedG,
    ModifierLetterCyrillicEn,
    LatinSmallLetterInsularG,
    LatinSmallLetterThWithStrikethrough,
    LatinSmallCapitalLetterIWithStroke,
    LatinSmallLetterIotaWithStroke,
    LatinSmallLetterPWithStroke,
    LatinSmallCapitalLetterUWithStroke,
}

An enum to represent all characters in the PhoneticExtensions block.

Variants

LatinLetterSmallCapitalA

\u{1d00}: 'ᴀ'

LatinLetterSmallCapitalAe

\u{1d01}: 'ᴁ'

LatinSmallLetterTurnedAe

\u{1d02}: 'ᴂ'

LatinLetterSmallCapitalBarredB

\u{1d03}: 'ᴃ'

LatinLetterSmallCapitalC

\u{1d04}: 'ᴄ'

LatinLetterSmallCapitalD

\u{1d05}: 'ᴅ'

LatinLetterSmallCapitalEth

\u{1d06}: 'ᴆ'

LatinLetterSmallCapitalE

\u{1d07}: 'ᴇ'

LatinSmallLetterTurnedOpenE

\u{1d08}: 'ᴈ'

LatinSmallLetterTurnedI

\u{1d09}: 'ᴉ'

LatinLetterSmallCapitalJ

\u{1d0a}: 'ᴊ'

LatinLetterSmallCapitalK

\u{1d0b}: 'ᴋ'

LatinLetterSmallCapitalLWithStroke

\u{1d0c}: 'ᴌ'

LatinLetterSmallCapitalM

\u{1d0d}: 'ᴍ'

LatinLetterSmallCapitalReversedN

\u{1d0e}: 'ᴎ'

LatinLetterSmallCapitalO

\u{1d0f}: 'ᴏ'

LatinLetterSmallCapitalOpenO

\u{1d10}: 'ᴐ'

LatinSmallLetterSidewaysO

\u{1d11}: 'ᴑ'

LatinSmallLetterSidewaysOpenO

\u{1d12}: 'ᴒ'

LatinSmallLetterSidewaysOWithStroke

\u{1d13}: 'ᴓ'

LatinSmallLetterTurnedOe

\u{1d14}: 'ᴔ'

LatinLetterSmallCapitalOu

\u{1d15}: 'ᴕ'

LatinSmallLetterTopHalfO

\u{1d16}: 'ᴖ'

LatinSmallLetterBottomHalfO

\u{1d17}: 'ᴗ'

LatinLetterSmallCapitalP

\u{1d18}: 'ᴘ'

LatinLetterSmallCapitalReversedR

\u{1d19}: 'ᴙ'

LatinLetterSmallCapitalTurnedR

\u{1d1a}: 'ᴚ'

LatinLetterSmallCapitalT

\u{1d1b}: 'ᴛ'

LatinLetterSmallCapitalU

\u{1d1c}: 'ᴜ'

LatinSmallLetterSidewaysU

\u{1d1d}: 'ᴝ'

LatinSmallLetterSidewaysDiaeresizedU

\u{1d1e}: 'ᴞ'

LatinSmallLetterSidewaysTurnedM

\u{1d1f}: 'ᴟ'

LatinLetterSmallCapitalV

\u{1d20}: 'ᴠ'

LatinLetterSmallCapitalW

\u{1d21}: 'ᴡ'

LatinLetterSmallCapitalZ

\u{1d22}: 'ᴢ'

LatinLetterSmallCapitalEzh

\u{1d23}: 'ᴣ'

LatinLetterVoicedLaryngealSpirant

\u{1d24}: 'ᴤ'

LatinLetterAin

\u{1d25}: 'ᴥ'

GreekLetterSmallCapitalGamma

\u{1d26}: 'ᴦ'

GreekLetterSmallCapitalLamda

\u{1d27}: 'ᴧ'

GreekLetterSmallCapitalPi

\u{1d28}: 'ᴨ'

GreekLetterSmallCapitalRho

\u{1d29}: 'ᴩ'

GreekLetterSmallCapitalPsi

\u{1d2a}: 'ᴪ'

CyrillicLetterSmallCapitalEl

\u{1d2b}: 'ᴫ'

ModifierLetterCapitalA

\u{1d2c}: 'ᴬ'

ModifierLetterCapitalAe

\u{1d2d}: 'ᴭ'

ModifierLetterCapitalB

\u{1d2e}: 'ᴮ'

ModifierLetterCapitalBarredB

\u{1d2f}: 'ᴯ'

ModifierLetterCapitalD

\u{1d30}: 'ᴰ'

ModifierLetterCapitalE

\u{1d31}: 'ᴱ'

ModifierLetterCapitalReversedE

\u{1d32}: 'ᴲ'

ModifierLetterCapitalG

\u{1d33}: 'ᴳ'

ModifierLetterCapitalH

\u{1d34}: 'ᴴ'

ModifierLetterCapitalI

\u{1d35}: 'ᴵ'

ModifierLetterCapitalJ

\u{1d36}: 'ᴶ'

ModifierLetterCapitalK

\u{1d37}: 'ᴷ'

ModifierLetterCapitalL

\u{1d38}: 'ᴸ'

ModifierLetterCapitalM

\u{1d39}: 'ᴹ'

ModifierLetterCapitalN

\u{1d3a}: 'ᴺ'

ModifierLetterCapitalReversedN

\u{1d3b}: 'ᴻ'

ModifierLetterCapitalO

\u{1d3c}: 'ᴼ'

ModifierLetterCapitalOu

\u{1d3d}: 'ᴽ'

ModifierLetterCapitalP

\u{1d3e}: 'ᴾ'

ModifierLetterCapitalR

\u{1d3f}: 'ᴿ'

ModifierLetterCapitalT

\u{1d40}: 'ᵀ'

ModifierLetterCapitalU

\u{1d41}: 'ᵁ'

ModifierLetterCapitalW

\u{1d42}: 'ᵂ'

ModifierLetterSmallA

\u{1d43}: 'ᵃ'

ModifierLetterSmallTurnedA

\u{1d44}: 'ᵄ'

ModifierLetterSmallAlpha

\u{1d45}: 'ᵅ'

ModifierLetterSmallTurnedAe

\u{1d46}: 'ᵆ'

ModifierLetterSmallB

\u{1d47}: 'ᵇ'

ModifierLetterSmallD

\u{1d48}: 'ᵈ'

ModifierLetterSmallE

\u{1d49}: 'ᵉ'

ModifierLetterSmallSchwa

\u{1d4a}: 'ᵊ'

ModifierLetterSmallOpenE

\u{1d4b}: 'ᵋ'

ModifierLetterSmallTurnedOpenE

\u{1d4c}: 'ᵌ'

ModifierLetterSmallG

\u{1d4d}: 'ᵍ'

ModifierLetterSmallTurnedI

\u{1d4e}: 'ᵎ'

ModifierLetterSmallK

\u{1d4f}: 'ᵏ'

ModifierLetterSmallM

\u{1d50}: 'ᵐ'

ModifierLetterSmallEng

\u{1d51}: 'ᵑ'

ModifierLetterSmallO

\u{1d52}: 'ᵒ'

ModifierLetterSmallOpenO

\u{1d53}: 'ᵓ'

ModifierLetterSmallTopHalfO

\u{1d54}: 'ᵔ'

ModifierLetterSmallBottomHalfO

\u{1d55}: 'ᵕ'

ModifierLetterSmallP

\u{1d56}: 'ᵖ'

ModifierLetterSmallT

\u{1d57}: 'ᵗ'

ModifierLetterSmallU

\u{1d58}: 'ᵘ'

ModifierLetterSmallSidewaysU

\u{1d59}: 'ᵙ'

ModifierLetterSmallTurnedM

\u{1d5a}: 'ᵚ'

ModifierLetterSmallV

\u{1d5b}: 'ᵛ'

ModifierLetterSmallAin

\u{1d5c}: 'ᵜ'

ModifierLetterSmallBeta

\u{1d5d}: 'ᵝ'

ModifierLetterSmallGreekGamma

\u{1d5e}: 'ᵞ'

ModifierLetterSmallDelta

\u{1d5f}: 'ᵟ'

ModifierLetterSmallGreekPhi

\u{1d60}: 'ᵠ'

ModifierLetterSmallChi

\u{1d61}: 'ᵡ'

LatinSubscriptSmallLetterI

\u{1d62}: 'ᵢ'

LatinSubscriptSmallLetterR

\u{1d63}: 'ᵣ'

LatinSubscriptSmallLetterU

\u{1d64}: 'ᵤ'

LatinSubscriptSmallLetterV

\u{1d65}: 'ᵥ'

GreekSubscriptSmallLetterBeta

\u{1d66}: 'ᵦ'

GreekSubscriptSmallLetterGamma

\u{1d67}: 'ᵧ'

GreekSubscriptSmallLetterRho

\u{1d68}: 'ᵨ'

GreekSubscriptSmallLetterPhi

\u{1d69}: 'ᵩ'

GreekSubscriptSmallLetterChi

\u{1d6a}: 'ᵪ'

LatinSmallLetterUe

\u{1d6b}: 'ᵫ'

LatinSmallLetterBWithMiddleTilde

\u{1d6c}: 'ᵬ'

LatinSmallLetterDWithMiddleTilde

\u{1d6d}: 'ᵭ'

LatinSmallLetterFWithMiddleTilde

\u{1d6e}: 'ᵮ'

LatinSmallLetterMWithMiddleTilde

\u{1d6f}: 'ᵯ'

LatinSmallLetterNWithMiddleTilde

\u{1d70}: 'ᵰ'

LatinSmallLetterPWithMiddleTilde

\u{1d71}: 'ᵱ'

LatinSmallLetterRWithMiddleTilde

\u{1d72}: 'ᵲ'

LatinSmallLetterRWithFishhookAndMiddleTilde

\u{1d73}: 'ᵳ'

LatinSmallLetterSWithMiddleTilde

\u{1d74}: 'ᵴ'

LatinSmallLetterTWithMiddleTilde

\u{1d75}: 'ᵵ'

LatinSmallLetterZWithMiddleTilde

\u{1d76}: 'ᵶ'

LatinSmallLetterTurnedG

\u{1d77}: 'ᵷ'

ModifierLetterCyrillicEn

\u{1d78}: 'ᵸ'

LatinSmallLetterInsularG

\u{1d79}: 'ᵹ'

LatinSmallLetterThWithStrikethrough

\u{1d7a}: 'ᵺ'

LatinSmallCapitalLetterIWithStroke

\u{1d7b}: 'ᵻ'

LatinSmallLetterIotaWithStroke

\u{1d7c}: 'ᵼ'

LatinSmallLetterPWithStroke

\u{1d7d}: 'ᵽ'

LatinSmallCapitalLetterUWithStroke

\u{1d7e}: 'ᵾ'

Methods

impl PhoneticExtensions

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 PhoneticExtensions

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

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

Important traits for PhoneticExtensions

impl Iterator for PhoneticExtensions type Item = Self;

fn clone(&self) -> PhoneticExtensions

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Into<char> for PhoneticExtensions

fn into(self) -> char

Performs the conversion.

impl Into<u32> for PhoneticExtensions

fn into(self) -> u32

Performs the conversion.

impl Eq for PhoneticExtensions

impl Copy for PhoneticExtensions

impl Hash for PhoneticExtensions

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 PhoneticExtensions

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

Formats the value using the given formatter.

impl TryFrom<char> for PhoneticExtensions

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 PhoneticExtensions

type Error = ()

The type returned in the event of a conversion error.

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

Performs the conversion.