Enum unicode_types::kangxi_radicals::KangxiRadicals

pub enum KangxiRadicals {
    KangxiRadicalOne,
    KangxiRadicalLine,
    KangxiRadicalDot,
    KangxiRadicalSlash,
    KangxiRadicalSecond,
    KangxiRadicalHook,
    KangxiRadicalTwo,
    KangxiRadicalLid,
    KangxiRadicalMan,
    KangxiRadicalLegs,
    KangxiRadicalEnter,
    KangxiRadicalEight,
    KangxiRadicalDownBox,
    KangxiRadicalCover,
    KangxiRadicalIce,
    KangxiRadicalTable,
    KangxiRadicalOpenBox,
    KangxiRadicalKnife,
    KangxiRadicalPower,
    KangxiRadicalWrap,
    KangxiRadicalSpoon,
    KangxiRadicalRightOpenBox,
    KangxiRadicalHidingEnclosure,
    KangxiRadicalTen,
    KangxiRadicalDivination,
    KangxiRadicalSeal,
    KangxiRadicalCliff,
    KangxiRadicalPrivate,
    KangxiRadicalAgain,
    KangxiRadicalMouth,
    KangxiRadicalEnclosure,
    KangxiRadicalEarth,
    KangxiRadicalScholar,
    KangxiRadicalGo,
    KangxiRadicalGoSlowly,
    KangxiRadicalEvening,
    KangxiRadicalBig,
    KangxiRadicalWoman,
    KangxiRadicalChild,
    KangxiRadicalRoof,
    KangxiRadicalInch,
    KangxiRadicalSmall,
    KangxiRadicalLame,
    KangxiRadicalCorpse,
    KangxiRadicalSprout,
    KangxiRadicalMountain,
    KangxiRadicalRiver,
    KangxiRadicalWork,
    KangxiRadicalOneself,
    KangxiRadicalTurban,
    KangxiRadicalDry,
    KangxiRadicalShortThread,
    KangxiRadicalDottedCliff,
    KangxiRadicalLongStride,
    KangxiRadicalTwoHands,
    KangxiRadicalShoot,
    KangxiRadicalBow,
    KangxiRadicalSnout,
    KangxiRadicalBristle,
    KangxiRadicalStep,
    KangxiRadicalHeart,
    KangxiRadicalHalberd,
    KangxiRadicalDoor,
    KangxiRadicalHand,
    KangxiRadicalBranch,
    KangxiRadicalRap,
    KangxiRadicalScript,
    KangxiRadicalDipper,
    KangxiRadicalAxe,
    KangxiRadicalSquare,
    KangxiRadicalNot,
    KangxiRadicalSun,
    KangxiRadicalSay,
    KangxiRadicalMoon,
    KangxiRadicalTree,
    KangxiRadicalLack,
    KangxiRadicalStop,
    KangxiRadicalDeath,
    KangxiRadicalWeapon,
    KangxiRadicalDoNot,
    KangxiRadicalCompare,
    KangxiRadicalFur,
    KangxiRadicalClan,
    KangxiRadicalSteam,
    KangxiRadicalWater,
    KangxiRadicalFire,
    KangxiRadicalClaw,
    KangxiRadicalFather,
    KangxiRadicalDoubleX,
    KangxiRadicalHalfTreeTrunk,
    KangxiRadicalSlice,
    KangxiRadicalFang,
    KangxiRadicalCow,
    KangxiRadicalDog,
    KangxiRadicalProfound,
    KangxiRadicalJade,
    KangxiRadicalMelon,
    KangxiRadicalTile,
    KangxiRadicalSweet,
    KangxiRadicalLife,
    KangxiRadicalUse,
    KangxiRadicalField,
    KangxiRadicalBoltOfCloth,
    KangxiRadicalSickness,
    KangxiRadicalDottedTent,
    KangxiRadicalWhite,
    KangxiRadicalSkin,
    KangxiRadicalDish,
    KangxiRadicalEye,
    KangxiRadicalSpear,
    KangxiRadicalArrow,
    KangxiRadicalStone,
    KangxiRadicalSpirit,
    KangxiRadicalTrack,
    KangxiRadicalGrain,
    KangxiRadicalCave,
    KangxiRadicalStand,
    KangxiRadicalBamboo,
    KangxiRadicalRice,
    KangxiRadicalSilk,
    KangxiRadicalJar,
    KangxiRadicalNet,
    KangxiRadicalSheep,
    KangxiRadicalFeather,
    KangxiRadicalOld,
    KangxiRadicalAnd,
    KangxiRadicalPlow,
    KangxiRadicalEar,
    KangxiRadicalBrush,
    KangxiRadicalMeat,
    KangxiRadicalMinister,
    KangxiRadicalSelf,
    KangxiRadicalArrive,
    KangxiRadicalMortar,
    KangxiRadicalTongue,
    KangxiRadicalOppose,
    KangxiRadicalBoat,
    KangxiRadicalStopping,
    KangxiRadicalColor,
    KangxiRadicalGrass,
    KangxiRadicalTiger,
    KangxiRadicalInsect,
    KangxiRadicalBlood,
    KangxiRadicalWalkEnclosure,
    KangxiRadicalClothes,
    KangxiRadicalWest,
    KangxiRadicalSee,
    KangxiRadicalHorn,
    KangxiRadicalSpeech,
    KangxiRadicalValley,
    KangxiRadicalBean,
    KangxiRadicalPig,
    KangxiRadicalBadger,
    KangxiRadicalShell,
    KangxiRadicalRed,
    KangxiRadicalRun,
    KangxiRadicalFoot,
    KangxiRadicalBody,
    KangxiRadicalCart,
    KangxiRadicalBitter,
    KangxiRadicalMorning,
    KangxiRadicalWalk,
    KangxiRadicalCity,
    KangxiRadicalWine,
    KangxiRadicalDistinguish,
    KangxiRadicalVillage,
    KangxiRadicalGold,
    KangxiRadicalLong,
    KangxiRadicalGate,
    KangxiRadicalMound,
    KangxiRadicalSlave,
    KangxiRadicalShortTailedBird,
    KangxiRadicalRain,
    KangxiRadicalBlue,
    KangxiRadicalWrong,
    KangxiRadicalFace,
    KangxiRadicalLeather,
    KangxiRadicalTannedLeather,
    KangxiRadicalLeek,
    KangxiRadicalSound,
    KangxiRadicalLeaf,
    KangxiRadicalWind,
    KangxiRadicalFly,
    KangxiRadicalEat,
    KangxiRadicalHead,
    KangxiRadicalFragrant,
    KangxiRadicalHorse,
    KangxiRadicalBone,
    KangxiRadicalTall,
    KangxiRadicalHair,
    KangxiRadicalFight,
    KangxiRadicalSacrificialWine,
    KangxiRadicalCauldron,
    KangxiRadicalGhost,
    KangxiRadicalFish,
    KangxiRadicalBird,
    KangxiRadicalSalt,
    KangxiRadicalDeer,
    KangxiRadicalWheat,
    KangxiRadicalHemp,
    KangxiRadicalYellow,
    KangxiRadicalMillet,
    KangxiRadicalBlack,
    KangxiRadicalEmbroidery,
    KangxiRadicalFrog,
    KangxiRadicalTripod,
    KangxiRadicalDrum,
    KangxiRadicalRat,
    KangxiRadicalNose,
    KangxiRadicalEven,
    KangxiRadicalTooth,
    KangxiRadicalDragon,
    KangxiRadicalTurtle,
    KangxiRadicalFlute,
}

