Enum unicode_types::latin_extended_d::LatinExtendedD

pub enum LatinExtendedD {
    ModifierLetterStressAndHighTone,
    ModifierLetterStressAndLowTone,
    LatinCapitalLetterEgyptologicalAlef,
    LatinSmallLetterEgyptologicalAlef,
    LatinCapitalLetterEgyptologicalAin,
    LatinSmallLetterEgyptologicalAin,
    LatinCapitalLetterHeng,
    LatinSmallLetterHeng,
    LatinCapitalLetterTz,
    LatinSmallLetterTz,
    LatinCapitalLetterTresillo,
    LatinSmallLetterTresillo,
    LatinCapitalLetterCuatrillo,
    LatinSmallLetterCuatrillo,
    LatinCapitalLetterCuatrilloWithComma,
    LatinSmallLetterCuatrilloWithComma,
    LatinLetterSmallCapitalF,
    LatinLetterSmallCapitalS,
    LatinCapitalLetterAa,
    LatinSmallLetterAa,
    LatinCapitalLetterAo,
    LatinSmallLetterAo,
    LatinCapitalLetterAu,
    LatinSmallLetterAu,
    LatinCapitalLetterAv,
    LatinSmallLetterAv,
    LatinCapitalLetterAvWithHorizontalBar,
    LatinSmallLetterAvWithHorizontalBar,
    LatinCapitalLetterAy,
    LatinSmallLetterAy,
    LatinCapitalLetterReversedCWithDot,
    LatinSmallLetterReversedCWithDot,
    LatinCapitalLetterKWithStroke,
    LatinSmallLetterKWithStroke,
    LatinCapitalLetterKWithDiagonalStroke,
    LatinSmallLetterKWithDiagonalStroke,
    LatinCapitalLetterKWithStrokeAndDiagonalStroke,
    LatinSmallLetterKWithStrokeAndDiagonalStroke,
    LatinCapitalLetterBrokenL,
    LatinSmallLetterBrokenL,
    LatinCapitalLetterLWithHighStroke,
    LatinSmallLetterLWithHighStroke,
    LatinCapitalLetterOWithLongStrokeOverlay,
    LatinSmallLetterOWithLongStrokeOverlay,
    LatinCapitalLetterOWithLoop,
    LatinSmallLetterOWithLoop,
    LatinCapitalLetterOo,
    LatinSmallLetterOo,
    LatinCapitalLetterPWithStrokeThroughDescender,
    LatinSmallLetterPWithStrokeThroughDescender,
    LatinCapitalLetterPWithFlourish,
    LatinSmallLetterPWithFlourish,
    LatinCapitalLetterPWithSquirrelTail,
    LatinSmallLetterPWithSquirrelTail,
    LatinCapitalLetterQWithStrokeThroughDescender,
    LatinSmallLetterQWithStrokeThroughDescender,
    LatinCapitalLetterQWithDiagonalStroke,
    LatinSmallLetterQWithDiagonalStroke,
    LatinCapitalLetterRRotunda,
    LatinSmallLetterRRotunda,
    LatinCapitalLetterRumRotunda,
    LatinSmallLetterRumRotunda,
    LatinCapitalLetterVWithDiagonalStroke,
    LatinSmallLetterVWithDiagonalStroke,
    LatinCapitalLetterVy,
    LatinSmallLetterVy,
    LatinCapitalLetterVisigothicZ,
    LatinSmallLetterVisigothicZ,
    LatinCapitalLetterThornWithStroke,
    LatinSmallLetterThornWithStroke,
    LatinCapitalLetterThornWithStrokeThroughDescender,
    LatinSmallLetterThornWithStrokeThroughDescender,
    LatinCapitalLetterVend,
    LatinSmallLetterVend,
    LatinCapitalLetterEt,
    LatinSmallLetterEt,
    LatinCapitalLetterIs,
    LatinSmallLetterIs,
    LatinCapitalLetterCon,
    LatinSmallLetterCon,
    ModifierLetterUs,
    LatinSmallLetterDum,
    LatinSmallLetterLum,
    LatinSmallLetterMum,
    LatinSmallLetterNum,
    LatinSmallLetterRum,
    LatinLetterSmallCapitalRum,
    LatinSmallLetterTum,
    LatinSmallLetterUm,
    LatinCapitalLetterInsularD,
    LatinSmallLetterInsularD,
    LatinCapitalLetterInsularF,
    LatinSmallLetterInsularF,
    LatinCapitalLetterInsularG,
    LatinCapitalLetterTurnedInsularG,
    LatinSmallLetterTurnedInsularG,
    LatinCapitalLetterTurnedL,
    LatinSmallLetterTurnedL,
    LatinCapitalLetterInsularR,
    LatinSmallLetterInsularR,
    LatinCapitalLetterInsularS,
    LatinSmallLetterInsularS,
    LatinCapitalLetterInsularT,
    LatinSmallLetterInsularT,
    ModifierLetterLowCircumflexAccent,
    ModifierLetterColon,
    ModifierLetterShortEqualsSign,
    LatinCapitalLetterSaltillo,
    LatinSmallLetterSaltillo,
    LatinCapitalLetterTurnedH,
    LatinSmallLetterLWithRetroflexHookAndBelt,
    LatinLetterSinologicalDot,
    LatinCapitalLetterNWithDescender,
    LatinSmallLetterNWithDescender,
    LatinCapitalLetterCWithBar,
    LatinSmallLetterCWithBar,
    LatinSmallLetterCWithPalatalHook,
    LatinSmallLetterHWithPalatalHook,
    LatinCapitalLetterBWithFlourish,
    LatinSmallLetterBWithFlourish,
    LatinCapitalLetterFWithStroke,
    LatinSmallLetterFWithStroke,
    LatinCapitalLetterVolapukAe,
    LatinSmallLetterVolapukAe,
    LatinCapitalLetterVolapukOe,
    LatinSmallLetterVolapukOe,
    LatinCapitalLetterVolapukUe,
    LatinSmallLetterVolapukUe,
    LatinCapitalLetterGWithObliqueStroke,
    LatinSmallLetterGWithObliqueStroke,
    LatinCapitalLetterKWithObliqueStroke,
    LatinSmallLetterKWithObliqueStroke,
    LatinCapitalLetterNWithObliqueStroke,
    LatinSmallLetterNWithObliqueStroke,
    LatinCapitalLetterRWithObliqueStroke,
    LatinSmallLetterRWithObliqueStroke,
    LatinCapitalLetterSWithObliqueStroke,
    LatinSmallLetterSWithObliqueStroke,
    LatinCapitalLetterHWithHook,
    LatinCapitalLetterReversedOpenE,
    LatinCapitalLetterScriptG,
    LatinCapitalLetterLWithBelt,
    LatinCapitalLetterSmallCapitalI,
    LatinLetterSmallCapitalQ,
    LatinCapitalLetterTurnedK,
    LatinCapitalLetterTurnedT,
    LatinCapitalLetterJWithCrossedDashTail,
    LatinCapitalLetterChi,
    LatinCapitalLetterBeta,
    LatinSmallLetterBeta,
    LatinCapitalLetterOmega,
    LatinSmallLetterOmega,
    LatinCapitalLetterUWithStroke,
    LatinSmallLetterUWithStroke,
    LatinCapitalLetterGlottalA,
    LatinSmallLetterGlottalA,
    LatinCapitalLetterGlottalI,
    LatinSmallLetterGlottalI,
    LatinCapitalLetterGlottalU,
    LatinSmallLetterGlottalU,
    LatinCapitalLetterAnglicanaW,
    LatinSmallLetterAnglicanaW,
    LatinCapitalLetterCWithPalatalHook,
    LatinCapitalLetterSWithHook,
    LatinCapitalLetterZWithPalatalHook,
    LatinEpigraphicLetterSidewaysI,
    ModifierLetterCapitalHWithStroke,
    ModifierLetterSmallLigatureOe,
    LatinLetterSmallCapitalTurnedM,
    LatinEpigraphicLetterReversedF,
    LatinEpigraphicLetterReversedP,
    LatinEpigraphicLetterInvertedM,
    LatinEpigraphicLetterILonga,
}

