Enum unicode_types::latin_extended_b::LatinExtendedB

pub enum LatinExtendedB {
    LatinSmallLetterBWithStroke,
    LatinCapitalLetterBWithHook,
    LatinCapitalLetterBWithTopbar,
    LatinSmallLetterBWithTopbar,
    LatinCapitalLetterToneSix,
    LatinSmallLetterToneSix,
    LatinCapitalLetterOpenO,
    LatinCapitalLetterCWithHook,
    LatinSmallLetterCWithHook,
    LatinCapitalLetterAfricanD,
    LatinCapitalLetterDWithHook,
    LatinCapitalLetterDWithTopbar,
    LatinSmallLetterDWithTopbar,
    LatinSmallLetterTurnedDelta,
    LatinCapitalLetterReversedE,
    LatinCapitalLetterSchwa,
    LatinCapitalLetterOpenE,
    LatinCapitalLetterFWithHook,
    LatinSmallLetterFWithHook,
    LatinCapitalLetterGWithHook,
    LatinCapitalLetterGamma,
    LatinSmallLetterHv,
    LatinCapitalLetterIota,
    LatinCapitalLetterIWithStroke,
    LatinCapitalLetterKWithHook,
    LatinSmallLetterKWithHook,
    LatinSmallLetterLWithBar,
    LatinSmallLetterLambdaWithStroke,
    LatinCapitalLetterTurnedM,
    LatinCapitalLetterNWithLeftHook,
    LatinSmallLetterNWithLongRightLeg,
    LatinCapitalLetterOWithMiddleTilde,
    LatinCapitalLetterOWithHorn,
    LatinSmallLetterOWithHorn,
    LatinCapitalLetterOi,
    LatinSmallLetterOi,
    LatinCapitalLetterPWithHook,
    LatinSmallLetterPWithHook,
    LatinLetterYr,
    LatinCapitalLetterToneTwo,
    LatinSmallLetterToneTwo,
    LatinCapitalLetterEsh,
    LatinLetterReversedEshLoop,
    LatinSmallLetterTWithPalatalHook,
    LatinCapitalLetterTWithHook,
    LatinSmallLetterTWithHook,
    LatinCapitalLetterTWithRetroflexHook,
    LatinCapitalLetterUWithHorn,
    LatinSmallLetterUWithHorn,
    LatinCapitalLetterUpsilon,
    LatinCapitalLetterVWithHook,
    LatinCapitalLetterYWithHook,
    LatinSmallLetterYWithHook,
    LatinCapitalLetterZWithStroke,
    LatinSmallLetterZWithStroke,
    LatinCapitalLetterEzh,
    LatinCapitalLetterEzhReversed,
    LatinSmallLetterEzhReversed,
    LatinSmallLetterEzhWithTail,
    LatinLetterTwoWithStroke,
    LatinCapitalLetterToneFive,
    LatinSmallLetterToneFive,
    LatinLetterInvertedGlottalStopWithStroke,
    LatinLetterWynn,
    LatinLetterDentalClick,
    LatinLetterLateralClick,
    LatinLetterAlveolarClick,
    LatinLetterRetroflexClick,
    LatinCapitalLetterDzWithCaron,
    LatinCapitalLetterDWithSmallLetterZWithCaron,
    LatinSmallLetterDzWithCaron,
    LatinCapitalLetterLj,
    LatinCapitalLetterLWithSmallLetterJ,
    LatinSmallLetterLj,
    LatinCapitalLetterNj,
    LatinCapitalLetterNWithSmallLetterJ,
    LatinSmallLetterNj,
    LatinCapitalLetterAWithCaron,
    LatinSmallLetterAWithCaron,
    LatinCapitalLetterIWithCaron,
    LatinSmallLetterIWithCaron,
    LatinCapitalLetterOWithCaron,
    LatinSmallLetterOWithCaron,
    LatinCapitalLetterUWithCaron,
    LatinSmallLetterUWithCaron,
    LatinCapitalLetterUWithDiaeresisAndMacron,
    LatinSmallLetterUWithDiaeresisAndMacron,
    LatinCapitalLetterUWithDiaeresisAndAcute,
    LatinSmallLetterUWithDiaeresisAndAcute,
    LatinCapitalLetterUWithDiaeresisAndCaron,
    LatinSmallLetterUWithDiaeresisAndCaron,
    LatinCapitalLetterUWithDiaeresisAndGrave,
    LatinSmallLetterUWithDiaeresisAndGrave,
    LatinSmallLetterTurnedE,
    LatinCapitalLetterAWithDiaeresisAndMacron,
    LatinSmallLetterAWithDiaeresisAndMacron,
    LatinCapitalLetterAWithDotAboveAndMacron,
    LatinSmallLetterAWithDotAboveAndMacron,
    LatinCapitalLetterAeWithMacron,
    LatinSmallLetterAeWithMacron,
    LatinCapitalLetterGWithStroke,
    LatinSmallLetterGWithStroke,
    LatinCapitalLetterGWithCaron,
    LatinSmallLetterGWithCaron,
    LatinCapitalLetterKWithCaron,
    LatinSmallLetterKWithCaron,
    LatinCapitalLetterOWithOgonek,
    LatinSmallLetterOWithOgonek,
    LatinCapitalLetterOWithOgonekAndMacron,
    LatinSmallLetterOWithOgonekAndMacron,
    LatinCapitalLetterEzhWithCaron,
    LatinSmallLetterEzhWithCaron,
    LatinSmallLetterJWithCaron,
    LatinCapitalLetterDz,
    LatinCapitalLetterDWithSmallLetterZ,
    LatinSmallLetterDz,
    LatinCapitalLetterGWithAcute,
    LatinSmallLetterGWithAcute,
    LatinCapitalLetterHwair,
    LatinCapitalLetterWynn,
    LatinCapitalLetterNWithGrave,
    LatinSmallLetterNWithGrave,
    LatinCapitalLetterAWithRingAboveAndAcute,
    LatinSmallLetterAWithRingAboveAndAcute,
    LatinCapitalLetterAeWithAcute,
    LatinSmallLetterAeWithAcute,
    LatinCapitalLetterOWithStrokeAndAcute,
    LatinSmallLetterOWithStrokeAndAcute,
    LatinCapitalLetterAWithDoubleGrave,
    LatinSmallLetterAWithDoubleGrave,
    LatinCapitalLetterAWithInvertedBreve,
    LatinSmallLetterAWithInvertedBreve,
    LatinCapitalLetterEWithDoubleGrave,
    LatinSmallLetterEWithDoubleGrave,
    LatinCapitalLetterEWithInvertedBreve,
    LatinSmallLetterEWithInvertedBreve,
    LatinCapitalLetterIWithDoubleGrave,
    LatinSmallLetterIWithDoubleGrave,
    LatinCapitalLetterIWithInvertedBreve,
    LatinSmallLetterIWithInvertedBreve,
    LatinCapitalLetterOWithDoubleGrave,
    LatinSmallLetterOWithDoubleGrave,
    LatinCapitalLetterOWithInvertedBreve,
    LatinSmallLetterOWithInvertedBreve,
    LatinCapitalLetterRWithDoubleGrave,
    LatinSmallLetterRWithDoubleGrave,
    LatinCapitalLetterRWithInvertedBreve,
    LatinSmallLetterRWithInvertedBreve,
    LatinCapitalLetterUWithDoubleGrave,
    LatinSmallLetterUWithDoubleGrave,
    LatinCapitalLetterUWithInvertedBreve,
    LatinSmallLetterUWithInvertedBreve,
    LatinCapitalLetterSWithCommaBelow,
    LatinSmallLetterSWithCommaBelow,
    LatinCapitalLetterTWithCommaBelow,
    LatinSmallLetterTWithCommaBelow,
    LatinCapitalLetterYogh,
    LatinSmallLetterYogh,
    LatinCapitalLetterHWithCaron,
    LatinSmallLetterHWithCaron,
    LatinCapitalLetterNWithLongRightLeg,
    LatinSmallLetterDWithCurl,
    LatinCapitalLetterOu,
    LatinSmallLetterOu,
    LatinCapitalLetterZWithHook,
    LatinSmallLetterZWithHook,
    LatinCapitalLetterAWithDotAbove,
    LatinSmallLetterAWithDotAbove,
    LatinCapitalLetterEWithCedilla,
    LatinSmallLetterEWithCedilla,
    LatinCapitalLetterOWithDiaeresisAndMacron,
    LatinSmallLetterOWithDiaeresisAndMacron,
    LatinCapitalLetterOWithTildeAndMacron,
    LatinSmallLetterOWithTildeAndMacron,
    LatinCapitalLetterOWithDotAbove,
    LatinSmallLetterOWithDotAbove,
    LatinCapitalLetterOWithDotAboveAndMacron,
    LatinSmallLetterOWithDotAboveAndMacron,
    LatinCapitalLetterYWithMacron,
    LatinSmallLetterYWithMacron,
    LatinSmallLetterLWithCurl,
    LatinSmallLetterNWithCurl,
    LatinSmallLetterTWithCurl,
    LatinSmallLetterDotlessJ,
    LatinSmallLetterDbDigraph,
    LatinSmallLetterQpDigraph,
    LatinCapitalLetterAWithStroke,
    LatinCapitalLetterCWithStroke,
    LatinSmallLetterCWithStroke,
    LatinCapitalLetterLWithBar,
    LatinCapitalLetterTWithDiagonalStroke,
    LatinSmallLetterSWithSwashTail,
    LatinSmallLetterZWithSwashTail,
    LatinCapitalLetterGlottalStop,
    LatinSmallLetterGlottalStop,
    LatinCapitalLetterBWithStroke,
    LatinCapitalLetterUBar,
    LatinCapitalLetterTurnedV,
    LatinCapitalLetterEWithStroke,
    LatinSmallLetterEWithStroke,
    LatinCapitalLetterJWithStroke,
    LatinSmallLetterJWithStroke,
    LatinCapitalLetterSmallQWithHookTail,
    LatinSmallLetterQWithHookTail,
    LatinCapitalLetterRWithStroke,
    LatinSmallLetterRWithStroke,
    LatinCapitalLetterYWithStroke,
}

