Enum unicode_types::vai::Vai

pub enum Vai {
    SyllableEe,
    SyllableEen,
    SyllableHee,
    SyllableWee,
    SyllableWeen,
    SyllablePee,
    SyllableBhee,
    SyllableBee,
    SyllableMbee,
    SyllableKpee,
    SyllableMgbee,
    SyllableGbee,
    SyllableFee,
    SyllableVee,
    SyllableTee,
    SyllableThee,
    SyllableDhee,
    SyllableDhhee,
    SyllableLee,
    SyllableRee,
    SyllableDee,
    SyllableNdee,
    SyllableSee,
    SyllableShee,
    SyllableZee,
    SyllableZhee,
    SyllableCee,
    SyllableJee,
    SyllableNjee,
    SyllableYee,
    SyllableKee,
    SyllableNggee,
    SyllableGee,
    SyllableMee,
    SyllableNee,
    SyllableNyee,
    SyllableI,
    SyllableIn,
    SyllableHi,
    SyllableHin,
    SyllableWi,
    SyllableWin,
    SyllablePi,
    SyllableBhi,
    SyllableBi,
    SyllableMbi,
    SyllableKpi,
    SyllableMgbi,
    SyllableGbi,
    SyllableFi,
    SyllableVi,
    SyllableTi,
    SyllableThi,
    SyllableDhi,
    SyllableDhhi,
    SyllableLi,
    SyllableRi,
    SyllableDi,
    SyllableNdi,
    SyllableSi,
    SyllableShi,
    SyllableZi,
    SyllableZhi,
    SyllableCi,
    SyllableJi,
    SyllableNji,
    SyllableYi,
    SyllableKi,
    SyllableNggi,
    SyllableGi,
    SyllableMi,
    SyllableNi,
    SyllableNyi,
    SyllableA,
    SyllableAn,
    SyllableNgan,
    SyllableHa,
    SyllableHan,
    SyllableWa,
    SyllableWan,
    SyllablePa,
    SyllableBha,
    SyllableBa,
    SyllableMba,
    SyllableKpa,
    SyllableKpan,
    SyllableMgba,
    SyllableGba,
    SyllableFa,
    SyllableVa,
    SyllableTa,
    SyllableTha,
    SyllableDha,
    SyllableDhha,
    SyllableLa,
    SyllableRa,
    SyllableDa,
    SyllableNda,
    SyllableSa,
    SyllableSha,
    SyllableZa,
    SyllableZha,
    SyllableCa,
    SyllableJa,
    SyllableNja,
    SyllableYa,
    SyllableKa,
    SyllableKan,
    SyllableNgga,
    SyllableGa,
    SyllableMa,
    SyllableNa,
    SyllableNya,
    SyllableOo,
    SyllableOon,
    SyllableHoo,
    SyllableWoo,
    SyllableWoon,
    SyllablePoo,
    SyllableBhoo,
    SyllableBoo,
    SyllableMboo,
    SyllableKpoo,
    SyllableMgboo,
    SyllableGboo,
    SyllableFoo,
    SyllableVoo,
    SyllableToo,
    SyllableThoo,
    SyllableDhoo,
    SyllableDhhoo,
    SyllableLoo,
    SyllableRoo,
    SyllableDoo,
    SyllableNdoo,
    SyllableSoo,
    SyllableShoo,
    SyllableZoo,
    SyllableZhoo,
    SyllableCoo,
    SyllableJoo,
    SyllableNjoo,
    SyllableYoo,
    SyllableKoo,
    SyllableNggoo,
    SyllableGoo,
    SyllableMoo,
    SyllableNoo,
    SyllableNyoo,
    SyllableU,
    SyllableUn,
    SyllableHu,
    SyllableHun,
    SyllableWu,
    SyllableWun,
    SyllablePu,
    SyllableBhu,
    SyllableBu,
    SyllableMbu,
    SyllableKpu,
    SyllableMgbu,
    SyllableGbu,
    SyllableFu,
    SyllableVu,
    SyllableTu,
    SyllableThu,
    SyllableDhu,
    SyllableDhhu,
    SyllableLu,
    SyllableRu,
    SyllableDu,
    SyllableNdu,
    SyllableSu,
    SyllableShu,
    SyllableZu,
    SyllableZhu,
    SyllableCu,
    SyllableJu,
    SyllableNju,
    SyllableYu,
    SyllableKu,
    SyllableNggu,
    SyllableGu,
    SyllableMu,
    SyllableNu,
    SyllableNyu,
    SyllableO,
    SyllableOn,
    SyllableNgon,
    SyllableHo,
    SyllableHon,
    SyllableWo,
    SyllableWon,
    SyllablePo,
    SyllableBho,
    SyllableBo,
    SyllableMbo,
    SyllableKpo,
    SyllableMgbo,
    SyllableGbo,
    SyllableGbon,
    SyllableFo,
    SyllableVo,
    SyllableTo,
    SyllableTho,
    SyllableDho,
    SyllableDhho,
    SyllableLo,
    SyllableRo,
    SyllableDo,
    SyllableNdo,
    SyllableSo,
    SyllableSho,
    SyllableZo,
    SyllableZho,
    SyllableCo,
    SyllableJo,
    SyllableNjo,
    SyllableYo,
    SyllableKo,
    SyllableNggo,
    SyllableGo,
    SyllableMo,
    SyllableNo,
    SyllableNyo,
    SyllableE,
    SyllableEn,
    SyllableNgen,
    SyllableHe,
    SyllableHen,
    SyllableWe,
    SyllableWen,
    SyllablePe,
    SyllableBhe,
    SyllableBe,
    SyllableMbe,
    SyllableKpe,
    SyllableKpen,
    SyllableMgbe,
    SyllableGbe,
    SyllableGben,
    SyllableFe,
    SyllableVe,
    SyllableTe,
    SyllableThe,
    SyllableDhe,
    SyllableDhhe,
    SyllableLe,
    SyllableRe,
    SyllableDe,
    SyllableNde,
    SyllableSe,
    SyllableShe,
    SyllableZe,
    SyllableZhe,
    SyllableCe,
    SyllableJe,
    SyllableNje,
    SyllableYe,
    SyllableKe,
    SyllableNgge,
    SyllableNggen,
    SyllableGe,
    SyllableGen,
    SyllableMe,
    SyllableNe,
    SyllableNye,
    SyllableNg,
    SyllableLengthener,
    Comma,
    FullStop,
    QuestionMark,
    SyllableNdoleFa,
    SyllableNdoleKa,
    SyllableNdoleSoo,
    SymbolFeeng,
    SymbolKeeng,
    SymbolTing,
    SymbolNii,
    SymbolBang,
    SymbolFaa,
    SymbolTaa,
    SymbolDang,
    SymbolDoong,
    SymbolKung,
    SymbolTong,
    SymbolDoDashO,
    SymbolJong,
    DigitZero,
    DigitOne,
    DigitTwo,
    DigitThree,
    DigitFour,
    DigitFive,
    DigitSix,
    DigitSeven,
    DigitEight,
    DigitNine,
    SyllableNdoleMa,
    SyllableNdoleDo,
}