An enum to represent all characters in the LatinExtendedD block.

Variants

ModifierLetterStressAndHighTone

\u{a720}: '꜠'

ModifierLetterStressAndLowTone

\u{a721}: '꜡'

LatinCapitalLetterEgyptologicalAlef

\u{a722}: 'Ꜣ'

LatinSmallLetterEgyptologicalAlef

\u{a723}: 'ꜣ'

LatinCapitalLetterEgyptologicalAin

\u{a724}: 'Ꜥ'

LatinSmallLetterEgyptologicalAin

\u{a725}: 'ꜥ'

LatinCapitalLetterHeng

\u{a726}: 'Ꜧ'

LatinSmallLetterHeng

\u{a727}: 'ꜧ'

LatinCapitalLetterTz

\u{a728}: 'Ꜩ'

LatinSmallLetterTz

\u{a729}: 'ꜩ'

LatinCapitalLetterTresillo

\u{a72a}: 'Ꜫ'

LatinSmallLetterTresillo

\u{a72b}: 'ꜫ'

LatinCapitalLetterCuatrillo

\u{a72c}: 'Ꜭ'

LatinSmallLetterCuatrillo

\u{a72d}: 'ꜭ'

LatinCapitalLetterCuatrilloWithComma

\u{a72e}: 'Ꜯ'

