Enum unicode_types::supplemental_arrows_c::SupplementalArrowsC

pub enum SupplementalArrowsC {
    LeftwardsArrowWithSmallTriangleArrowhead,
    UpwardsArrowWithSmallTriangleArrowhead,
    RightwardsArrowWithSmallTriangleArrowhead,
    DownwardsArrowWithSmallTriangleArrowhead,
    LeftwardsArrowWithMediumTriangleArrowhead,
    UpwardsArrowWithMediumTriangleArrowhead,
    RightwardsArrowWithMediumTriangleArrowhead,
    DownwardsArrowWithMediumTriangleArrowhead,
    LeftwardsArrowWithLargeTriangleArrowhead,
    UpwardsArrowWithLargeTriangleArrowhead,
    RightwardsArrowWithLargeTriangleArrowhead,
    DownwardsArrowWithLargeTriangleArrowhead,
    LeftwardsArrowWithSmallEquilateralArrowhead,
    UpwardsArrowWithSmallEquilateralArrowhead,
    RightwardsArrowWithSmallEquilateralArrowhead,
    DownwardsArrowWithSmallEquilateralArrowhead,
    LeftwardsArrowWithEquilateralArrowhead,
    UpwardsArrowWithEquilateralArrowhead,
    RightwardsArrowWithEquilateralArrowhead,
    DownwardsArrowWithEquilateralArrowhead,
    HeavyLeftwardsArrowWithEquilateralArrowhead,
    HeavyUpwardsArrowWithEquilateralArrowhead,
    HeavyRightwardsArrowWithEquilateralArrowhead,
    HeavyDownwardsArrowWithEquilateralArrowhead,
    HeavyLeftwardsArrowWithLargeEquilateralArrowhead,
    HeavyUpwardsArrowWithLargeEquilateralArrowhead,
    HeavyRightwardsArrowWithLargeEquilateralArrowhead,
    HeavyDownwardsArrowWithLargeEquilateralArrowhead,
    LeftwardsTriangleDashHeadedArrowWithNarrowShaft,
    UpwardsTriangleDashHeadedArrowWithNarrowShaft,
    RightwardsTriangleDashHeadedArrowWithNarrowShaft,
    DownwardsTriangleDashHeadedArrowWithNarrowShaft,
    LeftwardsTriangleDashHeadedArrowWithMediumShaft,
    UpwardsTriangleDashHeadedArrowWithMediumShaft,
    RightwardsTriangleDashHeadedArrowWithMediumShaft,
    DownwardsTriangleDashHeadedArrowWithMediumShaft,
    LeftwardsTriangleDashHeadedArrowWithBoldShaft,
    UpwardsTriangleDashHeadedArrowWithBoldShaft,
    RightwardsTriangleDashHeadedArrowWithBoldShaft,
    DownwardsTriangleDashHeadedArrowWithBoldShaft,
    LeftwardsTriangleDashHeadedArrowWithHeavyShaft,
    UpwardsTriangleDashHeadedArrowWithHeavyShaft,
    RightwardsTriangleDashHeadedArrowWithHeavyShaft,
    DownwardsTriangleDashHeadedArrowWithHeavyShaft,
    LeftwardsTriangleDashHeadedArrowWithVeryHeavyShaft,
    UpwardsTriangleDashHeadedArrowWithVeryHeavyShaft,
    RightwardsTriangleDashHeadedArrowWithVeryHeavyShaft,
    DownwardsTriangleDashHeadedArrowWithVeryHeavyShaft,
    LeftwardsFingerDashPostArrow,
    UpwardsFingerDashPostArrow,
    RightwardsFingerDashPostArrow,
    DownwardsFingerDashPostArrow,
    LeftwardsSquaredArrow,
    UpwardsSquaredArrow,
    RightwardsSquaredArrow,
    DownwardsSquaredArrow,
    LeftwardsCompressedArrow,
    UpwardsCompressedArrow,
    RightwardsCompressedArrow,
    DownwardsCompressedArrow,
    LeftwardsHeavyCompressedArrow,
    UpwardsHeavyCompressedArrow,
    RightwardsHeavyCompressedArrow,
    DownwardsHeavyCompressedArrow,
    LeftwardsHeavyArrow,
    UpwardsHeavyArrow,
    RightwardsHeavyArrow,
    DownwardsHeavyArrow,
    LeftwardsSansDashSerifArrow,
    UpwardsSansDashSerifArrow,
    RightwardsSansDashSerifArrow,
    DownwardsSansDashSerifArrow,
    NorthWestSansDashSerifArrow,
    NorthEastSansDashSerifArrow,
    SouthEastSansDashSerifArrow,
    SouthWestSansDashSerifArrow,
    LeftRightSansDashSerifArrow,
    UpDownSansDashSerifArrow,
    WideDashHeadedLeftwardsLightBarbArrow,
    WideDashHeadedUpwardsLightBarbArrow,
    WideDashHeadedRightwardsLightBarbArrow,
    WideDashHeadedDownwardsLightBarbArrow,
    WideDashHeadedNorthWestLightBarbArrow,
    WideDashHeadedNorthEastLightBarbArrow,
    WideDashHeadedSouthEastLightBarbArrow,
    WideDashHeadedSouthWestLightBarbArrow,
    WideDashHeadedLeftwardsBarbArrow,
    WideDashHeadedUpwardsBarbArrow,
    WideDashHeadedRightwardsBarbArrow,
    WideDashHeadedDownwardsBarbArrow,
    WideDashHeadedNorthWestBarbArrow,
    WideDashHeadedNorthEastBarbArrow,
    WideDashHeadedSouthEastBarbArrow,
    WideDashHeadedSouthWestBarbArrow,
    WideDashHeadedLeftwardsMediumBarbArrow,
    WideDashHeadedUpwardsMediumBarbArrow,
    WideDashHeadedRightwardsMediumBarbArrow,
    WideDashHeadedDownwardsMediumBarbArrow,
    WideDashHeadedNorthWestMediumBarbArrow,
    WideDashHeadedNorthEastMediumBarbArrow,
    WideDashHeadedSouthEastMediumBarbArrow,
    WideDashHeadedSouthWestMediumBarbArrow,
    WideDashHeadedLeftwardsHeavyBarbArrow,
    WideDashHeadedUpwardsHeavyBarbArrow,
    WideDashHeadedRightwardsHeavyBarbArrow,
    WideDashHeadedDownwardsHeavyBarbArrow,
    WideDashHeadedNorthWestHeavyBarbArrow,
    WideDashHeadedNorthEastHeavyBarbArrow,
    WideDashHeadedSouthEastHeavyBarbArrow,
    WideDashHeadedSouthWestHeavyBarbArrow,
    WideDashHeadedLeftwardsVeryHeavyBarbArrow,
    WideDashHeadedUpwardsVeryHeavyBarbArrow,
    WideDashHeadedRightwardsVeryHeavyBarbArrow,
    WideDashHeadedDownwardsVeryHeavyBarbArrow,
    WideDashHeadedNorthWestVeryHeavyBarbArrow,
    WideDashHeadedNorthEastVeryHeavyBarbArrow,
    WideDashHeadedSouthEastVeryHeavyBarbArrow,
    WideDashHeadedSouthWestVeryHeavyBarbArrow,
    LeftwardsTriangleArrowhead,
    UpwardsTriangleArrowhead,
    RightwardsTriangleArrowhead,
    DownwardsTriangleArrowhead,
    LeftwardsWhiteArrowWithinTriangleArrowhead,
    UpwardsWhiteArrowWithinTriangleArrowhead,
    RightwardsWhiteArrowWithinTriangleArrowhead,
    DownwardsWhiteArrowWithinTriangleArrowhead,
    LeftwardsArrowWithNotchedTail,
    UpwardsArrowWithNotchedTail,
    RightwardsArrowWithNotchedTail,
    DownwardsArrowWithNotchedTail,
    HeavyArrowShaftWidthOne,
    HeavyArrowShaftWidthTwoThirds,
    HeavyArrowShaftWidthOneHalf,
    HeavyArrowShaftWidthOneThird,
    LeftwardsBottomDashShadedWhiteArrow,
    RightwardsBottomShadedWhiteArrow,
    LeftwardsTopShadedWhiteArrow,
    RightwardsTopShadedWhiteArrow,
    LeftwardsLeftDashShadedWhiteArrow,
    RightwardsRightDashShadedWhiteArrow,
    LeftwardsRightDashShadedWhiteArrow,
    RightwardsLeftDashShadedWhiteArrow,
    LeftwardsBackDashTiltedShadowedWhiteArrow,
    RightwardsBackDashTiltedShadowedWhiteArrow,
    LeftwardsFrontDashTiltedShadowedWhiteArrow,
    RightwardsFrontDashTiltedShadowedWhiteArrow,
    WhiteArrowShaftWidthOne,
    WhiteArrowShaftWidthTwoThirds,
}