An enum to represent all characters in the Vai block.

Variants

SyllableEe

\u{a500}: 'ꔀ'

SyllableEen

\u{a501}: 'ꔁ'

SyllableHee

\u{a502}: 'ꔂ'

SyllableWee

\u{a503}: 'ꔃ'

SyllableWeen

\u{a504}: 'ꔄ'

SyllablePee

\u{a505}: 'ꔅ'

SyllableBhee

\u{a506}: 'ꔆ'

SyllableBee

\u{a507}: 'ꔇ'

SyllableMbee

\u{a508}: 'ꔈ'

SyllableKpee

\u{a509}: 'ꔉ'

SyllableMgbee

\u{a50a}: 'ꔊ'

SyllableGbee

\u{a50b}: 'ꔋ'

SyllableFee

\u{a50c}: 'ꔌ'

SyllableVee

\u{a50d}: 'ꔍ'

SyllableTee

\u{a50e}: 'ꔎ'

SyllableThee

\u{a50f}: 'ꔏ'

SyllableDhee

\u{a510}: 'ꔐ'

SyllableDhhee

\u{a511}: 'ꔑ'

SyllableLee

\u{a512}: 'ꔒ'

SyllableRee

\u{a513}: 'ꔓ'

SyllableDee

\u{a514}: 'ꔔ'

SyllableNdee

\u{a515}: 'ꔕ'

SyllableSee

\u{a516}: 'ꔖ'

SyllableShee

\u{a517}: 'ꔗ'

SyllableZee