LatinSmallLetterCuatrilloWithComma

\u{a72f}: 'ꜯ'

LatinLetterSmallCapitalF

\u{a730}: 'ꜰ'

LatinLetterSmallCapitalS

\u{a731}: 'ꜱ'

LatinCapitalLetterAa

\u{a732}: 'Ꜳ'

LatinSmallLetterAa

\u{a733}: 'ꜳ'

LatinCapitalLetterAo

\u{a734}: 'Ꜵ'

LatinSmallLetterAo

\u{a735}: 'ꜵ'

LatinCapitalLetterAu

\u{a736}: 'Ꜷ'

LatinSmallLetterAu

\u{a737}: 'ꜷ'

LatinCapitalLetterAv

\u{a738}: 'Ꜹ'

LatinSmallLetterAv

\u{a739}: 'ꜹ'

LatinCapitalLetterAvWithHorizontalBar

\u{a73a}: 'Ꜻ'

LatinSmallLetterAvWithHorizontalBar

\u{a73b}: 'ꜻ'

LatinCapitalLetterAy

\u{a73c}: 'Ꜽ'

LatinSmallLetterAy

\u{a73d}: 'ꜽ'

LatinCapitalLetterReversedCWithDot

\u{a73e}: 'Ꜿ'

LatinSmallLetterReversedCWithDot

\u{a73f}: 'ꜿ'

LatinCapitalLetterKWithStroke

\u{a740}: 'Ꝁ'

LatinSmallLetterKWithStroke

\u{a741}: 'ꝁ'

LatinCapitalLetterKWithDiagonalStroke

\u{a742}: 'Ꝃ'

LatinSmallLetterKWithDiagonalStroke

\u{a743}: 'ꝃ'

LatinCapitalLetterKWithStrokeAndDiagonalStroke

\u{a744}: 'Ꝅ'

LatinSmallLetterKWithStrokeAndDiagonalStroke

\u{a745}: 'ꝅ'

LatinCapitalLetterBrokenL

\u{a746}: 'Ꝇ'

LatinSmallLetterBrokenL

\u{a747}: 'ꝇ'

LatinCapitalLetterLWithHighStroke

\u{a748}: 'Ꝉ'

LatinSmallLetterLWithHighStroke

\u{a749}: 'ꝉ'

LatinCapitalLetterOWithLongStrokeOverlay

\u{a74a}: 'Ꝋ'