An enum to represent all characters in the LatinExtendedB block.

Variants

LatinSmallLetterBWithStroke

\u{180}: 'ƀ'

LatinCapitalLetterBWithHook

\u{181}: 'Ɓ'

LatinCapitalLetterBWithTopbar

\u{182}: 'Ƃ'

LatinSmallLetterBWithTopbar

\u{183}: 'ƃ'

LatinCapitalLetterToneSix

\u{184}: 'Ƅ'

LatinSmallLetterToneSix

\u{185}: 'ƅ'

LatinCapitalLetterOpenO

\u{186}: 'Ɔ'

LatinCapitalLetterCWithHook

\u{187}: 'Ƈ'

LatinSmallLetterCWithHook

\u{188}: 'ƈ'

LatinCapitalLetterAfricanD

\u{189}: 'Ɖ'

LatinCapitalLetterDWithHook

\u{18a}: 'Ɗ'

LatinCapitalLetterDWithTopbar

\u{18b}: 'Ƌ'

LatinSmallLetterDWithTopbar

\u{18c}: 'ƌ'

LatinSmallLetterTurnedDelta

\u{18d}: 'ƍ'

LatinCapitalLetterReversedE

\u{18e}: 'Ǝ'

LatinCapitalLetterSchwa

\u{18f}: 'Ə'

