Enum unicode_types::mathematical_operators::MathematicalOperators

pub enum MathematicalOperators {
    ForAll,
    Complement,
    PartialDifferential,
    ThereExists,
    ThereDoesNotExist,
    EmptySet,
    Increment,
    Nabla,
    ElementOf,
    NotAnElementOf,
    SmallElementOf,
    ContainsAsMember,
    DoesNotContainAsMember,
    SmallContainsAsMember,
    EndOfProof,
    NDashAryProduct,
    NDashAryCoproduct,
    NDashArySummation,
    MinusSign,
    MinusDashOrDashPlusSign,
    DotPlus,
    DivisionSlash,
    SetMinus,
    AsteriskOperator,
    RingOperator,
    BulletOperator,
    SquareRoot,
    CubeRoot,
    FourthRoot,
    ProportionalTo,
    Infinity,
    RightAngle,
    Angle,
    MeasuredAngle,
    SphericalAngle,
    Divides,
    DoesNotDivide,
    ParallelTo,
    NotParallelTo,
    LogicalAnd,
    LogicalOr,
    Intersection,
    Union,
    Integral,
    DoubleIntegral,
    TripleIntegral,
    ContourIntegral,
    SurfaceIntegral,
    VolumeIntegral,
    ClockwiseIntegral,
    ClockwiseContourIntegral,
    AnticlockwiseContourIntegral,
    Therefore,
    Because,
    Ratio,
    Proportion,
    DotMinus,
    Excess,
    GeometricProportion,
    Homothetic,
    TildeOperator,
    ReversedTilde,
    InvertedLazyS,
    SineWave,
    WreathProduct,
    NotTilde,
    MinusTilde,
    AsymptoticallyEqualTo,
    NotAsymptoticallyEqualTo,
    ApproximatelyEqualTo,
    ApproximatelyButNotActuallyEqualTo,
    NeitherApproximatelyNorActuallyEqualTo,
    AlmostEqualTo,
    NotAlmostEqualTo,
    AlmostEqualOrEqualTo,
    TripleTilde,
    AllEqualTo,
    EquivalentTo,
    GeometricallyEquivalentTo,
    DifferenceBetween,
    ApproachesTheLimit,
    GeometricallyEqualTo,
    ApproximatelyEqualToOrTheImageOf,
    ImageOfOrApproximatelyEqualTo,
    ColonEquals,
    EqualsColon,
    RingInEqualTo,
    RingEqualTo,
    CorrespondsTo,
    Estimates,
    EquiangularTo,
    StarEquals,
    DeltaEqualTo,
    EqualToByDefinition,
    MeasuredBy,
    QuestionedEqualTo,
    NotEqualTo,
    IdenticalTo,
    NotIdenticalTo,
    StrictlyEquivalentTo,
    LessDashThanOrEqualTo,
    GreaterDashThanOrEqualTo,
    LessDashThanOverEqualTo,
    GreaterDashThanOverEqualTo,
    LessDashThanButNotEqualTo,
    GreaterDashThanButNotEqualTo,
    MuchLessDashThan,
    MuchGreaterDashThan,
    Between,
    NotEquivalentTo,
    NotLessDashThan,
    NotGreaterDashThan,
    NeitherLessDashThanNorEqualTo,
    NeitherGreaterDashThanNorEqualTo,
    LessDashThanOrEquivalentTo,
    GreaterDashThanOrEquivalentTo,
    NeitherLessDashThanNorEquivalentTo,
    NeitherGreaterDashThanNorEquivalentTo,
    LessDashThanOrGreaterDashThan,
    GreaterDashThanOrLessDashThan,
    NeitherLessDashThanNorGreaterDashThan,
    NeitherGreaterDashThanNorLessDashThan,
    Precedes,
    Succeeds,
    PrecedesOrEqualTo,
    SucceedsOrEqualTo,
    PrecedesOrEquivalentTo,
    SucceedsOrEquivalentTo,
    DoesNotPrecede,
    DoesNotSucceed,
    SubsetOf,
    SupersetOf,
    NotASubsetOf,
    NotASupersetOf,
    SubsetOfOrEqualTo,
    SupersetOfOrEqualTo,
    NeitherASubsetOfNorEqualTo,
    NeitherASupersetOfNorEqualTo,
    SubsetOfWithNotEqualTo,
    SupersetOfWithNotEqualTo,
    Multiset,
    MultisetMultiplication,
    MultisetUnion,
    SquareImageOf,
    SquareOriginalOf,
    SquareImageOfOrEqualTo,
    SquareOriginalOfOrEqualTo,
    SquareCap,
    SquareCup,
    CircledPlus,
    CircledMinus,
    CircledTimes,
    CircledDivisionSlash,
    CircledDotOperator,
    CircledRingOperator,
    CircledAsteriskOperator,
    CircledEquals,
    CircledDash,
    SquaredPlus,
    SquaredMinus,
    SquaredTimes,
    SquaredDotOperator,
    RightTack,
    LeftTack,
    DownTack,
    UpTack,
    Assertion,
    Models,
    True,
    Forces,
    TripleVerticalBarRightTurnstile,
    DoubleVerticalBarDoubleRightTurnstile,
    DoesNotProve,
    NotTrue,
    DoesNotForce,
    NegatedDoubleVerticalBarDoubleRightTurnstile,
    PrecedesUnderRelation,
    SucceedsUnderRelation,
    NormalSubgroupOf,
    ContainsAsNormalSubgroup,
    NormalSubgroupOfOrEqualTo,
    ContainsAsNormalSubgroupOrEqualTo,
    OriginalOf,
    ImageOf,
    Multimap,
    HermitianConjugateMatrix,
    Intercalate,
    Xor,
    Nand,
    Nor,
    RightAngleWithArc,
    RightTriangle,
    NDashAryLogicalAnd,
    NDashAryLogicalOr,
    NDashAryIntersection,
    NDashAryUnion,
    DiamondOperator,
    DotOperator,
    StarOperator,
    DivisionTimes,
    Bowtie,
    LeftNormalFactorSemidirectProduct,
    RightNormalFactorSemidirectProduct,
    LeftSemidirectProduct,
    RightSemidirectProduct,
    ReversedTildeEquals,
    CurlyLogicalOr,
    CurlyLogicalAnd,
    DoubleSubset,
    DoubleSuperset,
    DoubleIntersection,
    DoubleUnion,
    Pitchfork,
    EqualAndParallelTo,
    LessDashThanWithDot,
    GreaterDashThanWithDot,
    VeryMuchLessDashThan,
    VeryMuchGreaterDashThan,
    LessDashThanEqualToOrGreaterDashThan,
    GreaterDashThanEqualToOrLessDashThan,
    EqualToOrLessDashThan,
    EqualToOrGreaterDashThan,
    EqualToOrPrecedes,
    EqualToOrSucceeds,
    DoesNotPrecedeOrEqual,
    DoesNotSucceedOrEqual,
    NotSquareImageOfOrEqualTo,
    NotSquareOriginalOfOrEqualTo,
    SquareImageOfOrNotEqualTo,
    SquareOriginalOfOrNotEqualTo,
    LessDashThanButNotEquivalentTo,
    GreaterDashThanButNotEquivalentTo,
    PrecedesButNotEquivalentTo,
    SucceedsButNotEquivalentTo,
    NotNormalSubgroupOf,
    DoesNotContainAsNormalSubgroup,
    NotNormalSubgroupOfOrEqualTo,
    DoesNotContainAsNormalSubgroupOrEqual,
    VerticalEllipsis,
    MidlineHorizontalEllipsis,
    UpRightDiagonalEllipsis,
    DownRightDiagonalEllipsis,
    ElementOfWithLongHorizontalStroke,
    ElementOfWithVerticalBarAtEndOfHorizontalStroke,
    SmallElementOfWithVerticalBarAtEndOfHorizontalStroke,
    ElementOfWithDotAbove,
    ElementOfWithOverbar,
    SmallElementOfWithOverbar,
    ElementOfWithUnderbar,
    ElementOfWithTwoHorizontalStrokes,
    ContainsWithLongHorizontalStroke,
    ContainsWithVerticalBarAtEndOfHorizontalStroke,
    SmallContainsWithVerticalBarAtEndOfHorizontalStroke,
    ContainsWithOverbar,
    SmallContainsWithOverbar,
}