LatinSmallLetterOWithLongStrokeOverlay

\u{a74b}: 'ꝋ'

LatinCapitalLetterOWithLoop

\u{a74c}: 'Ꝍ'

LatinSmallLetterOWithLoop

\u{a74d}: 'ꝍ'

LatinCapitalLetterOo

\u{a74e}: 'Ꝏ'

LatinSmallLetterOo

\u{a74f}: 'ꝏ'

LatinCapitalLetterPWithStrokeThroughDescender

\u{a750}: 'Ꝑ'

LatinSmallLetterPWithStrokeThroughDescender

\u{a751}: 'ꝑ'

LatinCapitalLetterPWithFlourish

\u{a752}: 'Ꝓ'

LatinSmallLetterPWithFlourish

\u{a753}: 'ꝓ'

LatinCapitalLetterPWithSquirrelTail

\u{a754}: 'Ꝕ'

LatinSmallLetterPWithSquirrelTail

\u{a755}: 'ꝕ'

LatinCapitalLetterQWithStrokeThroughDescender

\u{a756}: 'Ꝗ'

LatinSmallLetterQWithStrokeThroughDescender

\u{a757}: 'ꝗ'

LatinCapitalLetterQWithDiagonalStroke

\u{a758}: 'Ꝙ'

LatinSmallLetterQWithDiagonalStroke

\u{a759}: 'ꝙ'

LatinCapitalLetterRRotunda

\u{a75a}: 'Ꝛ'

LatinSmallLetterRRotunda

\u{a75b}: 'ꝛ'

LatinCapitalLetterRumRotunda

\u{a75c}: 'Ꝝ'

LatinSmallLetterRumRotunda

\u{a75d}: 'ꝝ'

LatinCapitalLetterVWithDiagonalStroke

\u{a75e}: 'Ꝟ'

LatinSmallLetterVWithDiagonalStroke

\u{a75f}: 'ꝟ'

LatinCapitalLetterVy

\u{a760}: 'Ꝡ'

LatinSmallLetterVy

\u{a761}: 'ꝡ'

LatinCapitalLetterVisigothicZ

\u{a762}: 'Ꝣ'

LatinSmallLetterVisigothicZ

\u{a763}: 'ꝣ'

LatinCapitalLetterThornWithStroke

\u{a764}: 'Ꝥ'

LatinSmallLetterThornWithStroke

\u{a765}: 'ꝥ'

LatinCapitalLetterThornWithStrokeThroughDescender

\u{a766}: 'Ꝧ'

LatinSmallLetterThornWithStrokeThroughDescender

\u{a767}: 'ꝧ'

LatinCapitalLetterVend

\u{a768}: 'Ꝩ'

LatinSmallLetterVend

\u{a769}: 'ꝩ'

LatinCapitalLetterEt

\u{a76a}: 'Ꝫ'

LatinSmallLetterEt

\u{a76b}: 'ꝫ'

LatinCapitalLetterIs

\u{a76c}: 'Ꝭ'

LatinSmallLetterIs

\u{a76d}: 'ꝭ'

LatinCapitalLetterCon

\u{a76e}: 'Ꝯ'

LatinSmallLetterCon

\u{a76f}: 'ꝯ'

ModifierLetterUs

\u{a770}: 'ꝰ'

LatinSmallLetterDum

\u{a771}: 'ꝱ'

LatinSmallLetterLum

\u{a772}: 'ꝲ'

LatinSmallLetterMum

\u{a773}: 'ꝳ'

LatinSmallLetterNum

\u{a774}: 'ꝴ'

LatinSmallLetterRum

\u{a775}: 'ꝵ'

LatinLetterSmallCapitalRum

\u{a776}: 'ꝶ'

LatinSmallLetterTum

\u{a777}: 'ꝷ'

LatinSmallLetterUm

\u{a778}: 'ꝸ'

LatinCapitalLetterInsularD

\u{a779}: 'Ꝺ'

LatinSmallLetterInsularD

\u{a77a}: 'ꝺ'

LatinCapitalLetterInsularF