LatinCapitalLetterOpenE

\u{190}: 'Ɛ'

LatinCapitalLetterFWithHook

\u{191}: 'Ƒ'

LatinSmallLetterFWithHook

\u{192}: 'ƒ'

LatinCapitalLetterGWithHook

\u{193}: 'Ɠ'

LatinCapitalLetterGamma

\u{194}: 'Ɣ'

LatinSmallLetterHv

\u{195}: 'ƕ'

LatinCapitalLetterIota

\u{196}: 'Ɩ'

LatinCapitalLetterIWithStroke

\u{197}: 'Ɨ'

LatinCapitalLetterKWithHook

\u{198}: 'Ƙ'

LatinSmallLetterKWithHook

\u{199}: 'ƙ'

LatinSmallLetterLWithBar

\u{19a}: 'ƚ'

LatinSmallLetterLambdaWithStroke

\u{19b}: 'ƛ'

LatinCapitalLetterTurnedM

\u{19c}: 'Ɯ'

LatinCapitalLetterNWithLeftHook

\u{19d}: 'Ɲ'

LatinSmallLetterNWithLongRightLeg

\u{19e}: 'ƞ'

LatinCapitalLetterOWithMiddleTilde

\u{19f}: 'Ɵ'

LatinCapitalLetterOWithHorn