An enum to represent all characters in the MathematicalOperators block.

Variants

ForAll

\u{2200}: '∀'

Complement

\u{2201}: '∁'

PartialDifferential

\u{2202}: '∂'

ThereExists

\u{2203}: '∃'

ThereDoesNotExist

\u{2204}: '∄'

EmptySet

\u{2205}: '∅'

Increment

\u{2206}: '∆'

Nabla

\u{2207}: '∇'

ElementOf

\u{2208}: '∈'

NotAnElementOf

\u{2209}: '∉'

SmallElementOf

\u{220a}: '∊'

ContainsAsMember

\u{220b}: '∋'

DoesNotContainAsMember

\u{220c}: '∌'

SmallContainsAsMember

\u{220d}: '∍'

EndOfProof

\u{220e}: '∎'

NDashAryProduct

\u{220f}: '∏'

NDashAryCoproduct

\u{2210}: '∐'

NDashArySummation

\u{2211}: '∑'

MinusSign

\u{2212}: '−'

MinusDashOrDashPlusSign

\u{2213}: '∓'

DotPlus

\u{2214}: '∔'

DivisionSlash

\u{2215}: '∕'

SetMinus

\u{2216}: '∖'

AsteriskOperator

\u{2217}: '∗'

RingOperator

\u{2218}: '∘'