\u{a77b}: 'Ꝼ'

LatinSmallLetterInsularF

\u{a77c}: 'ꝼ'

LatinCapitalLetterInsularG

\u{a77d}: 'Ᵹ'

LatinCapitalLetterTurnedInsularG

\u{a77e}: 'Ꝿ'

LatinSmallLetterTurnedInsularG

\u{a77f}: 'ꝿ'

LatinCapitalLetterTurnedL

\u{a780}: 'Ꞁ'

LatinSmallLetterTurnedL

\u{a781}: 'ꞁ'

LatinCapitalLetterInsularR

\u{a782}: 'Ꞃ'

LatinSmallLetterInsularR

\u{a783}: 'ꞃ'

LatinCapitalLetterInsularS

\u{a784}: 'Ꞅ'

LatinSmallLetterInsularS

\u{a785}: 'ꞅ'

LatinCapitalLetterInsularT

\u{a786}: 'Ꞇ'

LatinSmallLetterInsularT

\u{a787}: 'ꞇ'

ModifierLetterLowCircumflexAccent

\u{a788}: 'ꞈ'

ModifierLetterColon

\u{a789}: '꞉'

ModifierLetterShortEqualsSign

\u{a78a}: '꞊'

LatinCapitalLetterSaltillo

\u{a78b}: 'Ꞌ'

LatinSmallLetterSaltillo

\u{a78c}: 'ꞌ'

LatinCapitalLetterTurnedH

\u{a78d}: 'Ɥ'

LatinSmallLetterLWithRetroflexHookAndBelt

\u{a78e}: 'ꞎ'

LatinLetterSinologicalDot

\u{a78f}: 'ꞏ'

LatinCapitalLetterNWithDescender

\u{a790}: 'Ꞑ'

LatinSmallLetterNWithDescender

\u{a791}: 'ꞑ'

LatinCapitalLetterCWithBar

\u{a792}: 'Ꞓ'

LatinSmallLetterCWithBar

\u{a793}: 'ꞓ'

LatinSmallLetterCWithPalatalHook

\u{a794}: 'ꞔ'

LatinSmallLetterHWithPalatalHook

\u{a795}: 'ꞕ'

LatinCapitalLetterBWithFlourish

\u{a796}: 'Ꞗ'

LatinSmallLetterBWithFlourish

\u{a797}: 'ꞗ'

LatinCapitalLetterFWithStroke

\u{a798}: 'Ꞙ'

LatinSmallLetterFWithStroke

\u{a799}: 'ꞙ'

LatinCapitalLetterVolapukAe

\u{a79a}: 'Ꞛ'

LatinSmallLetterVolapukAe

\u{a79b}: 'ꞛ'

LatinCapitalLetterVolapukOe

\u{a79c}: 'Ꞝ'

LatinSmallLetterVolapukOe

\u{a79d}: 'ꞝ'

LatinCapitalLetterVolapukUe

\u{a79e}: 'Ꞟ'

LatinSmallLetterVolapukUe

\u{a79f}: 'ꞟ'

LatinCapitalLetterGWithObliqueStroke

\u{a7a0}: 'Ꞡ'

LatinSmallLetterGWithObliqueStroke

\u{a7a1}: 'ꞡ'

LatinCapitalLetterKWithObliqueStroke

\u{a7a2}: 'Ꞣ'

LatinSmallLetterKWithObliqueStroke

\u{a7a3}: 'ꞣ'

LatinCapitalLetterNWithObliqueStroke

\u{a7a4}: 'Ꞥ'

LatinSmallLetterNWithObliqueStroke

\u{a7a5}: 'ꞥ'

LatinCapitalLetterRWithObliqueStroke

\u{a7a6}: 'Ꞧ'

LatinSmallLetterRWithObliqueStroke

\u{a7a7}: 'ꞧ'

LatinCapitalLetterSWithObliqueStroke

\u{a7a8}: 'Ꞩ'

LatinSmallLetterSWithObliqueStroke

