Enum unicode_types::cyrillic::Cyrillic

pub enum Cyrillic {
    CapitalLetterIeWithGrave,
    CapitalLetterIo,
    CapitalLetterDje,
    CapitalLetterGje,
    CapitalLetterUkrainianIe,
    CapitalLetterDze,
    CapitalLetterByelorussianDashUkrainianI,
    CapitalLetterYi,
    CapitalLetterJe,
    CapitalLetterLje,
    CapitalLetterNje,
    CapitalLetterTshe,
    CapitalLetterKje,
    CapitalLetterIWithGrave,
    CapitalLetterShortU,
    CapitalLetterDzhe,
    CapitalLetterA,
    CapitalLetterBe,
    CapitalLetterVe,
    CapitalLetterGhe,
    CapitalLetterDe,
    CapitalLetterIe,
    CapitalLetterZhe,
    CapitalLetterZe,
    CapitalLetterI,
    CapitalLetterShortI,
    CapitalLetterKa,
    CapitalLetterEl,
    CapitalLetterEm,
    CapitalLetterEn,
    CapitalLetterO,
    CapitalLetterPe,
    CapitalLetterEr,
    CapitalLetterEs,
    CapitalLetterTe,
    CapitalLetterU,
    CapitalLetterEf,
    CapitalLetterHa,
    CapitalLetterTse,
    CapitalLetterChe,
    CapitalLetterSha,
    CapitalLetterShcha,
    CapitalLetterHardSign,
    CapitalLetterYeru,
    CapitalLetterSoftSign,
    CapitalLetterE,
    CapitalLetterYu,
    CapitalLetterYa,
    SmallLetterA,
    SmallLetterBe,
    SmallLetterVe,
    SmallLetterGhe,
    SmallLetterDe,
    SmallLetterIe,
    SmallLetterZhe,
    SmallLetterZe,
    SmallLetterI,
    SmallLetterShortI,
    SmallLetterKa,
    SmallLetterEl,
    SmallLetterEm,
    SmallLetterEn,
    SmallLetterO,
    SmallLetterPe,
    SmallLetterEr,
    SmallLetterEs,
    SmallLetterTe,
    SmallLetterU,
    SmallLetterEf,
    SmallLetterHa,
    SmallLetterTse,
    SmallLetterChe,
    SmallLetterSha,
    SmallLetterShcha,
    SmallLetterHardSign,
    SmallLetterYeru,
    SmallLetterSoftSign,
    SmallLetterE,
    SmallLetterYu,
    SmallLetterYa,
    SmallLetterIeWithGrave,
    SmallLetterIo,
    SmallLetterDje,
    SmallLetterGje,
    SmallLetterUkrainianIe,
    SmallLetterDze,
    SmallLetterByelorussianDashUkrainianI,
    SmallLetterYi,
    SmallLetterJe,
    SmallLetterLje,
    SmallLetterNje,
    SmallLetterTshe,
    SmallLetterKje,
    SmallLetterIWithGrave,
    SmallLetterShortU,
    SmallLetterDzhe,
    CapitalLetterOmega,
    SmallLetterOmega,
    CapitalLetterYat,
    SmallLetterYat,
    CapitalLetterIotifiedE,
    SmallLetterIotifiedE,
    CapitalLetterLittleYus,
    SmallLetterLittleYus,
    CapitalLetterIotifiedLittleYus,
    SmallLetterIotifiedLittleYus,
    CapitalLetterBigYus,
    SmallLetterBigYus,
    CapitalLetterIotifiedBigYus,
    SmallLetterIotifiedBigYus,
    CapitalLetterKsi,
    SmallLetterKsi,
    CapitalLetterPsi,
    SmallLetterPsi,
    CapitalLetterFita,
    SmallLetterFita,
    CapitalLetterIzhitsa,
    SmallLetterIzhitsa,
    CapitalLetterIzhitsaWithDoubleGraveAccent,
    SmallLetterIzhitsaWithDoubleGraveAccent,
    CapitalLetterUk,
    SmallLetterUk,
    CapitalLetterRoundOmega,
    SmallLetterRoundOmega,
    CapitalLetterOmegaWithTitlo,
    SmallLetterOmegaWithTitlo,
    CapitalLetterOt,
    SmallLetterOt,
    CapitalLetterKoppa,
    SmallLetterKoppa,
    ThousandsSign,
    CombiningTitlo,
    CombiningPalatalization,
    CombiningDasiaPneumata,
    CombiningPsiliPneumata,
    CombiningPokrytie,
    CombiningHundredThousandsSign,
    CombiningMillionsSign,
    CapitalLetterShortIWithTail,
    SmallLetterShortIWithTail,
    CapitalLetterSemisoftSign,
    SmallLetterSemisoftSign,
    CapitalLetterErWithTick,
    SmallLetterErWithTick,
    CapitalLetterGheWithUpturn,
    SmallLetterGheWithUpturn,
    CapitalLetterGheWithStroke,
    SmallLetterGheWithStroke,
    CapitalLetterGheWithMiddleHook,
    SmallLetterGheWithMiddleHook,
    CapitalLetterZheWithDescender,
    SmallLetterZheWithDescender,
    CapitalLetterZeWithDescender,
    SmallLetterZeWithDescender,
    CapitalLetterKaWithDescender,
    SmallLetterKaWithDescender,
    CapitalLetterKaWithVerticalStroke,
    SmallLetterKaWithVerticalStroke,
    CapitalLetterKaWithStroke,
    SmallLetterKaWithStroke,
    CapitalLetterBashkirKa,
    SmallLetterBashkirKa,
    CapitalLetterEnWithDescender,
    SmallLetterEnWithDescender,
    CapitalLigatureEnGhe,
    SmallLigatureEnGhe,
    CapitalLetterPeWithMiddleHook,
    SmallLetterPeWithMiddleHook,
    CapitalLetterAbkhasianHa,
    SmallLetterAbkhasianHa,
    CapitalLetterEsWithDescender,
    SmallLetterEsWithDescender,
    CapitalLetterTeWithDescender,
    SmallLetterTeWithDescender,
    CapitalLetterStraightU,
    SmallLetterStraightU,
    CapitalLetterStraightUWithStroke,
    SmallLetterStraightUWithStroke,
    CapitalLetterHaWithDescender,
    SmallLetterHaWithDescender,
    CapitalLigatureTeTse,
    SmallLigatureTeTse,
    CapitalLetterCheWithDescender,
    SmallLetterCheWithDescender,
    CapitalLetterCheWithVerticalStroke,
    SmallLetterCheWithVerticalStroke,
    CapitalLetterShha,
    SmallLetterShha,
    CapitalLetterAbkhasianChe,
    SmallLetterAbkhasianChe,
    CapitalLetterAbkhasianCheWithDescender,
    SmallLetterAbkhasianCheWithDescender,
    LetterPalochka,
    CapitalLetterZheWithBreve,
    SmallLetterZheWithBreve,
    CapitalLetterKaWithHook,
    SmallLetterKaWithHook,
    CapitalLetterElWithTail,
    SmallLetterElWithTail,
    CapitalLetterEnWithHook,
    SmallLetterEnWithHook,
    CapitalLetterEnWithTail,
    SmallLetterEnWithTail,
    CapitalLetterKhakassianChe,
    SmallLetterKhakassianChe,
    CapitalLetterEmWithTail,
    SmallLetterEmWithTail,
    SmallLetterPalochka,
    CapitalLetterAWithBreve,
    SmallLetterAWithBreve,
    CapitalLetterAWithDiaeresis,
    SmallLetterAWithDiaeresis,
    CapitalLigatureAIe,
    SmallLigatureAIe,
    CapitalLetterIeWithBreve,
    SmallLetterIeWithBreve,
    CapitalLetterSchwa,
    SmallLetterSchwa,
    CapitalLetterSchwaWithDiaeresis,
    SmallLetterSchwaWithDiaeresis,
    CapitalLetterZheWithDiaeresis,
    SmallLetterZheWithDiaeresis,
    CapitalLetterZeWithDiaeresis,
    SmallLetterZeWithDiaeresis,
    CapitalLetterAbkhasianDze,
    SmallLetterAbkhasianDze,
    CapitalLetterIWithMacron,
    SmallLetterIWithMacron,
    CapitalLetterIWithDiaeresis,
    SmallLetterIWithDiaeresis,
    CapitalLetterOWithDiaeresis,
    SmallLetterOWithDiaeresis,
    CapitalLetterBarredO,
    SmallLetterBarredO,
    CapitalLetterBarredOWithDiaeresis,
    SmallLetterBarredOWithDiaeresis,
    CapitalLetterEWithDiaeresis,
    SmallLetterEWithDiaeresis,
    CapitalLetterUWithMacron,
    SmallLetterUWithMacron,
    CapitalLetterUWithDiaeresis,
    SmallLetterUWithDiaeresis,
    CapitalLetterUWithDoubleAcute,
    SmallLetterUWithDoubleAcute,
    CapitalLetterCheWithDiaeresis,
    SmallLetterCheWithDiaeresis,
    CapitalLetterGheWithDescender,
    SmallLetterGheWithDescender,
    CapitalLetterYeruWithDiaeresis,
    SmallLetterYeruWithDiaeresis,
    CapitalLetterGheWithStrokeAndHook,
    SmallLetterGheWithStrokeAndHook,
    CapitalLetterHaWithHook,
    SmallLetterHaWithHook,
    CapitalLetterHaWithStroke,
}