\u{a518}: 'ꔘ'

SyllableZhee

\u{a519}: 'ꔙ'

SyllableCee

\u{a51a}: 'ꔚ'

SyllableJee

\u{a51b}: 'ꔛ'

SyllableNjee

\u{a51c}: 'ꔜ'

SyllableYee

\u{a51d}: 'ꔝ'

SyllableKee

\u{a51e}: 'ꔞ'

SyllableNggee

\u{a51f}: 'ꔟ'

SyllableGee

\u{a520}: 'ꔠ'

SyllableMee

\u{a521}: 'ꔡ'

SyllableNee

\u{a522}: 'ꔢ'

SyllableNyee

\u{a523}: 'ꔣ'

SyllableI

\u{a524}: 'ꔤ'

SyllableIn

\u{a525}: 'ꔥ'

SyllableHi

\u{a526}: 'ꔦ'

SyllableHin

\u{a527}: 'ꔧ'

SyllableWi

\u{a528}: 'ꔨ'

SyllableWin

\u{a529}: 'ꔩ'

SyllablePi

\u{a52a}: 'ꔪ'

SyllableBhi

\u{a52b}: 'ꔫ'

SyllableBi

\u{a52c}: 'ꔬ'

SyllableMbi

\u{a52d}: 'ꔭ'

SyllableKpi

\u{a52e}: 'ꔮ'

SyllableMgbi

\u{a52f}: 'ꔯ'

SyllableGbi

\u{a530}: 'ꔰ'

SyllableFi

\u{a531}: 'ꔱ'

SyllableVi

\u{a532}: 'ꔲ'

SyllableTi

\u{a533}: 'ꔳ'

SyllableThi

\u{a534}: 'ꔴ'

SyllableDhi

\u{a535}: 'ꔵ'

SyllableDhhi

\u{a536}: 'ꔶ'

SyllableLi

\u{a537}: 'ꔷ'

SyllableRi

\u{a538}: 'ꔸ'

SyllableDi

\u{a539}: 'ꔹ'

SyllableNdi

\u{a53a}: 'ꔺ'

SyllableSi

\u{a53b}: 'ꔻ'

SyllableShi

\u{a53c}: 'ꔼ'

SyllableZi

\u{a53d}: 'ꔽ'

SyllableZhi

\u{a53e}: 'ꔾ'

SyllableCi

\u{a53f}: 'ꔿ'

SyllableJi

\u{a540}: 'ꕀ'

SyllableNji

\u{a541}: 'ꕁ'

SyllableYi

\u{a542}: 'ꕂ'

SyllableKi

\u{a543}: 'ꕃ'

SyllableNggi

\u{a544}: 'ꕄ'

SyllableGi

\u{a545}: 'ꕅ'

SyllableMi

\u{a546}: 'ꕆ'

SyllableNi

\u{a547}: 'ꕇ'

SyllableNyi

\u{a548}: 'ꕈ'

SyllableA

\u{a549}: 'ꕉ'

SyllableAn

\u{a54a}: 'ꕊ'

SyllableNgan

\u{a54b}: 'ꕋ'

SyllableHa

\u{a54c}: 'ꕌ'

SyllableHan

\u{a54d}: 'ꕍ'

SyllableWa

\u{a54e}: 'ꕎ'

SyllableWan

\u{a54f}: 'ꕏ'

SyllablePa

\u{a550}: 'ꕐ'

SyllableBha

\u{a551}: 'ꕑ'

SyllableBa

\u{a552}: 'ꕒ'

SyllableMba

\u{a553}: 'ꕓ'

SyllableKpa

\u{a554}: 'ꕔ'

SyllableKpan

\u{a555}: 'ꕕ'

SyllableMgba

\u{a556}: 'ꕖ'

SyllableGba

\u{a557}: 'ꕗ'

SyllableFa

\u{a558}: 'ꕘ'

SyllableVa

\u{a559}: 'ꕙ'

SyllableTa

\u{a55a}: 'ꕚ'

SyllableTha

\u{a55b}: 'ꕛ'

SyllableDha

\u{a55c}: 'ꕜ'

SyllableDhha

\u{a55d}: 'ꕝ'

SyllableLa

\u{a55e}: 'ꕞ'

SyllableRa

\u{a55f}: 'ꕟ'

SyllableDa

\u{a560}: 'ꕠ'