An enum to represent all characters in the SupplementalArrowsC block.

Variants

LeftwardsArrowWithSmallTriangleArrowhead

\u{1f800}: '🠀'

UpwardsArrowWithSmallTriangleArrowhead

\u{1f801}: '🠁'

RightwardsArrowWithSmallTriangleArrowhead

\u{1f802}: '🠂'

DownwardsArrowWithSmallTriangleArrowhead

\u{1f803}: '🠃'

LeftwardsArrowWithMediumTriangleArrowhead

\u{1f804}: '🠄'

UpwardsArrowWithMediumTriangleArrowhead

\u{1f805}: '🠅'

RightwardsArrowWithMediumTriangleArrowhead

\u{1f806}: '🠆'

DownwardsArrowWithMediumTriangleArrowhead

\u{1f807}: '🠇'

LeftwardsArrowWithLargeTriangleArrowhead

\u{1f808}: '🠈'

UpwardsArrowWithLargeTriangleArrowhead

\u{1f809}: '🠉'

RightwardsArrowWithLargeTriangleArrowhead

\u{1f80a}: '🠊'

DownwardsArrowWithLargeTriangleArrowhead

\u{1f80b}: '🠋'

LeftwardsArrowWithSmallEquilateralArrowhead

\u{1f810}: '🠐'