An enum to represent all characters in the Cyrillic block.

Variants

CapitalLetterIeWithGrave

\u{400}: 'Ѐ'

CapitalLetterIo

\u{401}: 'Ё'

CapitalLetterDje

\u{402}: 'Ђ'

CapitalLetterGje

\u{403}: 'Ѓ'

CapitalLetterUkrainianIe

\u{404}: 'Є'

CapitalLetterDze

\u{405}: 'Ѕ'

CapitalLetterByelorussianDashUkrainianI

\u{406}: 'І'

CapitalLetterYi

\u{407}: 'Ї'

CapitalLetterJe

\u{408}: 'Ј'

CapitalLetterLje

\u{409}: 'Љ'

CapitalLetterNje

\u{40a}: 'Њ'

CapitalLetterTshe

\u{40b}: 'Ћ'

CapitalLetterKje

\u{40c}: 'Ќ'

CapitalLetterIWithGrave

\u{40d}: 'Ѝ'

CapitalLetterShortU

\u{40e}: 'Ў'

CapitalLetterDzhe

\u{40f}: 'Џ'

CapitalLetterA

\u{410}: 'А'

CapitalLetterBe

\u{411}: 'Б'

CapitalLetterVe

\u{412}: 'В'

CapitalLetterGhe

\u{413}: 'Г'