\u{1a0}: 'Ơ'

LatinSmallLetterOWithHorn

\u{1a1}: 'ơ'

LatinCapitalLetterOi

\u{1a2}: 'Ƣ'

LatinSmallLetterOi

\u{1a3}: 'ƣ'

LatinCapitalLetterPWithHook

\u{1a4}: 'Ƥ'

LatinSmallLetterPWithHook

\u{1a5}: 'ƥ'

LatinLetterYr

\u{1a6}: 'Ʀ'

LatinCapitalLetterToneTwo

\u{1a7}: 'Ƨ'

LatinSmallLetterToneTwo

\u{1a8}: 'ƨ'

LatinCapitalLetterEsh

\u{1a9}: 'Ʃ'

LatinLetterReversedEshLoop

\u{1aa}: 'ƪ'

LatinSmallLetterTWithPalatalHook

\u{1ab}: 'ƫ'

LatinCapitalLetterTWithHook

\u{1ac}: 'Ƭ'

LatinSmallLetterTWithHook

\u{1ad}: 'ƭ'

LatinCapitalLetterTWithRetroflexHook

\u{1ae}: 'Ʈ'

LatinCapitalLetterUWithHorn

\u{1af}: 'Ư'

LatinSmallLetterUWithHorn

\u{1b0}: 'ư'

LatinCapitalLetterUpsilon

\u{1b1}: 'Ʊ'

LatinCapitalLetterVWithHook

\u{1b2}: 'Ʋ'

LatinCapitalLetterYWithHook

\u{1b3}: 'Ƴ'

LatinSmallLetterYWithHook

\u{1b4}: 'ƴ'

LatinCapitalLetterZWithStroke

\u{1b5}: 'Ƶ'

LatinSmallLetterZWithStroke

\u{1b6}: 'ƶ'

LatinCapitalLetterEzh

\u{1b7}: 'Ʒ'

LatinCapitalLetterEzhReversed

\u{1b8}: 'Ƹ'

LatinSmallLetterEzhReversed

\u{1b9}: 'ƹ'

LatinSmallLetterEzhWithTail

\u{1ba}: 'ƺ'

LatinLetterTwoWithStroke

\u{1bb}: 'ƻ'

LatinCapitalLetterToneFive

\u{1bc}: 'Ƽ'

LatinSmallLetterToneFive

\u{1bd}: 'ƽ'

LatinLetterInvertedGlottalStopWithStroke

\u{1be}: 'ƾ'

LatinLetterWynn

\u{1bf}: 'ƿ'

LatinLetterDentalClick

\u{1c0}: 'ǀ'

LatinLetterLateralClick

\u{1c1}: 'ǁ'

LatinLetterAlveolarClick

\u{1c2}: 'ǂ'

LatinLetterRetroflexClick

\u{1c3}: 'ǃ'

LatinCapitalLetterDzWithCaron

\u{1c4}: 'DŽ'

LatinCapitalLetterDWithSmallLetterZWithCaron

\u{1c5}: 'Dž'

LatinSmallLetterDzWithCaron

\u{1c6}: 'dž'

LatinCapitalLetterLj

\u{1c7}: 'LJ'

LatinCapitalLetterLWithSmallLetterJ

\u{1c8}: 'Lj'

LatinSmallLetterLj