BulletOperator

\u{2219}: '∙'

SquareRoot

\u{221a}: '√'

CubeRoot

\u{221b}: '∛'

FourthRoot

\u{221c}: '∜'

ProportionalTo

\u{221d}: '∝'

Infinity

\u{221e}: '∞'

RightAngle

\u{221f}: '∟'

Angle

\u{2220}: '∠'

MeasuredAngle

\u{2221}: '∡'

SphericalAngle

\u{2222}: '∢'

Divides

\u{2223}: '∣'

DoesNotDivide

\u{2224}: '∤'

ParallelTo

\u{2225}: '∥'

NotParallelTo

\u{2226}: '∦'

LogicalAnd

\u{2227}: '∧'

LogicalOr

\u{2228}: '∨'

Intersection

\u{2229}: '∩'

Union

\u{222a}: '∪'

Integral

\u{222b}: '∫'

DoubleIntegral

\u{222c}: '∬'

TripleIntegral

\u{222d}: '∭'

ContourIntegral

\u{222e}: '∮'

SurfaceIntegral

\u{222f}: '∯'

VolumeIntegral

\u{2230}: '∰'

ClockwiseIntegral

\u{2231}: '∱'

ClockwiseContourIntegral

\u{2232}: '∲'

AnticlockwiseContourIntegral

\u{2233}: '∳'

Therefore

\u{2234}: '∴'

Because

\u{2235}: '∵'

Ratio

\u{2236}: '∶'

Proportion

\u{2237}: '∷'

DotMinus

\u{2238}: '∸'

Excess

\u{2239}: '∹'

GeometricProportion

\u{223a}: '∺'

Homothetic

\u{223b}: '∻'

TildeOperator

\u{223c}: '∼'

ReversedTilde

\u{223d}: '∽'

InvertedLazyS

\u{223e}: '∾'

SineWave

\u{223f}: '∿'

WreathProduct

\u{2240}: '≀'

NotTilde

\u{2241}: '≁'

MinusTilde

\u{2242}: '≂'

AsymptoticallyEqualTo

\u{2243}: '≃'

NotAsymptoticallyEqualTo

\u{2244}: '≄'

ApproximatelyEqualTo

\u{2245}: '≅'

ApproximatelyButNotActuallyEqualTo

\u{2246}: '≆'

NeitherApproximatelyNorActuallyEqualTo

\u{2247}: '≇'

AlmostEqualTo

\u{2248}: '≈'

NotAlmostEqualTo

\u{2249}: '≉'

AlmostEqualOrEqualTo