CapitalLetterDe

\u{414}: 'Д'

CapitalLetterIe

\u{415}: 'Е'

CapitalLetterZhe

\u{416}: 'Ж'

CapitalLetterZe

\u{417}: 'З'

CapitalLetterI

\u{418}: 'И'

CapitalLetterShortI

\u{419}: 'Й'

CapitalLetterKa

\u{41a}: 'К'

CapitalLetterEl

\u{41b}: 'Л'

CapitalLetterEm

\u{41c}: 'М'

CapitalLetterEn

\u{41d}: 'Н'

CapitalLetterO

\u{41e}: 'О'

CapitalLetterPe

\u{41f}: 'П'

CapitalLetterEr

\u{420}: 'Р'

CapitalLetterEs

\u{421}: 'С'

CapitalLetterTe

\u{422}: 'Т'

CapitalLetterU

\u{423}: 'У'

CapitalLetterEf

\u{424}: 'Ф'

CapitalLetterHa

\u{425}: 'Х'

CapitalLetterTse

\u{426}: 'Ц'

CapitalLetterChe

\u{427}: 'Ч'

CapitalLetterSha

\u{428}: 'Ш'

CapitalLetterShcha

\u{429}: 'Щ'

CapitalLetterHardSign

\u{42a}: 'Ъ'