An enum to represent all characters in the KangxiRadicals block.

Variants

KangxiRadicalOne

\u{2f00}: '⼀'

KangxiRadicalLine

\u{2f01}: '⼁'

KangxiRadicalDot

\u{2f02}: '⼂'

KangxiRadicalSlash

\u{2f03}: '⼃'

KangxiRadicalSecond

\u{2f04}: '⼄'

KangxiRadicalHook

\u{2f05}: '⼅'

KangxiRadicalTwo

\u{2f06}: '⼆'

KangxiRadicalLid

\u{2f07}: '⼇'

KangxiRadicalMan

\u{2f08}: '⼈'

KangxiRadicalLegs

\u{2f09}: '⼉'

KangxiRadicalEnter

\u{2f0a}: '⼊'

KangxiRadicalEight

\u{2f0b}: '⼋'

KangxiRadicalDownBox

\u{2f0c}: '⼌'

KangxiRadicalCover

\u{2f0d}: '⼍'

KangxiRadicalIce

\u{2f0e}: '⼎'

KangxiRadicalTable

\u{2f0f}: '⼏'

KangxiRadicalOpenBox

\u{2f10}: '⼐'

KangxiRadicalKnife

\u{2f11}: '⼑'

KangxiRadicalPower

\u{2f12}: '⼒'

KangxiRadicalWrap

\u{2f13}: '⼓'

KangxiRadicalSpoon

\u{2f14}: '⼔'