\u{224a}: '≊'

TripleTilde

\u{224b}: '≋'

AllEqualTo

\u{224c}: '≌'

EquivalentTo

\u{224d}: '≍'

GeometricallyEquivalentTo

\u{224e}: '≎'

DifferenceBetween

\u{224f}: '≏'

ApproachesTheLimit

\u{2250}: '≐'

GeometricallyEqualTo

\u{2251}: '≑'

ApproximatelyEqualToOrTheImageOf

\u{2252}: '≒'

ImageOfOrApproximatelyEqualTo

\u{2253}: '≓'

ColonEquals

\u{2254}: '≔'

EqualsColon

\u{2255}: '≕'

RingInEqualTo

\u{2256}: '≖'

RingEqualTo

\u{2257}: '≗'

CorrespondsTo

\u{2258}: '≘'

Estimates

\u{2259}: '≙'

EquiangularTo

\u{225a}: '≚'

StarEquals

\u{225b}: '≛'

DeltaEqualTo

\u{225c}: '≜'

EqualToByDefinition

\u{225d}: '≝'

MeasuredBy

\u{225e}: '≞'

QuestionedEqualTo

\u{225f}: '≟'

NotEqualTo

\u{2260}: '≠'

IdenticalTo

\u{2261}: '≡'

NotIdenticalTo

\u{2262}: '≢'

StrictlyEquivalentTo

\u{2263}: '≣'

LessDashThanOrEqualTo

\u{2264}: '≤'

GreaterDashThanOrEqualTo

\u{2265}: '≥'

LessDashThanOverEqualTo

\u{2266}: '≦'

GreaterDashThanOverEqualTo

\u{2267}: '≧'

LessDashThanButNotEqualTo

\u{2268}: '≨'

GreaterDashThanButNotEqualTo

\u{2269}: '≩'

MuchLessDashThan

\u{226a}: '≪'

MuchGreaterDashThan

\u{226b}: '≫'

Between

\u{226c}: '≬'

NotEquivalentTo

\u{226d}: '≭'

NotLessDashThan

\u{226e}: '≮'

NotGreaterDashThan

\u{226f}: '≯'

NeitherLessDashThanNorEqualTo

\u{2270}: '≰'

NeitherGreaterDashThanNorEqualTo

\u{2271}: '≱'

LessDashThanOrEquivalentTo

\u{2272}: '≲'

GreaterDashThanOrEquivalentTo

\u{2273}: '≳'

NeitherLessDashThanNorEquivalentTo

\u{2274}: '≴'

NeitherGreaterDashThanNorEquivalentTo

\u{2275}: '≵'

LessDashThanOrGreaterDashThan

\u{2276}: '≶'

GreaterDashThanOrLessDashThan

\u{2277}: '≷'

NeitherLessDashThanNorGreaterDashThan

\u{2278}: '≸'

NeitherGreaterDashThanNorLessDashThan

\u{2279}: '≹'

Precedes

\u{227a}: '≺'

Succeeds

\u{227b}: '≻'

PrecedesOrEqualTo

\u{227c}: '≼'

SucceedsOrEqualTo

\u{227d}: '≽'

PrecedesOrEquivalentTo

\u{227e}: '≾'

SucceedsOrEquivalentTo

\u{227f}: '≿'

DoesNotPrecede

\u{2280}: '⊀'

DoesNotSucceed

\u{2281}: '⊁'

SubsetOf

\u{2282}: '⊂'

SupersetOf

\u{2283}: '⊃'

NotASubsetOf

\u{2284}: '⊄'

NotASupersetOf

\u{2285}: '⊅'

SubsetOfOrEqualTo

\u{2286}: '⊆'

SupersetOfOrEqualTo

\u{2287}: '⊇'

NeitherASubsetOfNorEqualTo

\u{2288}: '⊈'

NeitherASupersetOfNorEqualTo

\u{2289}: '⊉'

SubsetOfWithNotEqualTo

\u{228a}: '⊊'

SupersetOfWithNotEqualTo

\u{228b}: '⊋'

Multiset

\u{228c}: '⊌'