CapitalLetterYeru

\u{42b}: 'Ы'

CapitalLetterSoftSign

\u{42c}: 'Ь'

CapitalLetterE

\u{42d}: 'Э'

CapitalLetterYu

\u{42e}: 'Ю'

CapitalLetterYa

\u{42f}: 'Я'

SmallLetterA

\u{430}: 'а'

SmallLetterBe

\u{431}: 'б'

SmallLetterVe

\u{432}: 'в'

SmallLetterGhe

\u{433}: 'г'

SmallLetterDe

\u{434}: 'д'

SmallLetterIe

\u{435}: 'е'

SmallLetterZhe

\u{436}: 'ж'

SmallLetterZe

\u{437}: 'з'

SmallLetterI

\u{438}: 'и'

SmallLetterShortI

\u{439}: 'й'

SmallLetterKa

\u{43a}: 'к'

SmallLetterEl

\u{43b}: 'л'

SmallLetterEm

\u{43c}: 'м'

SmallLetterEn

\u{43d}: 'н'

SmallLetterO

\u{43e}: 'о'

SmallLetterPe

\u{43f}: 'п'

SmallLetterEr

\u{440}: 'р'

SmallLetterEs

\u{441}: 'с'

SmallLetterTe

\u{442}: 'т'

SmallLetterU

\u{443}: 'у'

SmallLetterEf

\u{444}: 'ф'

SmallLetterHa

\u{445}: 'х'

SmallLetterTse

\u{446}: 'ц'

SmallLetterChe

\u{447}: 'ч'

SmallLetterSha

\u{448}: 'ш'

SmallLetterShcha

\u{449}: 'щ'

SmallLetterHardSign

\u{44a}: 'ъ'

SmallLetterYeru

\u{44b}: 'ы'

SmallLetterSoftSign

\u{44c}: 'ь'

SmallLetterE

\u{44d}: 'э'

SmallLetterYu

\u{44e}: 'ю'

SmallLetterYa

\u{44f}: 'я'

SmallLetterIeWithGrave

\u{450}: 'ѐ'

SmallLetterIo

\u{451}: 'ё'

SmallLetterDje

\u{452}: 'ђ'

SmallLetterGje

\u{453}: 'ѓ'

SmallLetterUkrainianIe

\u{454}: 'є'

SmallLetterDze

\u{455}: 'ѕ'

SmallLetterByelorussianDashUkrainianI

\u{456}: 'і'

SmallLetterYi

\u{457}: 'ї'

SmallLetterJe

\u{458}: 'ј'

SmallLetterLje

\u{459}: 'љ'

SmallLetterNje

\u{45a}: 'њ'

SmallLetterTshe

\u{45b}: 'ћ'

SmallLetterKje

\u{45c}: 'ќ'

SmallLetterIWithGrave

\u{45d}: 'ѝ'

SmallLetterShortU

\u{45e}: 'ў'

SmallLetterDzhe

\u{45f}: 'џ'

CapitalLetterOmega

\u{460}: 'Ѡ'

SmallLetterOmega

\u{461}: 'ѡ'

CapitalLetterYat

\u{462}: 'Ѣ'

SmallLetterYat

\u{463}: 'ѣ'

CapitalLetterIotifiedE

\u{464}: 'Ѥ'

SmallLetterIotifiedE

\u{465}: 'ѥ'

CapitalLetterLittleYus

\u{466}: 'Ѧ'

SmallLetterLittleYus

\u{467}: 'ѧ'

CapitalLetterIotifiedLittleYus

\u{468}: 'Ѩ'

SmallLetterIotifiedLittleYus

\u{469}: 'ѩ'

CapitalLetterBigYus