SyllableNda

\u{a561}: 'ꕡ'

SyllableSa

\u{a562}: 'ꕢ'

SyllableSha

\u{a563}: 'ꕣ'

SyllableZa

\u{a564}: 'ꕤ'

SyllableZha

\u{a565}: 'ꕥ'

SyllableCa

\u{a566}: 'ꕦ'

SyllableJa

\u{a567}: 'ꕧ'

SyllableNja

\u{a568}: 'ꕨ'

SyllableYa

\u{a569}: 'ꕩ'

SyllableKa

\u{a56a}: 'ꕪ'

SyllableKan

\u{a56b}: 'ꕫ'

SyllableNgga

\u{a56c}: 'ꕬ'

SyllableGa

\u{a56d}: 'ꕭ'

SyllableMa

\u{a56e}: 'ꕮ'

SyllableNa

\u{a56f}: 'ꕯ'

SyllableNya

\u{a570}: 'ꕰ'

SyllableOo

\u{a571}: 'ꕱ'

SyllableOon

\u{a572}: 'ꕲ'

SyllableHoo

\u{a573}: 'ꕳ'

SyllableWoo

\u{a574}: 'ꕴ'

SyllableWoon

\u{a575}: 'ꕵ'

SyllablePoo

\u{a576}: 'ꕶ'

SyllableBhoo

\u{a577}: 'ꕷ'

SyllableBoo

\u{a578}: 'ꕸ'

SyllableMboo

\u{a579}: 'ꕹ'

SyllableKpoo

\u{a57a}: 'ꕺ'

SyllableMgboo

\u{a57b}: 'ꕻ'

SyllableGboo

\u{a57c}: 'ꕼ'

SyllableFoo

\u{a57d}: 'ꕽ'

SyllableVoo

\u{a57e}: 'ꕾ'

SyllableToo

\u{a57f}: 'ꕿ'

SyllableThoo

\u{a580}: 'ꖀ'

SyllableDhoo

\u{a581}: 'ꖁ'

SyllableDhhoo

\u{a582}: 'ꖂ'

SyllableLoo

\u{a583}: 'ꖃ'

SyllableRoo

\u{a584}: 'ꖄ'

SyllableDoo

\u{a585}: 'ꖅ'

SyllableNdoo

\u{a586}: 'ꖆ'

SyllableSoo

\u{a587}: 'ꖇ'

SyllableShoo

\u{a588}: 'ꖈ'

SyllableZoo

\u{a589}: 'ꖉ'

SyllableZhoo

\u{a58a}: 'ꖊ'

SyllableCoo

\u{a58b}: 'ꖋ'

SyllableJoo

\u{a58c}: 'ꖌ'

SyllableNjoo

\u{a58d}: 'ꖍ'

SyllableYoo

\u{a58e}: 'ꖎ'

SyllableKoo

\u{a58f}: 'ꖏ'

SyllableNggoo

\u{a590}: 'ꖐ'

SyllableGoo

\u{a591}: 'ꖑ'

SyllableMoo

\u{a592}: 'ꖒ'

SyllableNoo

\u{a593}: 'ꖓ'

SyllableNyoo

\u{a594}: 'ꖔ'

SyllableU

\u{a595}: 'ꖕ'

SyllableUn

\u{a596}: 'ꖖ'

SyllableHu

\u{a597}: 'ꖗ'

SyllableHun

\u{a598}: 'ꖘ'

SyllableWu

\u{a599}: 'ꖙ'

SyllableWun

\u{a59a}: 'ꖚ'

SyllablePu

\u{a59b}: 'ꖛ'

SyllableBhu

\u{a59c}: 'ꖜ'

SyllableBu

\u{a59d}: 'ꖝ'

SyllableMbu

\u{a59e}: 'ꖞ'

SyllableKpu

\u{a59f}: 'ꖟ'

SyllableMgbu

\u{a5a0}: 'ꖠ'

SyllableGbu

\u{a5a1}: 'ꖡ'

SyllableFu

\u{a5a2}: 'ꖢ'

SyllableVu

\u{a5a3}: 'ꖣ'

SyllableTu

\u{a5a4}: 'ꖤ'

SyllableThu

\u{a5a5}: 'ꖥ'

SyllableDhu

\u{a5a6}: 'ꖦ'

SyllableDhhu

\u{a5a7}: 'ꖧ'