MultisetMultiplication

\u{228d}: '⊍'

MultisetUnion

\u{228e}: '⊎'

SquareImageOf

\u{228f}: '⊏'

SquareOriginalOf

\u{2290}: '⊐'

SquareImageOfOrEqualTo

\u{2291}: '⊑'

SquareOriginalOfOrEqualTo

\u{2292}: '⊒'

SquareCap

\u{2293}: '⊓'

SquareCup

\u{2294}: '⊔'

CircledPlus

\u{2295}: '⊕'

CircledMinus

\u{2296}: '⊖'

CircledTimes

\u{2297}: '⊗'

CircledDivisionSlash

\u{2298}: '⊘'

CircledDotOperator

\u{2299}: '⊙'

CircledRingOperator

\u{229a}: '⊚'

CircledAsteriskOperator

\u{229b}: '⊛'

CircledEquals

\u{229c}: '⊜'

CircledDash

\u{229d}: '⊝'

SquaredPlus

\u{229e}: '⊞'

SquaredMinus

\u{229f}: '⊟'

SquaredTimes

\u{22a0}: '⊠'

SquaredDotOperator

\u{22a1}: '⊡'

RightTack

\u{22a2}: '⊢'

LeftTack

\u{22a3}: '⊣'

DownTack

\u{22a4}: '⊤'

UpTack

\u{22a5}: '⊥'

Assertion

\u{22a6}: '⊦'

Models

\u{22a7}: '⊧'

True

\u{22a8}: '⊨'

Forces

\u{22a9}: '⊩'

TripleVerticalBarRightTurnstile

\u{22aa}: '⊪'

DoubleVerticalBarDoubleRightTurnstile

\u{22ab}: '⊫'

DoesNotProve

\u{22ac}: '⊬'

NotTrue

\u{22ad}: '⊭'

DoesNotForce

\u{22ae}: '⊮'

NegatedDoubleVerticalBarDoubleRightTurnstile

\u{22af}: '⊯'

PrecedesUnderRelation

\u{22b0}: '⊰'

SucceedsUnderRelation

\u{22b1}: '⊱'

NormalSubgroupOf

\u{22b2}: '⊲'

ContainsAsNormalSubgroup

\u{22b3}: '⊳'

NormalSubgroupOfOrEqualTo

\u{22b4}: '⊴'

ContainsAsNormalSubgroupOrEqualTo

\u{22b5}: '⊵'

OriginalOf

\u{22b6}: '⊶'

ImageOf

\u{22b7}: '⊷'

Multimap

\u{22b8}: '⊸'

HermitianConjugateMatrix

\u{22b9}: '⊹'

Intercalate

\u{22ba}: '⊺'

Xor

\u{22bb}: '⊻'

Nand

\u{22bc}: '⊼'

Nor

\u{22bd}: '⊽'

RightAngleWithArc

\u{22be}: '⊾'

RightTriangle

\u{22bf}: '⊿'

NDashAryLogicalAnd

\u{22c0}: '⋀'

NDashAryLogicalOr

\u{22c1}: '⋁'

NDashAryIntersection

\u{22c2}: '⋂'

NDashAryUnion

\u{22c3}: '⋃'

DiamondOperator

\u{22c4}: '⋄'

DotOperator

\u{22c5}: '⋅'

StarOperator

\u{22c6}: '⋆'

DivisionTimes

\u{22c7}: '⋇'

Bowtie

\u{22c8}: '⋈'

LeftNormalFactorSemidirectProduct

\u{22c9}: '⋉'

RightNormalFactorSemidirectProduct

\u{22ca}: '⋊'

LeftSemidirectProduct

\u{22cb}: '⋋'

RightSemidirectProduct

\u{22cc}: '⋌'

ReversedTildeEquals

\u{22cd}: '⋍'

CurlyLogicalOr

\u{22ce}: '⋎'

CurlyLogicalAnd

\u{22cf}: '⋏'

DoubleSubset

\u{22d0}: '⋐'

DoubleSuperset

\u{22d1}: '⋑'

DoubleIntersection

\u{22d2}: '⋒'