\u{a7a9}: 'ꞩ'

LatinCapitalLetterHWithHook

\u{a7aa}: 'Ɦ'

LatinCapitalLetterReversedOpenE

\u{a7ab}: 'Ɜ'

LatinCapitalLetterScriptG

\u{a7ac}: 'Ɡ'

LatinCapitalLetterLWithBelt

\u{a7ad}: 'Ɬ'

LatinCapitalLetterSmallCapitalI

\u{a7ae}: 'Ɪ'

LatinLetterSmallCapitalQ

\u{a7af}: 'ꞯ'

LatinCapitalLetterTurnedK

\u{a7b0}: 'Ʞ'

LatinCapitalLetterTurnedT

\u{a7b1}: 'Ʇ'

LatinCapitalLetterJWithCrossedDashTail

\u{a7b2}: 'Ʝ'

LatinCapitalLetterChi

\u{a7b3}: 'Ꭓ'

LatinCapitalLetterBeta

\u{a7b4}: 'Ꞵ'

LatinSmallLetterBeta

\u{a7b5}: 'ꞵ'

LatinCapitalLetterOmega

\u{a7b6}: 'Ꞷ'

LatinSmallLetterOmega

\u{a7b7}: 'ꞷ'

LatinCapitalLetterUWithStroke

\u{a7b8}: 'Ꞹ'

LatinSmallLetterUWithStroke

\u{a7b9}: 'ꞹ'

LatinCapitalLetterGlottalA

\u{a7ba}: 'Ꞻ'

LatinSmallLetterGlottalA

\u{a7bb}: 'ꞻ'

LatinCapitalLetterGlottalI

\u{a7bc}: 'Ꞽ'

LatinSmallLetterGlottalI

\u{a7bd}: 'ꞽ'

LatinCapitalLetterGlottalU

\u{a7be}: 'Ꞿ'

LatinSmallLetterGlottalU

\u{a7bf}: 'ꞿ'

LatinCapitalLetterAnglicanaW

\u{a7c2}: 'Ꟃ'

LatinSmallLetterAnglicanaW

\u{a7c3}: 'ꟃ'

LatinCapitalLetterCWithPalatalHook

\u{a7c4}: 'Ꞔ'

LatinCapitalLetterSWithHook

\u{a7c5}: 'Ʂ'

LatinCapitalLetterZWithPalatalHook

\u{a7c6}: 'Ᶎ'

LatinEpigraphicLetterSidewaysI

\u{a7f7}: 'ꟷ'

ModifierLetterCapitalHWithStroke

\u{a7f8}: 'ꟸ'

ModifierLetterSmallLigatureOe

\u{a7f9}: 'ꟹ'

LatinLetterSmallCapitalTurnedM

\u{a7fa}: 'ꟺ'

LatinEpigraphicLetterReversedF

\u{a7fb}: 'ꟻ'

LatinEpigraphicLetterReversedP

\u{a7fc}: 'ꟼ'

LatinEpigraphicLetterInvertedM

\u{a7fd}: 'ꟽ'

LatinEpigraphicLetterILonga

\u{a7fe}: 'ꟾ'

Methods

impl LatinExtendedD

pub fn new() -> Self

The character with the lowest index in this unicode block

pub fn name(&self) -> String

The character's name, in sentence case

Trait Implementations

impl Iterator for LatinExtendedD

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

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

Important traits for LatinExtendedD

impl Iterator for LatinExtendedD type Item = Self;

fn clone(&self) -> LatinExtendedD

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Into<char> for LatinExtendedD

fn into(self) -> char

Performs the conversion.

impl Into<u32> for LatinExtendedD

fn into(self) -> u32

Performs the conversion.

impl Eq for LatinExtendedD

impl Copy for LatinExtendedD

impl Hash for LatinExtendedD

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 LatinExtendedD

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

Formats the value using the given formatter.

impl TryFrom<char> for LatinExtendedD

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 LatinExtendedD

type Error = ()

The type returned in the event of a conversion error.

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

Performs the conversion.