UpwardsArrowWithSmallEquilateralArrowhead

\u{1f811}: '🠑'

RightwardsArrowWithSmallEquilateralArrowhead

\u{1f812}: '🠒'

DownwardsArrowWithSmallEquilateralArrowhead

\u{1f813}: '🠓'

LeftwardsArrowWithEquilateralArrowhead

\u{1f814}: '🠔'

UpwardsArrowWithEquilateralArrowhead

\u{1f815}: '🠕'

RightwardsArrowWithEquilateralArrowhead

\u{1f816}: '🠖'

DownwardsArrowWithEquilateralArrowhead

\u{1f817}: '🠗'

HeavyLeftwardsArrowWithEquilateralArrowhead

\u{1f818}: '🠘'

HeavyUpwardsArrowWithEquilateralArrowhead

\u{1f819}: '🠙'

HeavyRightwardsArrowWithEquilateralArrowhead

\u{1f81a}: '🠚'

HeavyDownwardsArrowWithEquilateralArrowhead

\u{1f81b}: '🠛'

HeavyLeftwardsArrowWithLargeEquilateralArrowhead

\u{1f81c}: '🠜'

HeavyUpwardsArrowWithLargeEquilateralArrowhead

\u{1f81d}: '🠝'

HeavyRightwardsArrowWithLargeEquilateralArrowhead

\u{1f81e}: '🠞'

HeavyDownwardsArrowWithLargeEquilateralArrowhead