DoubleUnion

\u{22d3}: '⋓'

Pitchfork

\u{22d4}: '⋔'

EqualAndParallelTo

\u{22d5}: '⋕'

LessDashThanWithDot

\u{22d6}: '⋖'

GreaterDashThanWithDot

\u{22d7}: '⋗'

VeryMuchLessDashThan

\u{22d8}: '⋘'

VeryMuchGreaterDashThan

\u{22d9}: '⋙'

LessDashThanEqualToOrGreaterDashThan

\u{22da}: '⋚'

GreaterDashThanEqualToOrLessDashThan

\u{22db}: '⋛'

EqualToOrLessDashThan

\u{22dc}: '⋜'

EqualToOrGreaterDashThan

\u{22dd}: '⋝'

EqualToOrPrecedes

\u{22de}: '⋞'

EqualToOrSucceeds

\u{22df}: '⋟'

DoesNotPrecedeOrEqual

\u{22e0}: '⋠'

DoesNotSucceedOrEqual

\u{22e1}: '⋡'

NotSquareImageOfOrEqualTo

\u{22e2}: '⋢'

NotSquareOriginalOfOrEqualTo

\u{22e3}: '⋣'

SquareImageOfOrNotEqualTo

\u{22e4}: '⋤'

SquareOriginalOfOrNotEqualTo

\u{22e5}: '⋥'

LessDashThanButNotEquivalentTo

\u{22e6}: '⋦'

GreaterDashThanButNotEquivalentTo

\u{22e7}: '⋧'

PrecedesButNotEquivalentTo

\u{22e8}: '⋨'

SucceedsButNotEquivalentTo

\u{22e9}: '⋩'

NotNormalSubgroupOf

\u{22ea}: '⋪'

DoesNotContainAsNormalSubgroup

\u{22eb}: '⋫'

NotNormalSubgroupOfOrEqualTo

\u{22ec}: '⋬'

DoesNotContainAsNormalSubgroupOrEqual

\u{22ed}: '⋭'

VerticalEllipsis

\u{22ee}: '⋮'

MidlineHorizontalEllipsis

\u{22ef}: '⋯'

UpRightDiagonalEllipsis

\u{22f0}: '⋰'

DownRightDiagonalEllipsis

\u{22f1}: '⋱'

ElementOfWithLongHorizontalStroke

\u{22f2}: '⋲'

ElementOfWithVerticalBarAtEndOfHorizontalStroke

\u{22f3}: '⋳'

SmallElementOfWithVerticalBarAtEndOfHorizontalStroke

\u{22f4}: '⋴'

ElementOfWithDotAbove

\u{22f5}: '⋵'

ElementOfWithOverbar

\u{22f6}: '⋶'

SmallElementOfWithOverbar

\u{22f7}: '⋷'

ElementOfWithUnderbar

\u{22f8}: '⋸'

ElementOfWithTwoHorizontalStrokes

\u{22f9}: '⋹'

ContainsWithLongHorizontalStroke

\u{22fa}: '⋺'

ContainsWithVerticalBarAtEndOfHorizontalStroke

\u{22fb}: '⋻'

SmallContainsWithVerticalBarAtEndOfHorizontalStroke

\u{22fc}: '⋼'

ContainsWithOverbar

\u{22fd}: '⋽'

SmallContainsWithOverbar

\u{22fe}: '⋾'

Methods

impl MathematicalOperators

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 MathematicalOperators

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

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

Important traits for MathematicalOperators

impl Iterator for MathematicalOperators type Item = Self;

fn clone(&self) -> MathematicalOperators

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Into<char> for MathematicalOperators

fn into(self) -> char

Performs the conversion.

impl Into<u32> for MathematicalOperators

fn into(self) -> u32

Performs the conversion.

impl Eq for MathematicalOperators

impl Copy for MathematicalOperators

impl Hash for MathematicalOperators

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 MathematicalOperators

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

Formats the value using the given formatter.

impl TryFrom<char> for MathematicalOperators

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 MathematicalOperators

type Error = ()

The type returned in the event of a conversion error.

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

Performs the conversion.