\u{46a}: 'Ѫ'

SmallLetterBigYus

\u{46b}: 'ѫ'

CapitalLetterIotifiedBigYus

\u{46c}: 'Ѭ'

SmallLetterIotifiedBigYus

\u{46d}: 'ѭ'

CapitalLetterKsi

\u{46e}: 'Ѯ'

SmallLetterKsi

\u{46f}: 'ѯ'

CapitalLetterPsi

\u{470}: 'Ѱ'

SmallLetterPsi

\u{471}: 'ѱ'

CapitalLetterFita

\u{472}: 'Ѳ'

SmallLetterFita

\u{473}: 'ѳ'

CapitalLetterIzhitsa

\u{474}: 'Ѵ'

SmallLetterIzhitsa

\u{475}: 'ѵ'

CapitalLetterIzhitsaWithDoubleGraveAccent

\u{476}: 'Ѷ'

SmallLetterIzhitsaWithDoubleGraveAccent

\u{477}: 'ѷ'

CapitalLetterUk

\u{478}: 'Ѹ'

SmallLetterUk

\u{479}: 'ѹ'

CapitalLetterRoundOmega

\u{47a}: 'Ѻ'

SmallLetterRoundOmega

\u{47b}: 'ѻ'

CapitalLetterOmegaWithTitlo

\u{47c}: 'Ѽ'

SmallLetterOmegaWithTitlo

\u{47d}: 'ѽ'

CapitalLetterOt

\u{47e}: 'Ѿ'

SmallLetterOt

\u{47f}: 'ѿ'

CapitalLetterKoppa

\u{480}: 'Ҁ'

SmallLetterKoppa

\u{481}: 'ҁ'

ThousandsSign

\u{482}: '҂'

CombiningTitlo

\u{483}: '҃'

CombiningPalatalization

\u{484}: '҄'

CombiningDasiaPneumata

\u{485}: '҅'

CombiningPsiliPneumata

\u{486}: '҆'

CombiningPokrytie

\u{487}: '҇'

CombiningHundredThousandsSign

\u{488}: '҈'

CombiningMillionsSign

\u{489}: '҉'

CapitalLetterShortIWithTail

\u{48a}: 'Ҋ'

SmallLetterShortIWithTail

\u{48b}: 'ҋ'

CapitalLetterSemisoftSign

\u{48c}: 'Ҍ'

SmallLetterSemisoftSign

\u{48d}: 'ҍ'

CapitalLetterErWithTick

\u{48e}: 'Ҏ'

SmallLetterErWithTick

\u{48f}: 'ҏ'

CapitalLetterGheWithUpturn

\u{490}: 'Ґ'

SmallLetterGheWithUpturn

\u{491}: 'ґ'

CapitalLetterGheWithStroke

\u{492}: 'Ғ'

SmallLetterGheWithStroke

\u{493}: 'ғ'

CapitalLetterGheWithMiddleHook

\u{494}: 'Ҕ'

SmallLetterGheWithMiddleHook

\u{495}: 'ҕ'

CapitalLetterZheWithDescender

\u{496}: 'Җ'

SmallLetterZheWithDescender

\u{497}: 'җ'

CapitalLetterZeWithDescender

\u{498}: 'Ҙ'

SmallLetterZeWithDescender

\u{499}: 'ҙ'

CapitalLetterKaWithDescender

\u{49a}: 'Қ'

SmallLetterKaWithDescender

\u{49b}: 'қ'

CapitalLetterKaWithVerticalStroke

\u{49c}: 'Ҝ'

SmallLetterKaWithVerticalStroke

\u{49d}: 'ҝ'

CapitalLetterKaWithStroke

\u{49e}: 'Ҟ'

SmallLetterKaWithStroke

\u{49f}: 'ҟ'

CapitalLetterBashkirKa

\u{4a0}: 'Ҡ'

SmallLetterBashkirKa

\u{4a1}: 'ҡ'

CapitalLetterEnWithDescender