\u{1f81f}: '🠟'

LeftwardsTriangleDashHeadedArrowWithNarrowShaft

\u{1f820}: '🠠'

UpwardsTriangleDashHeadedArrowWithNarrowShaft

\u{1f821}: '🠡'

RightwardsTriangleDashHeadedArrowWithNarrowShaft

\u{1f822}: '🠢'

DownwardsTriangleDashHeadedArrowWithNarrowShaft

\u{1f823}: '🠣'

LeftwardsTriangleDashHeadedArrowWithMediumShaft

\u{1f824}: '🠤'

UpwardsTriangleDashHeadedArrowWithMediumShaft

\u{1f825}: '🠥'

RightwardsTriangleDashHeadedArrowWithMediumShaft

\u{1f826}: '🠦'

DownwardsTriangleDashHeadedArrowWithMediumShaft

\u{1f827}: '🠧'

LeftwardsTriangleDashHeadedArrowWithBoldShaft

\u{1f828}: '🠨'

UpwardsTriangleDashHeadedArrowWithBoldShaft

\u{1f829}: '🠩'

RightwardsTriangleDashHeadedArrowWithBoldShaft

\u{1f82a}: '🠪'

DownwardsTriangleDashHeadedArrowWithBoldShaft

\u{1f82b}: '🠫'

LeftwardsTriangleDashHeadedArrowWithHeavyShaft

\u{1f82c}: '🠬'

UpwardsTriangleDashHeadedArrowWithHeavyShaft

\u{1f82d}: '🠭'

RightwardsTriangleDashHeadedArrowWithHeavyShaft

\u{1f82e}: '🠮'

DownwardsTriangleDashHeadedArrowWithHeavyShaft

\u{1f82f}: '🠯'

LeftwardsTriangleDashHeadedArrowWithVeryHeavyShaft

\u{1f830}: '🠰'

UpwardsTriangleDashHeadedArrowWithVeryHeavyShaft

\u{1f831}: '🠱'

RightwardsTriangleDashHeadedArrowWithVeryHeavyShaft

\u{1f832}: '🠲'

DownwardsTriangleDashHeadedArrowWithVeryHeavyShaft

\u{1f833}: '🠳'

LeftwardsFingerDashPostArrow

\u{1f834}: '🠴'

UpwardsFingerDashPostArrow

\u{1f835}: '🠵'

RightwardsFingerDashPostArrow

\u{1f836}: '🠶'

DownwardsFingerDashPostArrow

\u{1f837}: '🠷'

LeftwardsSquaredArrow

\u{1f838}: '🠸'

UpwardsSquaredArrow

\u{1f839}: '🠹'

RightwardsSquaredArrow

\u{1f83a}: '🠺'

DownwardsSquaredArrow

\u{1f83b}: '🠻'

LeftwardsCompressedArrow

\u{1f83c}: '🠼'

UpwardsCompressedArrow

\u{1f83d}: '🠽'

RightwardsCompressedArrow

\u{1f83e}: '🠾'

DownwardsCompressedArrow

\u{1f83f}: '🠿'

LeftwardsHeavyCompressedArrow

\u{1f840}: '🡀'

UpwardsHeavyCompressedArrow

\u{1f841}: '🡁'

RightwardsHeavyCompressedArrow

\u{1f842}: '🡂'

DownwardsHeavyCompressedArrow

\u{1f843}: '🡃'

LeftwardsHeavyArrow

\u{1f844}: '🡄'

UpwardsHeavyArrow

\u{1f845}: '🡅'

RightwardsHeavyArrow

\u{1f846}: '🡆'

DownwardsHeavyArrow

\u{1f847}: '🡇'

LeftwardsSansDashSerifArrow

\u{1f850}: '🡐'

UpwardsSansDashSerifArrow

\u{1f851}: '🡑'

RightwardsSansDashSerifArrow

\u{1f852}: '🡒'