KangxiRadicalRightOpenBox

\u{2f15}: '⼕'

KangxiRadicalHidingEnclosure

\u{2f16}: '⼖'

KangxiRadicalTen

\u{2f17}: '⼗'

KangxiRadicalDivination

\u{2f18}: '⼘'

KangxiRadicalSeal

\u{2f19}: '⼙'

KangxiRadicalCliff

\u{2f1a}: '⼚'

KangxiRadicalPrivate

\u{2f1b}: '⼛'

KangxiRadicalAgain

\u{2f1c}: '⼜'

KangxiRadicalMouth

\u{2f1d}: '⼝'

KangxiRadicalEnclosure

\u{2f1e}: '⼞'

KangxiRadicalEarth

\u{2f1f}: '⼟'

KangxiRadicalScholar

\u{2f20}: '⼠'

KangxiRadicalGo

\u{2f21}: '⼡'

KangxiRadicalGoSlowly

\u{2f22}: '⼢'

KangxiRadicalEvening

\u{2f23}: '⼣'

KangxiRadicalBig

\u{2f24}: '⼤'

KangxiRadicalWoman

\u{2f25}: '⼥'

KangxiRadicalChild

\u{2f26}: '⼦'

KangxiRadicalRoof

\u{2f27}: '⼧'

KangxiRadicalInch

\u{2f28}: '⼨'

KangxiRadicalSmall

\u{2f29}: '⼩'

KangxiRadicalLame

\u{2f2a}: '⼪'

KangxiRadicalCorpse

\u{2f2b}: '⼫'

KangxiRadicalSprout

\u{2f2c}: '⼬'

KangxiRadicalMountain

\u{2f2d}: '⼭'

KangxiRadicalRiver

\u{2f2e}: '⼮'

KangxiRadicalWork

\u{2f2f}: '⼯'

KangxiRadicalOneself

\u{2f30}: '⼰'

KangxiRadicalTurban

\u{2f31}: '⼱'

KangxiRadicalDry

\u{2f32}: '⼲'

KangxiRadicalShortThread

\u{2f33}: '⼳'

KangxiRadicalDottedCliff

\u{2f34}: '⼴'

KangxiRadicalLongStride

\u{2f35}: '⼵'

KangxiRadicalTwoHands

\u{2f36}: '⼶'

KangxiRadicalShoot

\u{2f37}: '⼷'

KangxiRadicalBow

\u{2f38}: '⼸'

KangxiRadicalSnout

\u{2f39}: '⼹'

KangxiRadicalBristle

\u{2f3a}: '⼺'

KangxiRadicalStep

\u{2f3b}: '⼻'

KangxiRadicalHeart

\u{2f3c}: '⼼'

KangxiRadicalHalberd

\u{2f3d}: '⼽'

KangxiRadicalDoor

\u{2f3e}: '⼾'

KangxiRadicalHand

\u{2f3f}: '⼿'

KangxiRadicalBranch

\u{2f40}: '⽀'

KangxiRadicalRap

\u{2f41}: '⽁'

KangxiRadicalScript

\u{2f42}: '⽂'

KangxiRadicalDipper

\u{2f43}: '⽃'

KangxiRadicalAxe

\u{2f44}: '⽄'

KangxiRadicalSquare

\u{2f45}: '⽅'

KangxiRadicalNot

\u{2f46}: '⽆'

KangxiRadicalSun

\u{2f47}: '⽇'

KangxiRadicalSay

\u{2f48}: '⽈'

KangxiRadicalMoon

\u{2f49}: '⽉'

KangxiRadicalTree

\u{2f4a}: '⽊'

KangxiRadicalLack

\u{2f4b}: '⽋'

KangxiRadicalStop

\u{2f4c}: '⽌'

KangxiRadicalDeath

\u{2f4d}: '⽍'

KangxiRadicalWeapon

\u{2f4e}: '⽎'

KangxiRadicalDoNot

\u{2f4f}: '⽏'

KangxiRadicalCompare

\u{2f50}: '⽐'

KangxiRadicalFur

\u{2f51}: '⽑'

KangxiRadicalClan

\u{2f52}: '⽒'

KangxiRadicalSteam

\u{2f53}: '⽓'

KangxiRadicalWater

\u{2f54}: '⽔'

KangxiRadicalFire

\u{2f55}: '⽕'

KangxiRadicalClaw

\u{2f56}: '⽖'

KangxiRadicalFather

\u{2f57}: '⽗'

KangxiRadicalDoubleX

\u{2f58}: '⽘'