\u{4a2}: 'Ң'

SmallLetterEnWithDescender

\u{4a3}: 'ң'

CapitalLigatureEnGhe

\u{4a4}: 'Ҥ'

SmallLigatureEnGhe

\u{4a5}: 'ҥ'

CapitalLetterPeWithMiddleHook

\u{4a6}: 'Ҧ'

SmallLetterPeWithMiddleHook

\u{4a7}: 'ҧ'

CapitalLetterAbkhasianHa

\u{4a8}: 'Ҩ'

SmallLetterAbkhasianHa

\u{4a9}: 'ҩ'

CapitalLetterEsWithDescender

\u{4aa}: 'Ҫ'

SmallLetterEsWithDescender

\u{4ab}: 'ҫ'

CapitalLetterTeWithDescender

\u{4ac}: 'Ҭ'

SmallLetterTeWithDescender

\u{4ad}: 'ҭ'

CapitalLetterStraightU

\u{4ae}: 'Ү'

SmallLetterStraightU

\u{4af}: 'ү'

CapitalLetterStraightUWithStroke

\u{4b0}: 'Ұ'

SmallLetterStraightUWithStroke

\u{4b1}: 'ұ'

CapitalLetterHaWithDescender

\u{4b2}: 'Ҳ'

SmallLetterHaWithDescender

\u{4b3}: 'ҳ'

CapitalLigatureTeTse

\u{4b4}: 'Ҵ'

SmallLigatureTeTse

\u{4b5}: 'ҵ'

CapitalLetterCheWithDescender

\u{4b6}: 'Ҷ'

SmallLetterCheWithDescender

\u{4b7}: 'ҷ'

CapitalLetterCheWithVerticalStroke

\u{4b8}: 'Ҹ'

SmallLetterCheWithVerticalStroke

\u{4b9}: 'ҹ'

CapitalLetterShha

\u{4ba}: 'Һ'

SmallLetterShha

\u{4bb}: 'һ'

CapitalLetterAbkhasianChe

\u{4bc}: 'Ҽ'

SmallLetterAbkhasianChe

\u{4bd}: 'ҽ'

CapitalLetterAbkhasianCheWithDescender

\u{4be}: 'Ҿ'

SmallLetterAbkhasianCheWithDescender

\u{4bf}: 'ҿ'

LetterPalochka

\u{4c0}: 'Ӏ'

CapitalLetterZheWithBreve

\u{4c1}: 'Ӂ'

SmallLetterZheWithBreve

\u{4c2}: 'ӂ'

CapitalLetterKaWithHook

\u{4c3}: 'Ӄ'

SmallLetterKaWithHook

\u{4c4}: 'ӄ'

CapitalLetterElWithTail

\u{4c5}: 'Ӆ'

SmallLetterElWithTail

\u{4c6}: 'ӆ'

CapitalLetterEnWithHook

\u{4c7}: 'Ӈ'

SmallLetterEnWithHook

\u{4c8}: 'ӈ'

CapitalLetterEnWithTail

\u{4c9}: 'Ӊ'

SmallLetterEnWithTail

\u{4ca}: 'ӊ'

CapitalLetterKhakassianChe

\u{4cb}: 'Ӌ'

SmallLetterKhakassianChe

\u{4cc}: 'ӌ'

CapitalLetterEmWithTail

\u{4cd}: 'Ӎ'

SmallLetterEmWithTail

\u{4ce}: 'ӎ'

SmallLetterPalochka

\u{4cf}: 'ӏ'

CapitalLetterAWithBreve

\u{4d0}: 'Ӑ'

SmallLetterAWithBreve

\u{4d1}: 'ӑ'

CapitalLetterAWithDiaeresis

\u{4d2}: 'Ӓ'

SmallLetterAWithDiaeresis

\u{4d3}: 'ӓ'

CapitalLigatureAIe

\u{4d4}: 'Ӕ'

SmallLigatureAIe

\u{4d5}: 'ӕ'

CapitalLetterIeWithBreve