\u{1c9}: 'lj'

LatinCapitalLetterNj

\u{1ca}: 'NJ'

LatinCapitalLetterNWithSmallLetterJ

\u{1cb}: 'Nj'

LatinSmallLetterNj

\u{1cc}: 'nj'

LatinCapitalLetterAWithCaron

\u{1cd}: 'Ǎ'

LatinSmallLetterAWithCaron

\u{1ce}: 'ǎ'

LatinCapitalLetterIWithCaron

\u{1cf}: 'Ǐ'

LatinSmallLetterIWithCaron

\u{1d0}: 'ǐ'

LatinCapitalLetterOWithCaron

\u{1d1}: 'Ǒ'

LatinSmallLetterOWithCaron

\u{1d2}: 'ǒ'

LatinCapitalLetterUWithCaron

\u{1d3}: 'Ǔ'

LatinSmallLetterUWithCaron

\u{1d4}: 'ǔ'

LatinCapitalLetterUWithDiaeresisAndMacron

\u{1d5}: 'Ǖ'

LatinSmallLetterUWithDiaeresisAndMacron

\u{1d6}: 'ǖ'

LatinCapitalLetterUWithDiaeresisAndAcute

\u{1d7}: 'Ǘ'

LatinSmallLetterUWithDiaeresisAndAcute

\u{1d8}: 'ǘ'

LatinCapitalLetterUWithDiaeresisAndCaron

\u{1d9}: 'Ǚ'

LatinSmallLetterUWithDiaeresisAndCaron

\u{1da}: 'ǚ'

LatinCapitalLetterUWithDiaeresisAndGrave

\u{1db}: 'Ǜ'

LatinSmallLetterUWithDiaeresisAndGrave

\u{1dc}: 'ǜ'

LatinSmallLetterTurnedE

\u{1dd}: 'ǝ'

LatinCapitalLetterAWithDiaeresisAndMacron

\u{1de}: 'Ǟ'

LatinSmallLetterAWithDiaeresisAndMacron

\u{1df}: 'ǟ'

LatinCapitalLetterAWithDotAboveAndMacron

\u{1e0}: 'Ǡ'

LatinSmallLetterAWithDotAboveAndMacron

\u{1e1}: 'ǡ'

LatinCapitalLetterAeWithMacron

\u{1e2}: 'Ǣ'

LatinSmallLetterAeWithMacron

\u{1e3}: 'ǣ'

LatinCapitalLetterGWithStroke

\u{1e4}: 'Ǥ'

LatinSmallLetterGWithStroke

\u{1e5}: 'ǥ'

LatinCapitalLetterGWithCaron

\u{1e6}: 'Ǧ'

LatinSmallLetterGWithCaron

\u{1e7}: 'ǧ'

LatinCapitalLetterKWithCaron

\u{1e8}: 'Ǩ'

LatinSmallLetterKWithCaron

\u{1e9}: 'ǩ'

LatinCapitalLetterOWithOgonek

\u{1ea}: 'Ǫ'

LatinSmallLetterOWithOgonek

\u{1eb}: 'ǫ'

LatinCapitalLetterOWithOgonekAndMacron

\u{1ec}: 'Ǭ'

LatinSmallLetterOWithOgonekAndMacron

\u{1ed}: 'ǭ'

LatinCapitalLetterEzhWithCaron

\u{1ee}: 'Ǯ'

LatinSmallLetterEzhWithCaron

\u{1ef}: 'ǯ'

LatinSmallLetterJWithCaron

\u{1f0}: 'ǰ'

LatinCapitalLetterDz

\u{1f1}: 'DZ'

LatinCapitalLetterDWithSmallLetterZ

\u{1f2}: 'Dz'

LatinSmallLetterDz

\u{1f3}: 'dz'

LatinCapitalLetterGWithAcute

\u{1f4}: 'Ǵ'

LatinSmallLetterGWithAcute

\u{1f5}: 'ǵ'

LatinCapitalLetterHwair

\u{1f6}: 'Ƕ'

LatinCapitalLetterWynn