DownwardsSansDashSerifArrow

\u{1f853}: '🡓'

NorthWestSansDashSerifArrow

\u{1f854}: '🡔'

NorthEastSansDashSerifArrow

\u{1f855}: '🡕'

SouthEastSansDashSerifArrow

\u{1f856}: '🡖'

SouthWestSansDashSerifArrow

\u{1f857}: '🡗'

LeftRightSansDashSerifArrow

\u{1f858}: '🡘'

UpDownSansDashSerifArrow

\u{1f859}: '🡙'

WideDashHeadedLeftwardsLightBarbArrow

\u{1f860}: '🡠'

WideDashHeadedUpwardsLightBarbArrow

\u{1f861}: '🡡'

WideDashHeadedRightwardsLightBarbArrow

\u{1f862}: '🡢'

WideDashHeadedDownwardsLightBarbArrow

\u{1f863}: '🡣'

WideDashHeadedNorthWestLightBarbArrow

\u{1f864}: '🡤'

WideDashHeadedNorthEastLightBarbArrow

\u{1f865}: '🡥'

WideDashHeadedSouthEastLightBarbArrow

\u{1f866}: '🡦'

WideDashHeadedSouthWestLightBarbArrow

\u{1f867}: '🡧'

WideDashHeadedLeftwardsBarbArrow

\u{1f868}: '🡨'

WideDashHeadedUpwardsBarbArrow

\u{1f869}: '🡩'

WideDashHeadedRightwardsBarbArrow

\u{1f86a}: '🡪'

WideDashHeadedDownwardsBarbArrow

\u{1f86b}: '🡫'

WideDashHeadedNorthWestBarbArrow

\u{1f86c}: '🡬'

WideDashHeadedNorthEastBarbArrow

\u{1f86d}: '🡭'

WideDashHeadedSouthEastBarbArrow

\u{1f86e}: '🡮'

WideDashHeadedSouthWestBarbArrow

\u{1f86f}: '🡯'

WideDashHeadedLeftwardsMediumBarbArrow

\u{1f870}: '🡰'

WideDashHeadedUpwardsMediumBarbArrow

\u{1f871}: '🡱'

WideDashHeadedRightwardsMediumBarbArrow

\u{1f872}: '🡲'

WideDashHeadedDownwardsMediumBarbArrow

\u{1f873}: '🡳'

WideDashHeadedNorthWestMediumBarbArrow

\u{1f874}: '🡴'

WideDashHeadedNorthEastMediumBarbArrow

\u{1f875}: '🡵'

WideDashHeadedSouthEastMediumBarbArrow

\u{1f876}: '🡶'

WideDashHeadedSouthWestMediumBarbArrow

\u{1f877}: '🡷'

WideDashHeadedLeftwardsHeavyBarbArrow

\u{1f878}: '🡸'

WideDashHeadedUpwardsHeavyBarbArrow

\u{1f879}: '🡹'

WideDashHeadedRightwardsHeavyBarbArrow

\u{1f87a}: '🡺'

WideDashHeadedDownwardsHeavyBarbArrow

\u{1f87b}: '🡻'

WideDashHeadedNorthWestHeavyBarbArrow

\u{1f87c}: '🡼'

WideDashHeadedNorthEastHeavyBarbArrow

\u{1f87d}: '🡽'

WideDashHeadedSouthEastHeavyBarbArrow

\u{1f87e}: '🡾'

WideDashHeadedSouthWestHeavyBarbArrow

\u{1f87f}: '🡿'

WideDashHeadedLeftwardsVeryHeavyBarbArrow

\u{1f880}: '🢀'

WideDashHeadedUpwardsVeryHeavyBarbArrow

\u{1f881}: '🢁'

WideDashHeadedRightwardsVeryHeavyBarbArrow

\u{1f882}: '🢂'

WideDashHeadedDownwardsVeryHeavyBarbArrow

\u{1f883}: '🢃'