\u{4d6}: 'Ӗ'

SmallLetterIeWithBreve

\u{4d7}: 'ӗ'

CapitalLetterSchwa

\u{4d8}: 'Ә'

SmallLetterSchwa

\u{4d9}: 'ә'

CapitalLetterSchwaWithDiaeresis

\u{4da}: 'Ӛ'

SmallLetterSchwaWithDiaeresis

\u{4db}: 'ӛ'

CapitalLetterZheWithDiaeresis

\u{4dc}: 'Ӝ'

SmallLetterZheWithDiaeresis

\u{4dd}: 'ӝ'

CapitalLetterZeWithDiaeresis

\u{4de}: 'Ӟ'

SmallLetterZeWithDiaeresis

\u{4df}: 'ӟ'

CapitalLetterAbkhasianDze

\u{4e0}: 'Ӡ'

SmallLetterAbkhasianDze

\u{4e1}: 'ӡ'

CapitalLetterIWithMacron

\u{4e2}: 'Ӣ'

SmallLetterIWithMacron

\u{4e3}: 'ӣ'

CapitalLetterIWithDiaeresis

\u{4e4}: 'Ӥ'

SmallLetterIWithDiaeresis

\u{4e5}: 'ӥ'

CapitalLetterOWithDiaeresis

\u{4e6}: 'Ӧ'

SmallLetterOWithDiaeresis

\u{4e7}: 'ӧ'

CapitalLetterBarredO

\u{4e8}: 'Ө'

SmallLetterBarredO

\u{4e9}: 'ө'

CapitalLetterBarredOWithDiaeresis

\u{4ea}: 'Ӫ'

SmallLetterBarredOWithDiaeresis

\u{4eb}: 'ӫ'

CapitalLetterEWithDiaeresis

\u{4ec}: 'Ӭ'

SmallLetterEWithDiaeresis

\u{4ed}: 'ӭ'

CapitalLetterUWithMacron

\u{4ee}: 'Ӯ'

SmallLetterUWithMacron

\u{4ef}: 'ӯ'

CapitalLetterUWithDiaeresis

\u{4f0}: 'Ӱ'

SmallLetterUWithDiaeresis

\u{4f1}: 'ӱ'

CapitalLetterUWithDoubleAcute

\u{4f2}: 'Ӳ'

SmallLetterUWithDoubleAcute

\u{4f3}: 'ӳ'

CapitalLetterCheWithDiaeresis

\u{4f4}: 'Ӵ'

SmallLetterCheWithDiaeresis

\u{4f5}: 'ӵ'

CapitalLetterGheWithDescender

\u{4f6}: 'Ӷ'

SmallLetterGheWithDescender

\u{4f7}: 'ӷ'

CapitalLetterYeruWithDiaeresis

\u{4f8}: 'Ӹ'

SmallLetterYeruWithDiaeresis

\u{4f9}: 'ӹ'

CapitalLetterGheWithStrokeAndHook

\u{4fa}: 'Ӻ'

SmallLetterGheWithStrokeAndHook

\u{4fb}: 'ӻ'

CapitalLetterHaWithHook

\u{4fc}: 'Ӽ'

SmallLetterHaWithHook

\u{4fd}: 'ӽ'

CapitalLetterHaWithStroke

\u{4fe}: 'Ӿ'

Methods

impl Cyrillic

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 Cyrillic

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

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

Important traits for Cyrillic

impl Iterator for Cyrillic type Item = Self;

fn clone(&self) -> Cyrillic

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Into<char> for Cyrillic

fn into(self) -> char

Performs the conversion.

impl Into<u32> for Cyrillic

fn into(self) -> u32

Performs the conversion.

impl Eq for Cyrillic

impl Copy for Cyrillic

impl Hash for Cyrillic

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 Cyrillic

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

Formats the value using the given formatter.

impl TryFrom<char> for Cyrillic

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 Cyrillic

type Error = ()

The type returned in the event of a conversion error.

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

Performs the conversion.