SyllableLu

\u{a5a8}: 'ꖨ'

SyllableRu

\u{a5a9}: 'ꖩ'

SyllableDu

\u{a5aa}: 'ꖪ'

SyllableNdu

\u{a5ab}: 'ꖫ'

SyllableSu

\u{a5ac}: 'ꖬ'

SyllableShu

\u{a5ad}: 'ꖭ'

SyllableZu

\u{a5ae}: 'ꖮ'

SyllableZhu

\u{a5af}: 'ꖯ'

SyllableCu

\u{a5b0}: 'ꖰ'

SyllableJu

\u{a5b1}: 'ꖱ'

SyllableNju

\u{a5b2}: 'ꖲ'

SyllableYu

\u{a5b3}: 'ꖳ'

SyllableKu

\u{a5b4}: 'ꖴ'

SyllableNggu

\u{a5b5}: 'ꖵ'

SyllableGu

\u{a5b6}: 'ꖶ'

SyllableMu

\u{a5b7}: 'ꖷ'

SyllableNu

\u{a5b8}: 'ꖸ'

SyllableNyu

\u{a5b9}: 'ꖹ'

SyllableO

\u{a5ba}: 'ꖺ'

SyllableOn

\u{a5bb}: 'ꖻ'

SyllableNgon

\u{a5bc}: 'ꖼ'

SyllableHo

\u{a5bd}: 'ꖽ'

SyllableHon

\u{a5be}: 'ꖾ'

SyllableWo

\u{a5bf}: 'ꖿ'

SyllableWon

\u{a5c0}: 'ꗀ'

SyllablePo

\u{a5c1}: 'ꗁ'

SyllableBho

\u{a5c2}: 'ꗂ'

SyllableBo

\u{a5c3}: 'ꗃ'

SyllableMbo

\u{a5c4}: 'ꗄ'

SyllableKpo

\u{a5c5}: 'ꗅ'

SyllableMgbo

\u{a5c6}: 'ꗆ'

SyllableGbo

\u{a5c7}: 'ꗇ'

SyllableGbon

\u{a5c8}: 'ꗈ'

SyllableFo

\u{a5c9}: 'ꗉ'

SyllableVo

\u{a5ca}: 'ꗊ'

SyllableTo

\u{a5cb}: 'ꗋ'

SyllableTho

\u{a5cc}: 'ꗌ'

SyllableDho

\u{a5cd}: 'ꗍ'

SyllableDhho

\u{a5ce}: 'ꗎ'

SyllableLo

\u{a5cf}: 'ꗏ'

SyllableRo

\u{a5d0}: 'ꗐ'

SyllableDo

\u{a5d1}: 'ꗑ'

SyllableNdo

\u{a5d2}: 'ꗒ'

SyllableSo

\u{a5d3}: 'ꗓ'

SyllableSho

\u{a5d4}: 'ꗔ'

SyllableZo

\u{a5d5}: 'ꗕ'

SyllableZho

\u{a5d6}: 'ꗖ'

SyllableCo

\u{a5d7}: 'ꗗ'

SyllableJo

\u{a5d8}: 'ꗘ'

SyllableNjo

\u{a5d9}: 'ꗙ'

SyllableYo

\u{a5da}: 'ꗚ'

SyllableKo

\u{a5db}: 'ꗛ'

SyllableNggo

\u{a5dc}: 'ꗜ'

SyllableGo

\u{a5dd}: 'ꗝ'

SyllableMo

\u{a5de}: 'ꗞ'

SyllableNo

\u{a5df}: 'ꗟ'

SyllableNyo

\u{a5e0}: 'ꗠ'

SyllableE

\u{a5e1}: 'ꗡ'

SyllableEn

\u{a5e2}: 'ꗢ'

SyllableNgen

\u{a5e3}: 'ꗣ'

SyllableHe

\u{a5e4}: 'ꗤ'

SyllableHen

\u{a5e5}: 'ꗥ'

SyllableWe

\u{a5e6}: 'ꗦ'

SyllableWen

\u{a5e7}: 'ꗧ'

SyllablePe

\u{a5e8}: 'ꗨ'

SyllableBhe

\u{a5e9}: 'ꗩ'

SyllableBe

\u{a5ea}: 'ꗪ'

SyllableMbe

\u{a5eb}: 'ꗫ'

SyllableKpe

\u{a5ec}: 'ꗬ'