\u{1f7}: 'Ƿ'

LatinCapitalLetterNWithGrave

\u{1f8}: 'Ǹ'

LatinSmallLetterNWithGrave

\u{1f9}: 'ǹ'

LatinCapitalLetterAWithRingAboveAndAcute

\u{1fa}: 'Ǻ'

LatinSmallLetterAWithRingAboveAndAcute

\u{1fb}: 'ǻ'

LatinCapitalLetterAeWithAcute

\u{1fc}: 'Ǽ'

LatinSmallLetterAeWithAcute

\u{1fd}: 'ǽ'

LatinCapitalLetterOWithStrokeAndAcute

\u{1fe}: 'Ǿ'

LatinSmallLetterOWithStrokeAndAcute

\u{1ff}: 'ǿ'

LatinCapitalLetterAWithDoubleGrave

\u{200}: 'Ȁ'

LatinSmallLetterAWithDoubleGrave

\u{201}: 'ȁ'

LatinCapitalLetterAWithInvertedBreve

\u{202}: 'Ȃ'

LatinSmallLetterAWithInvertedBreve

\u{203}: 'ȃ'

LatinCapitalLetterEWithDoubleGrave

\u{204}: 'Ȅ'

LatinSmallLetterEWithDoubleGrave

\u{205}: 'ȅ'

LatinCapitalLetterEWithInvertedBreve

\u{206}: 'Ȇ'

LatinSmallLetterEWithInvertedBreve

\u{207}: 'ȇ'

LatinCapitalLetterIWithDoubleGrave

\u{208}: 'Ȉ'

LatinSmallLetterIWithDoubleGrave

\u{209}: 'ȉ'

LatinCapitalLetterIWithInvertedBreve

\u{20a}: 'Ȋ'

LatinSmallLetterIWithInvertedBreve

\u{20b}: 'ȋ'

LatinCapitalLetterOWithDoubleGrave

\u{20c}: 'Ȍ'

LatinSmallLetterOWithDoubleGrave

\u{20d}: 'ȍ'

LatinCapitalLetterOWithInvertedBreve

\u{20e}: 'Ȏ'

LatinSmallLetterOWithInvertedBreve

\u{20f}: 'ȏ'

LatinCapitalLetterRWithDoubleGrave

\u{210}: 'Ȑ'

LatinSmallLetterRWithDoubleGrave

\u{211}: 'ȑ'

LatinCapitalLetterRWithInvertedBreve

\u{212}: 'Ȓ'

LatinSmallLetterRWithInvertedBreve

\u{213}: 'ȓ'

LatinCapitalLetterUWithDoubleGrave

\u{214}: 'Ȕ'

LatinSmallLetterUWithDoubleGrave

\u{215}: 'ȕ'

LatinCapitalLetterUWithInvertedBreve

\u{216}: 'Ȗ'

LatinSmallLetterUWithInvertedBreve

\u{217}: 'ȗ'

LatinCapitalLetterSWithCommaBelow

\u{218}: 'Ș'

LatinSmallLetterSWithCommaBelow

\u{219}: 'ș'

LatinCapitalLetterTWithCommaBelow

\u{21a}: 'Ț'

LatinSmallLetterTWithCommaBelow

\u{21b}: 'ț'

LatinCapitalLetterYogh

\u{21c}: 'Ȝ'

LatinSmallLetterYogh

\u{21d}: 'ȝ'

LatinCapitalLetterHWithCaron

\u{21e}: 'Ȟ'

LatinSmallLetterHWithCaron

\u{21f}: 'ȟ'

LatinCapitalLetterNWithLongRightLeg

\u{220}: 'Ƞ'

LatinSmallLetterDWithCurl

\u{221}: 'ȡ'

LatinCapitalLetterOu

\u{222}: 'Ȣ'

LatinSmallLetterOu

\u{223}: 'ȣ'

LatinCapitalLetterZWithHook

\u{224}: 'Ȥ'

LatinSmallLetterZWithHook

\u{225}: 'ȥ'

LatinCapitalLetterAWithDotAbove

\u{226}: 'Ȧ'