WideDashHeadedNorthWestVeryHeavyBarbArrow

\u{1f884}: '🢄'

WideDashHeadedNorthEastVeryHeavyBarbArrow

\u{1f885}: '🢅'

WideDashHeadedSouthEastVeryHeavyBarbArrow

\u{1f886}: '🢆'

WideDashHeadedSouthWestVeryHeavyBarbArrow

\u{1f887}: '🢇'

LeftwardsTriangleArrowhead

\u{1f890}: '🢐'

UpwardsTriangleArrowhead

\u{1f891}: '🢑'

RightwardsTriangleArrowhead

\u{1f892}: '🢒'

DownwardsTriangleArrowhead

\u{1f893}: '🢓'

LeftwardsWhiteArrowWithinTriangleArrowhead

\u{1f894}: '🢔'

UpwardsWhiteArrowWithinTriangleArrowhead

\u{1f895}: '🢕'

RightwardsWhiteArrowWithinTriangleArrowhead

\u{1f896}: '🢖'

DownwardsWhiteArrowWithinTriangleArrowhead

\u{1f897}: '🢗'

LeftwardsArrowWithNotchedTail

\u{1f898}: '🢘'

UpwardsArrowWithNotchedTail

\u{1f899}: '🢙'

RightwardsArrowWithNotchedTail

\u{1f89a}: '🢚'

DownwardsArrowWithNotchedTail

\u{1f89b}: '🢛'

HeavyArrowShaftWidthOne

\u{1f89c}: '🢜'

HeavyArrowShaftWidthTwoThirds

\u{1f89d}: '🢝'

HeavyArrowShaftWidthOneHalf

\u{1f89e}: '🢞'

HeavyArrowShaftWidthOneThird

\u{1f89f}: '🢟'

LeftwardsBottomDashShadedWhiteArrow

\u{1f8a0}: '🢠'

RightwardsBottomShadedWhiteArrow

\u{1f8a1}: '🢡'

LeftwardsTopShadedWhiteArrow

\u{1f8a2}: '🢢'

RightwardsTopShadedWhiteArrow

\u{1f8a3}: '🢣'

LeftwardsLeftDashShadedWhiteArrow

\u{1f8a4}: '🢤'

RightwardsRightDashShadedWhiteArrow

\u{1f8a5}: '🢥'

LeftwardsRightDashShadedWhiteArrow

\u{1f8a6}: '🢦'

RightwardsLeftDashShadedWhiteArrow

\u{1f8a7}: '🢧'

LeftwardsBackDashTiltedShadowedWhiteArrow

\u{1f8a8}: '🢨'

RightwardsBackDashTiltedShadowedWhiteArrow

\u{1f8a9}: '🢩'

LeftwardsFrontDashTiltedShadowedWhiteArrow

\u{1f8aa}: '🢪'

RightwardsFrontDashTiltedShadowedWhiteArrow

\u{1f8ab}: '🢫'

WhiteArrowShaftWidthOne

\u{1f8ac}: '🢬'

WhiteArrowShaftWidthTwoThirds

\u{1f8ad}: '🢭'

Methods

impl SupplementalArrowsC

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 Copy for SupplementalArrowsC

impl Iterator for SupplementalArrowsC

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, 

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

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

Important traits for SupplementalArrowsC

impl Iterator for SupplementalArrowsC type Item = Self;

fn clone(&self) -> SupplementalArrowsC

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Eq for SupplementalArrowsC

impl Into<char> for SupplementalArrowsC

fn into(self) -> char

Performs the conversion.

impl Into<u32> for SupplementalArrowsC

fn into(self) -> u32

Performs the conversion.

impl Debug for SupplementalArrowsC

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

Formats the value using the given formatter.

impl Hash for SupplementalArrowsC

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 TryFrom<char> for SupplementalArrowsC

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 SupplementalArrowsC

type Error = ()

The type returned in the event of a conversion error.

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

Performs the conversion.