KangxiRadicalHalfTreeTrunk

\u{2f59}: '⽙'

KangxiRadicalSlice

\u{2f5a}: '⽚'

KangxiRadicalFang

\u{2f5b}: '⽛'

KangxiRadicalCow

\u{2f5c}: '⽜'

KangxiRadicalDog

\u{2f5d}: '⽝'

KangxiRadicalProfound

\u{2f5e}: '⽞'

KangxiRadicalJade

\u{2f5f}: '⽟'

KangxiRadicalMelon

\u{2f60}: '⽠'

KangxiRadicalTile

\u{2f61}: '⽡'

KangxiRadicalSweet

\u{2f62}: '⽢'

KangxiRadicalLife

\u{2f63}: '⽣'

KangxiRadicalUse

\u{2f64}: '⽤'

KangxiRadicalField

\u{2f65}: '⽥'

KangxiRadicalBoltOfCloth

\u{2f66}: '⽦'

KangxiRadicalSickness

\u{2f67}: '⽧'

KangxiRadicalDottedTent

\u{2f68}: '⽨'

KangxiRadicalWhite

\u{2f69}: '⽩'

KangxiRadicalSkin

\u{2f6a}: '⽪'

KangxiRadicalDish

\u{2f6b}: '⽫'

KangxiRadicalEye

\u{2f6c}: '⽬'

KangxiRadicalSpear

\u{2f6d}: '⽭'

KangxiRadicalArrow

\u{2f6e}: '⽮'

KangxiRadicalStone

\u{2f6f}: '⽯'

KangxiRadicalSpirit

\u{2f70}: '⽰'

KangxiRadicalTrack

\u{2f71}: '⽱'

KangxiRadicalGrain

\u{2f72}: '⽲'

KangxiRadicalCave

\u{2f73}: '⽳'

KangxiRadicalStand

\u{2f74}: '⽴'

KangxiRadicalBamboo

\u{2f75}: '⽵'

KangxiRadicalRice

\u{2f76}: '⽶'

KangxiRadicalSilk

\u{2f77}: '⽷'

KangxiRadicalJar

\u{2f78}: '⽸'

KangxiRadicalNet

\u{2f79}: '⽹'

KangxiRadicalSheep

\u{2f7a}: '⽺'

KangxiRadicalFeather

\u{2f7b}: '⽻'

KangxiRadicalOld

\u{2f7c}: '⽼'

KangxiRadicalAnd

\u{2f7d}: '⽽'

KangxiRadicalPlow

\u{2f7e}: '⽾'

KangxiRadicalEar

\u{2f7f}: '⽿'

KangxiRadicalBrush

\u{2f80}: '⾀'

KangxiRadicalMeat

\u{2f81}: '⾁'

KangxiRadicalMinister

\u{2f82}: '⾂'

KangxiRadicalSelf

\u{2f83}: '⾃'

KangxiRadicalArrive

\u{2f84}: '⾄'

KangxiRadicalMortar

\u{2f85}: '⾅'

KangxiRadicalTongue

\u{2f86}: '⾆'

KangxiRadicalOppose

\u{2f87}: '⾇'

KangxiRadicalBoat

\u{2f88}: '⾈'

KangxiRadicalStopping

\u{2f89}: '⾉'

KangxiRadicalColor

\u{2f8a}: '⾊'

KangxiRadicalGrass

\u{2f8b}: '⾋'

KangxiRadicalTiger

\u{2f8c}: '⾌'

KangxiRadicalInsect

\u{2f8d}: '⾍'

KangxiRadicalBlood

\u{2f8e}: '⾎'

KangxiRadicalWalkEnclosure

\u{2f8f}: '⾏'

KangxiRadicalClothes

\u{2f90}: '⾐'

KangxiRadicalWest

\u{2f91}: '⾑'

KangxiRadicalSee

\u{2f92}: '⾒'

KangxiRadicalHorn

\u{2f93}: '⾓'

KangxiRadicalSpeech

\u{2f94}: '⾔'

KangxiRadicalValley

\u{2f95}: '⾕'

KangxiRadicalBean

\u{2f96}: '⾖'

KangxiRadicalPig

\u{2f97}: '⾗'

KangxiRadicalBadger

\u{2f98}: '⾘'

KangxiRadicalShell

\u{2f99}: '⾙'

KangxiRadicalRed

\u{2f9a}: '⾚'

KangxiRadicalRun

\u{2f9b}: '⾛'

KangxiRadicalFoot

\u{2f9c}: '⾜'

KangxiRadicalBody

\u{2f9d}: '⾝'