SyllableKpen

\u{a5ed}: 'ꗭ'

SyllableMgbe

\u{a5ee}: 'ꗮ'

SyllableGbe

\u{a5ef}: 'ꗯ'

SyllableGben

\u{a5f0}: 'ꗰ'

SyllableFe

\u{a5f1}: 'ꗱ'

SyllableVe

\u{a5f2}: 'ꗲ'

SyllableTe

\u{a5f3}: 'ꗳ'

SyllableThe

\u{a5f4}: 'ꗴ'

SyllableDhe

\u{a5f5}: 'ꗵ'

SyllableDhhe

\u{a5f6}: 'ꗶ'

SyllableLe

\u{a5f7}: 'ꗷ'

SyllableRe

\u{a5f8}: 'ꗸ'

SyllableDe

\u{a5f9}: 'ꗹ'

SyllableNde

\u{a5fa}: 'ꗺ'

SyllableSe

\u{a5fb}: 'ꗻ'

SyllableShe

\u{a5fc}: 'ꗼ'

SyllableZe

\u{a5fd}: 'ꗽ'

SyllableZhe

\u{a5fe}: 'ꗾ'

SyllableCe

\u{a5ff}: 'ꗿ'

SyllableJe

\u{a600}: 'ꘀ'

SyllableNje

\u{a601}: 'ꘁ'

SyllableYe

\u{a602}: 'ꘂ'

SyllableKe

\u{a603}: 'ꘃ'

SyllableNgge

\u{a604}: 'ꘄ'

SyllableNggen

\u{a605}: 'ꘅ'

SyllableGe

\u{a606}: 'ꘆ'

SyllableGen

\u{a607}: 'ꘇ'

SyllableMe

\u{a608}: 'ꘈ'

SyllableNe

\u{a609}: 'ꘉ'

SyllableNye

\u{a60a}: 'ꘊ'

SyllableNg

\u{a60b}: 'ꘋ'

SyllableLengthener

\u{a60c}: 'ꘌ'

Comma

\u{a60d}: '꘍'

FullStop

\u{a60e}: '꘎'

QuestionMark

\u{a60f}: '꘏'

SyllableNdoleFa

\u{a610}: 'ꘐ'

SyllableNdoleKa

\u{a611}: 'ꘑ'

SyllableNdoleSoo

\u{a612}: 'ꘒ'

SymbolFeeng

\u{a613}: 'ꘓ'

SymbolKeeng

\u{a614}: 'ꘔ'

SymbolTing

\u{a615}: 'ꘕ'

SymbolNii

\u{a616}: 'ꘖ'

SymbolBang

\u{a617}: 'ꘗ'

SymbolFaa

\u{a618}: 'ꘘ'

SymbolTaa

\u{a619}: 'ꘙ'

SymbolDang

\u{a61a}: 'ꘚ'

SymbolDoong

\u{a61b}: 'ꘛ'

SymbolKung

\u{a61c}: 'ꘜ'

SymbolTong

\u{a61d}: 'ꘝ'

SymbolDoDashO

\u{a61e}: 'ꘞ'

SymbolJong

\u{a61f}: 'ꘟ'

DigitZero

\u{a620}: '꘠'

DigitOne

\u{a621}: '꘡'

DigitTwo

\u{a622}: '꘢'

DigitThree

\u{a623}: '꘣'

DigitFour

\u{a624}: '꘤'

DigitFive

\u{a625}: '꘥'

DigitSix

\u{a626}: '꘦'

DigitSeven

\u{a627}: '꘧'

DigitEight

\u{a628}: '꘨'

DigitNine

\u{a629}: '꘩'

SyllableNdoleMa

\u{a62a}: 'ꘪ'

SyllableNdoleDo

\u{a62b}: 'ꘫ'

Methods

impl Vai

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 Vai

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

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

Important traits for Vai

impl Iterator for Vai type Item = Self;

fn clone(&self) -> Vai

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Into<char> for Vai

fn into(self) -> char

Performs the conversion.

impl Into<u32> for Vai

fn into(self) -> u32

Performs the conversion.

impl Eq for Vai

impl Copy for Vai

impl Hash for Vai

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 Vai

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

Formats the value using the given formatter.

impl TryFrom<char> for Vai

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 Vai

type Error = ()

The type returned in the event of a conversion error.

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

Performs the conversion.