LatinSmallLetterAWithDotAbove

\u{227}: 'ȧ'

LatinCapitalLetterEWithCedilla

\u{228}: 'Ȩ'

LatinSmallLetterEWithCedilla

\u{229}: 'ȩ'

LatinCapitalLetterOWithDiaeresisAndMacron

\u{22a}: 'Ȫ'

LatinSmallLetterOWithDiaeresisAndMacron

\u{22b}: 'ȫ'

LatinCapitalLetterOWithTildeAndMacron

\u{22c}: 'Ȭ'

LatinSmallLetterOWithTildeAndMacron

\u{22d}: 'ȭ'

LatinCapitalLetterOWithDotAbove

\u{22e}: 'Ȯ'

LatinSmallLetterOWithDotAbove

\u{22f}: 'ȯ'

LatinCapitalLetterOWithDotAboveAndMacron

\u{230}: 'Ȱ'

LatinSmallLetterOWithDotAboveAndMacron

\u{231}: 'ȱ'

LatinCapitalLetterYWithMacron

\u{232}: 'Ȳ'

LatinSmallLetterYWithMacron

\u{233}: 'ȳ'

LatinSmallLetterLWithCurl

\u{234}: 'ȴ'

LatinSmallLetterNWithCurl

\u{235}: 'ȵ'

LatinSmallLetterTWithCurl

\u{236}: 'ȶ'

LatinSmallLetterDotlessJ

\u{237}: 'ȷ'

LatinSmallLetterDbDigraph

\u{238}: 'ȸ'

LatinSmallLetterQpDigraph

\u{239}: 'ȹ'

LatinCapitalLetterAWithStroke

\u{23a}: 'Ⱥ'

LatinCapitalLetterCWithStroke

\u{23b}: 'Ȼ'

LatinSmallLetterCWithStroke

\u{23c}: 'ȼ'

LatinCapitalLetterLWithBar

\u{23d}: 'Ƚ'

LatinCapitalLetterTWithDiagonalStroke

\u{23e}: 'Ⱦ'

LatinSmallLetterSWithSwashTail

\u{23f}: 'ȿ'

LatinSmallLetterZWithSwashTail

\u{240}: 'ɀ'

LatinCapitalLetterGlottalStop

\u{241}: 'Ɂ'

LatinSmallLetterGlottalStop

\u{242}: 'ɂ'

LatinCapitalLetterBWithStroke

\u{243}: 'Ƀ'

LatinCapitalLetterUBar

\u{244}: 'Ʉ'

LatinCapitalLetterTurnedV

\u{245}: 'Ʌ'

LatinCapitalLetterEWithStroke

\u{246}: 'Ɇ'

LatinSmallLetterEWithStroke

\u{247}: 'ɇ'

LatinCapitalLetterJWithStroke

\u{248}: 'Ɉ'

LatinSmallLetterJWithStroke

\u{249}: 'ɉ'

LatinCapitalLetterSmallQWithHookTail

\u{24a}: 'Ɋ'

LatinSmallLetterQWithHookTail

\u{24b}: 'ɋ'

LatinCapitalLetterRWithStroke

\u{24c}: 'Ɍ'

LatinSmallLetterRWithStroke

\u{24d}: 'ɍ'

LatinCapitalLetterYWithStroke

\u{24e}: 'Ɏ'

Methods

impl LatinExtendedB

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 LatinExtendedB

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

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

Important traits for LatinExtendedB

impl Iterator for LatinExtendedB type Item = Self;

fn clone(&self) -> LatinExtendedB

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Into<char> for LatinExtendedB

fn into(self) -> char

Performs the conversion.

impl Into<u32> for LatinExtendedB

fn into(self) -> u32

Performs the conversion.

impl Eq for LatinExtendedB

impl Copy for LatinExtendedB

impl Hash for LatinExtendedB

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 LatinExtendedB

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

Formats the value using the given formatter.

impl TryFrom<char> for LatinExtendedB

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 LatinExtendedB

type Error = ()

The type returned in the event of a conversion error.

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

Performs the conversion.