KangxiRadicalCart

\u{2f9e}: '⾞'

KangxiRadicalBitter

\u{2f9f}: '⾟'

KangxiRadicalMorning

\u{2fa0}: '⾠'

KangxiRadicalWalk

\u{2fa1}: '⾡'

KangxiRadicalCity

\u{2fa2}: '⾢'

KangxiRadicalWine

\u{2fa3}: '⾣'

KangxiRadicalDistinguish

\u{2fa4}: '⾤'

KangxiRadicalVillage

\u{2fa5}: '⾥'

KangxiRadicalGold

\u{2fa6}: '⾦'

KangxiRadicalLong

\u{2fa7}: '⾧'

KangxiRadicalGate

\u{2fa8}: '⾨'

KangxiRadicalMound

\u{2fa9}: '⾩'

KangxiRadicalSlave

\u{2faa}: '⾪'

KangxiRadicalShortTailedBird

\u{2fab}: '⾫'

KangxiRadicalRain

\u{2fac}: '⾬'

KangxiRadicalBlue

\u{2fad}: '⾭'

KangxiRadicalWrong

\u{2fae}: '⾮'

KangxiRadicalFace

\u{2faf}: '⾯'

KangxiRadicalLeather

\u{2fb0}: '⾰'

KangxiRadicalTannedLeather

\u{2fb1}: '⾱'

KangxiRadicalLeek

\u{2fb2}: '⾲'

KangxiRadicalSound

\u{2fb3}: '⾳'

KangxiRadicalLeaf

\u{2fb4}: '⾴'

KangxiRadicalWind

\u{2fb5}: '⾵'

KangxiRadicalFly

\u{2fb6}: '⾶'

KangxiRadicalEat

\u{2fb7}: '⾷'

KangxiRadicalHead

\u{2fb8}: '⾸'

KangxiRadicalFragrant

\u{2fb9}: '⾹'

KangxiRadicalHorse

\u{2fba}: '⾺'

KangxiRadicalBone

\u{2fbb}: '⾻'

KangxiRadicalTall

\u{2fbc}: '⾼'

KangxiRadicalHair

\u{2fbd}: '⾽'

KangxiRadicalFight

\u{2fbe}: '⾾'

KangxiRadicalSacrificialWine

\u{2fbf}: '⾿'

KangxiRadicalCauldron

\u{2fc0}: '⿀'

KangxiRadicalGhost

\u{2fc1}: '⿁'

KangxiRadicalFish

\u{2fc2}: '⿂'

KangxiRadicalBird

\u{2fc3}: '⿃'

KangxiRadicalSalt

\u{2fc4}: '⿄'

KangxiRadicalDeer

\u{2fc5}: '⿅'

KangxiRadicalWheat

\u{2fc6}: '⿆'

KangxiRadicalHemp

\u{2fc7}: '⿇'

KangxiRadicalYellow

\u{2fc8}: '⿈'

KangxiRadicalMillet

\u{2fc9}: '⿉'

KangxiRadicalBlack

\u{2fca}: '⿊'

KangxiRadicalEmbroidery

\u{2fcb}: '⿋'

KangxiRadicalFrog

\u{2fcc}: '⿌'

KangxiRadicalTripod

\u{2fcd}: '⿍'

KangxiRadicalDrum

\u{2fce}: '⿎'

KangxiRadicalRat

\u{2fcf}: '⿏'

KangxiRadicalNose

\u{2fd0}: '⿐'

KangxiRadicalEven

\u{2fd1}: '⿑'

KangxiRadicalTooth

\u{2fd2}: '⿒'

KangxiRadicalDragon

\u{2fd3}: '⿓'

KangxiRadicalTurtle

\u{2fd4}: '⿔'

KangxiRadicalFlute

\u{2fd5}: '⿕'

Methods

impl KangxiRadicals

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 KangxiRadicals

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

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

Important traits for KangxiRadicals

impl Iterator for KangxiRadicals type Item = Self;

fn clone(&self) -> KangxiRadicals

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Into<char> for KangxiRadicals

fn into(self) -> char

Performs the conversion.

impl Into<u32> for KangxiRadicals

fn into(self) -> u32

Performs the conversion.

impl Eq for KangxiRadicals

impl Copy for KangxiRadicals

impl Hash for KangxiRadicals

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 KangxiRadicals

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

Formats the value using the given formatter.

impl TryFrom<char> for KangxiRadicals

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 KangxiRadicals

type Error = ()

The type returned in the event of a conversion error.

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

Performs the conversion.