ΛLogos

logos.lang.range

Module lang · package logos-lang

Traits

traitStep

trait Step

Provides the primitive stepping operations that range iterators require.

Implemented by: i32 i64 u32 u64

Types

structRangeFromI32

struct RangeFromI32

Iterates i32 values unboundedly from current; next() never returns None.

Implements: Iterator FusedIterator

Fields

current: i32

Methods

fn all(self: RangeFromI32, pred: AllFn) -> bool
fn any(self: RangeFromI32, pred: AnyFn) -> bool
fn chain(self: RangeFromI32, other: ChainOther) -> ChainIter<RangeFromI32, ChainOther, i32>
fn collect(self: RangeFromI32) -> C
fn contains(self: RangeFromI32, item: i32) -> bool

Returns true if item >= current.

fn count(self: RangeFromI32) -> i64
fn enumerate(self: RangeFromI32) -> EnumIter<RangeFromI32, i32>
fn filter(self: RangeFromI32, pred: fn(i32) -> bool) -> FilterIter<RangeFromI32, i32>
fn find(self: &mut RangeFromI32, pred: FindFn) -> Option
fn find_map(self: RangeFromI32, f: FindMapFn) -> Option
fn fold(self: RangeFromI32, init: Acc, f: FoldFn) -> Acc
fn for_each(self: RangeFromI32, f: EachFn) -> void
fn inspect(self: RangeFromI32, visit: fn(i32) -> void, zero: i32) -> InspectIter<RangeFromI32, i32>
fn last(self: RangeFromI32) -> Option
fn map(self: RangeFromI32, f: MapFn) -> MapIter<RangeFromI32, i32, MapOut, MapFn>
fn max(self: RangeFromI32) -> Option
fn max_by(self: RangeFromI32, cmp: fn(i32, i32) -> i32) -> Option
fn min(self: RangeFromI32) -> Option
fn min_by(self: RangeFromI32, cmp: fn(i32, i32) -> i32) -> Option
fn next(self: &mut RangeFromI32) -> Option
fn nth(self: &mut RangeFromI32, n: i64) -> Option
fn peekable(self: RangeFromI32) -> PeekableIter<RangeFromI32, i32>
fn position(self: &mut RangeFromI32, pred: PosFn) -> Option
fn product(self: RangeFromI32) -> S
fn reduce(self: RangeFromI32, f: ReduceFn) -> Option
fn skip(self: RangeFromI32, n: i64) -> SkipIter<RangeFromI32, i32>
fn skip_while(self: RangeFromI32, pred: fn(i32) -> bool, zero: i32) -> SkipWhileIter<RangeFromI32, i32>
fn step_by(self: RangeFromI32, step: i64, zero: i32) -> StepByIter<RangeFromI32, i32>
fn sum(self: RangeFromI32) -> S
fn take(self: RangeFromI32, n: i64) -> TakeIter<RangeFromI32, i32>
fn take_while(self: RangeFromI32, pred: fn(i32) -> bool, zero: i32) -> TakeWhileIter<RangeFromI32, i32>
fn try_fold(self: RangeFromI32, init: Acc, f: TryFoldFn) -> ControlFlow
fn try_for_each(self: RangeFromI32, f: TryEachFn) -> ControlFlow
fn zip(self: RangeFromI32, other: ZipOther) -> ZipIter<RangeFromI32, ZipOther, i32, ZipOtherItem>

structRangeFromI64

struct RangeFromI64

Iterates i64 values unboundedly from current; next() never returns None.

Implements: Iterator FusedIterator

Fields

current: i64

Methods

fn all(self: RangeFromI64, pred: AllFn) -> bool
fn any(self: RangeFromI64, pred: AnyFn) -> bool
fn chain(self: RangeFromI64, other: ChainOther) -> ChainIter<RangeFromI64, ChainOther, i64>
fn collect(self: RangeFromI64) -> C
fn contains(self: RangeFromI64, item: i64) -> bool

Returns true if item >= current.

fn count(self: RangeFromI64) -> i64
fn enumerate(self: RangeFromI64) -> EnumIter<RangeFromI64, i64>
fn filter(self: RangeFromI64, pred: fn(i64) -> bool) -> FilterIter<RangeFromI64, i64>
fn find(self: &mut RangeFromI64, pred: FindFn) -> Option
fn find_map(self: RangeFromI64, f: FindMapFn) -> Option
fn fold(self: RangeFromI64, init: Acc, f: FoldFn) -> Acc
fn for_each(self: RangeFromI64, f: EachFn) -> void
fn inspect(self: RangeFromI64, visit: fn(i64) -> void, zero: i64) -> InspectIter<RangeFromI64, i64>
fn last(self: RangeFromI64) -> Option
fn map(self: RangeFromI64, f: MapFn) -> MapIter<RangeFromI64, i64, MapOut, MapFn>
fn max(self: RangeFromI64) -> Option
fn max_by(self: RangeFromI64, cmp: fn(i64, i64) -> i32) -> Option
fn min(self: RangeFromI64) -> Option
fn min_by(self: RangeFromI64, cmp: fn(i64, i64) -> i32) -> Option
fn next(self: &mut RangeFromI64) -> Option
fn nth(self: &mut RangeFromI64, n: i64) -> Option
fn peekable(self: RangeFromI64) -> PeekableIter<RangeFromI64, i64>
fn position(self: &mut RangeFromI64, pred: PosFn) -> Option
fn product(self: RangeFromI64) -> S
fn reduce(self: RangeFromI64, f: ReduceFn) -> Option
fn skip(self: RangeFromI64, n: i64) -> SkipIter<RangeFromI64, i64>
fn skip_while(self: RangeFromI64, pred: fn(i64) -> bool, zero: i64) -> SkipWhileIter<RangeFromI64, i64>
fn step_by(self: RangeFromI64, step: i64, zero: i64) -> StepByIter<RangeFromI64, i64>
fn sum(self: RangeFromI64) -> S
fn take(self: RangeFromI64, n: i64) -> TakeIter<RangeFromI64, i64>
fn take_while(self: RangeFromI64, pred: fn(i64) -> bool, zero: i64) -> TakeWhileIter<RangeFromI64, i64>
fn try_fold(self: RangeFromI64, init: Acc, f: TryFoldFn) -> ControlFlow
fn try_for_each(self: RangeFromI64, f: TryEachFn) -> ControlFlow
fn zip(self: RangeFromI64, other: ZipOther) -> ZipIter<RangeFromI64, ZipOther, i64, ZipOtherItem>

structRangeFull

struct RangeFull

Marks the full unbounded range (..); bound-less, carries no state.

structRangeI32

struct RangeI32

Iterates the half-open i32 range [current, end).

Implements: Iterator DoubleEndedIterator ExactSizeIterator FusedIterator

Fields

current: i32

Next value to yield.

end: i32

Exclusive upper bound.

Methods

fn all(self: RangeI32, pred: AllFn) -> bool
fn any(self: RangeI32, pred: AnyFn) -> bool
fn chain(self: RangeI32, other: ChainOther) -> ChainIter<RangeI32, ChainOther, i32>
fn collect(self: RangeI32) -> C
fn contains(self: RangeI32, item: i32) -> bool

Returns true if item lies in the half-open interval [current, end).

fn count(self: RangeI32) -> i64
fn enumerate(self: RangeI32) -> EnumIter<RangeI32, i32>
fn filter(self: RangeI32, pred: fn(i32) -> bool) -> FilterIter<RangeI32, i32>
fn find(self: &mut RangeI32, pred: FindFn) -> Option
fn find_map(self: RangeI32, f: FindMapFn) -> Option
fn fold(self: RangeI32, init: Acc, f: FoldFn) -> Acc
fn for_each(self: RangeI32, f: EachFn) -> void
fn inspect(self: RangeI32, visit: fn(i32) -> void, zero: i32) -> InspectIter<RangeI32, i32>
fn into_rev_range(self: RangeI32) -> RevRangeI32

Converts into a RevRangeI32 yielding the same elements in reverse. Back-compat form; prefer the DoubleEndedIterator .rev() trait default (returns RevIter) for new code.

fn is_empty(self: RangeI32) -> bool

Returns true iff current >= end (Rust’s Range::is_empty).

fn last(self: RangeI32) -> Option
fn len(self: &RangeI32) -> i64
fn map(self: RangeI32, f: MapFn) -> MapIter<RangeI32, i32, MapOut, MapFn>
fn max(self: RangeI32) -> Option
fn max_by(self: RangeI32, cmp: fn(i32, i32) -> i32) -> Option
fn min(self: RangeI32) -> Option
fn min_by(self: RangeI32, cmp: fn(i32, i32) -> i32) -> Option
fn next(self: &mut RangeI32) -> Option
fn next_back(self: &mut RangeI32) -> Option
fn nth(self: &mut RangeI32, n: i64) -> Option
fn nth_back(self: &mut RangeI32, n: i64) -> Option
fn peekable(self: RangeI32) -> PeekableIter<RangeI32, i32>
fn position(self: &mut RangeI32, pred: PosFn) -> Option
fn product(self: RangeI32) -> S
fn reduce(self: RangeI32, f: ReduceFn) -> Option
fn rev(self: RangeI32) -> RevIter<RangeI32, i32>
fn skip(self: RangeI32, n: i64) -> SkipIter<RangeI32, i32>
fn skip_while(self: RangeI32, pred: fn(i32) -> bool, zero: i32) -> SkipWhileIter<RangeI32, i32>
fn step_by(self: RangeI32, step: i64, zero: i32) -> StepByIter<RangeI32, i32>
fn sum(self: RangeI32) -> S
fn take(self: RangeI32, n: i64) -> TakeIter<RangeI32, i32>
fn take_while(self: RangeI32, pred: fn(i32) -> bool, zero: i32) -> TakeWhileIter<RangeI32, i32>
fn try_fold(self: RangeI32, init: Acc, f: TryFoldFn) -> ControlFlow
fn try_for_each(self: RangeI32, f: TryEachFn) -> ControlFlow
fn zip(self: RangeI32, other: ZipOther) -> ZipIter<RangeI32, ZipOther, i32, ZipOtherItem>

structRangeI64

struct RangeI64

Iterates the half-open i64 range [current, end).

Implements: Iterator DoubleEndedIterator ExactSizeIterator FusedIterator

Fields

current: i64

Next value to yield.

end: i64

Exclusive upper bound.

Methods

fn all(self: RangeI64, pred: AllFn) -> bool
fn any(self: RangeI64, pred: AnyFn) -> bool
fn chain(self: RangeI64, other: ChainOther) -> ChainIter<RangeI64, ChainOther, i64>
fn collect(self: RangeI64) -> C
fn contains(self: RangeI64, item: i64) -> bool

Returns true if item lies in the half-open interval [current, end).

fn count(self: RangeI64) -> i64
fn enumerate(self: RangeI64) -> EnumIter<RangeI64, i64>
fn filter(self: RangeI64, pred: fn(i64) -> bool) -> FilterIter<RangeI64, i64>
fn find(self: &mut RangeI64, pred: FindFn) -> Option
fn find_map(self: RangeI64, f: FindMapFn) -> Option
fn fold(self: RangeI64, init: Acc, f: FoldFn) -> Acc
fn for_each(self: RangeI64, f: EachFn) -> void
fn inspect(self: RangeI64, visit: fn(i64) -> void, zero: i64) -> InspectIter<RangeI64, i64>
fn into_rev_range(self: RangeI64) -> RevRangeI64

Converts into a RevRangeI64 yielding the same elements in reverse. Back-compat form; prefer the DoubleEndedIterator .rev() trait default.

fn is_empty(self: RangeI64) -> bool

Returns true iff current >= end (Rust’s Range::is_empty).

fn last(self: RangeI64) -> Option
fn len(self: &RangeI64) -> i64
fn map(self: RangeI64, f: MapFn) -> MapIter<RangeI64, i64, MapOut, MapFn>
fn max(self: RangeI64) -> Option
fn max_by(self: RangeI64, cmp: fn(i64, i64) -> i32) -> Option
fn min(self: RangeI64) -> Option
fn min_by(self: RangeI64, cmp: fn(i64, i64) -> i32) -> Option
fn next(self: &mut RangeI64) -> Option
fn next_back(self: &mut RangeI64) -> Option
fn nth(self: &mut RangeI64, n: i64) -> Option
fn nth_back(self: &mut RangeI64, n: i64) -> Option
fn peekable(self: RangeI64) -> PeekableIter<RangeI64, i64>
fn position(self: &mut RangeI64, pred: PosFn) -> Option
fn product(self: RangeI64) -> S
fn reduce(self: RangeI64, f: ReduceFn) -> Option
fn rev(self: RangeI64) -> RevIter<RangeI64, i64>
fn skip(self: RangeI64, n: i64) -> SkipIter<RangeI64, i64>
fn skip_while(self: RangeI64, pred: fn(i64) -> bool, zero: i64) -> SkipWhileIter<RangeI64, i64>
fn step_by(self: RangeI64, step: i64, zero: i64) -> StepByIter<RangeI64, i64>
fn sum(self: RangeI64) -> S
fn take(self: RangeI64, n: i64) -> TakeIter<RangeI64, i64>
fn take_while(self: RangeI64, pred: fn(i64) -> bool, zero: i64) -> TakeWhileIter<RangeI64, i64>
fn try_fold(self: RangeI64, init: Acc, f: TryFoldFn) -> ControlFlow
fn try_for_each(self: RangeI64, f: TryEachFn) -> ControlFlow
fn zip(self: RangeI64, other: ZipOther) -> ZipIter<RangeI64, ZipOther, i64, ZipOtherItem>

structRangeInclI32

struct RangeInclI32

Iterates the inclusive i32 range [current, end].

Implements: Iterator FusedIterator

Fields

current: i32

Next value to yield.

done: bool

Set once end has been yielded (or when constructed empty).

end: i32

Inclusive upper bound.

Methods

fn all(self: RangeInclI32, pred: AllFn) -> bool
fn any(self: RangeInclI32, pred: AnyFn) -> bool
fn chain(self: RangeInclI32, other: ChainOther) -> ChainIter<RangeInclI32, ChainOther, i32>
fn collect(self: RangeInclI32) -> C
fn contains(self: RangeInclI32, item: i32) -> bool

Returns true if item lies in the closed interval [current, end].

fn count(self: RangeInclI32) -> i64
fn enumerate(self: RangeInclI32) -> EnumIter<RangeInclI32, i32>
fn filter(self: RangeInclI32, pred: fn(i32) -> bool) -> FilterIter<RangeInclI32, i32>
fn find(self: &mut RangeInclI32, pred: FindFn) -> Option
fn find_map(self: RangeInclI32, f: FindMapFn) -> Option
fn fold(self: RangeInclI32, init: Acc, f: FoldFn) -> Acc
fn for_each(self: RangeInclI32, f: EachFn) -> void
fn inspect(self: RangeInclI32, visit: fn(i32) -> void, zero: i32) -> InspectIter<RangeInclI32, i32>
fn is_empty(self: RangeInclI32) -> bool

Returns true once the range has yielded its final value (or was constructed empty).

fn last(self: RangeInclI32) -> Option
fn map(self: RangeInclI32, f: MapFn) -> MapIter<RangeInclI32, i32, MapOut, MapFn>
fn max(self: RangeInclI32) -> Option
fn max_by(self: RangeInclI32, cmp: fn(i32, i32) -> i32) -> Option
fn min(self: RangeInclI32) -> Option
fn min_by(self: RangeInclI32, cmp: fn(i32, i32) -> i32) -> Option
fn next(self: &mut RangeInclI32) -> Option
fn nth(self: &mut RangeInclI32, n: i64) -> Option
fn peekable(self: RangeInclI32) -> PeekableIter<RangeInclI32, i32>
fn position(self: &mut RangeInclI32, pred: PosFn) -> Option
fn product(self: RangeInclI32) -> S
fn reduce(self: RangeInclI32, f: ReduceFn) -> Option
fn skip(self: RangeInclI32, n: i64) -> SkipIter<RangeInclI32, i32>
fn skip_while(self: RangeInclI32, pred: fn(i32) -> bool, zero: i32) -> SkipWhileIter<RangeInclI32, i32>
fn step_by(self: RangeInclI32, step: i64, zero: i32) -> StepByIter<RangeInclI32, i32>
fn sum(self: RangeInclI32) -> S
fn take(self: RangeInclI32, n: i64) -> TakeIter<RangeInclI32, i32>
fn take_while(self: RangeInclI32, pred: fn(i32) -> bool, zero: i32) -> TakeWhileIter<RangeInclI32, i32>
fn try_fold(self: RangeInclI32, init: Acc, f: TryFoldFn) -> ControlFlow
fn try_for_each(self: RangeInclI32, f: TryEachFn) -> ControlFlow
fn zip(self: RangeInclI32, other: ZipOther) -> ZipIter<RangeInclI32, ZipOther, i32, ZipOtherItem>

structRangeInclI64

struct RangeInclI64

Iterates the inclusive i64 range [current, end].

Implements: Iterator FusedIterator

Fields

current: i64

Next value to yield.

done: bool

Set once end has been yielded (or when constructed empty).

end: i64

Inclusive upper bound.

Methods

fn all(self: RangeInclI64, pred: AllFn) -> bool
fn any(self: RangeInclI64, pred: AnyFn) -> bool
fn chain(self: RangeInclI64, other: ChainOther) -> ChainIter<RangeInclI64, ChainOther, i64>
fn collect(self: RangeInclI64) -> C
fn contains(self: RangeInclI64, item: i64) -> bool

Returns true if item lies in the closed interval [current, end].

fn count(self: RangeInclI64) -> i64
fn enumerate(self: RangeInclI64) -> EnumIter<RangeInclI64, i64>
fn filter(self: RangeInclI64, pred: fn(i64) -> bool) -> FilterIter<RangeInclI64, i64>
fn find(self: &mut RangeInclI64, pred: FindFn) -> Option
fn find_map(self: RangeInclI64, f: FindMapFn) -> Option
fn fold(self: RangeInclI64, init: Acc, f: FoldFn) -> Acc
fn for_each(self: RangeInclI64, f: EachFn) -> void
fn inspect(self: RangeInclI64, visit: fn(i64) -> void, zero: i64) -> InspectIter<RangeInclI64, i64>
fn is_empty(self: RangeInclI64) -> bool

Returns true once the range has yielded its final value (or was constructed empty).

fn last(self: RangeInclI64) -> Option
fn map(self: RangeInclI64, f: MapFn) -> MapIter<RangeInclI64, i64, MapOut, MapFn>
fn max(self: RangeInclI64) -> Option
fn max_by(self: RangeInclI64, cmp: fn(i64, i64) -> i32) -> Option
fn min(self: RangeInclI64) -> Option
fn min_by(self: RangeInclI64, cmp: fn(i64, i64) -> i32) -> Option
fn next(self: &mut RangeInclI64) -> Option
fn nth(self: &mut RangeInclI64, n: i64) -> Option
fn peekable(self: RangeInclI64) -> PeekableIter<RangeInclI64, i64>
fn position(self: &mut RangeInclI64, pred: PosFn) -> Option
fn product(self: RangeInclI64) -> S
fn reduce(self: RangeInclI64, f: ReduceFn) -> Option
fn skip(self: RangeInclI64, n: i64) -> SkipIter<RangeInclI64, i64>
fn skip_while(self: RangeInclI64, pred: fn(i64) -> bool, zero: i64) -> SkipWhileIter<RangeInclI64, i64>
fn step_by(self: RangeInclI64, step: i64, zero: i64) -> StepByIter<RangeInclI64, i64>
fn sum(self: RangeInclI64) -> S
fn take(self: RangeInclI64, n: i64) -> TakeIter<RangeInclI64, i64>
fn take_while(self: RangeInclI64, pred: fn(i64) -> bool, zero: i64) -> TakeWhileIter<RangeInclI64, i64>
fn try_fold(self: RangeInclI64, init: Acc, f: TryFoldFn) -> ControlFlow
fn try_for_each(self: RangeInclI64, f: TryEachFn) -> ControlFlow
fn zip(self: RangeInclI64, other: ZipOther) -> ZipIter<RangeInclI64, ZipOther, i64, ZipOtherItem>

structRangeOf

struct RangeOf

Iterates the half-open range [current, end) for any T: Step + Copy.

Implements: Iterator

Fields

current: T

Next value to yield.

end: T

Exclusive upper bound.

structRangeOfFrom

struct RangeOfFrom

Iterates unboundedly from current; next() never returns None.

Implements: Iterator

Fields

current: T

Next value to yield.

structRangeOfFull

struct RangeOfFull

Marks the full unbounded range (..); stateless slicing-index shape.

structRangeOfIncl

struct RangeOfIncl

Iterates the inclusive range [current, end] for any T: Step + Copy.

Implements: Iterator

Fields

current: T

Next value to yield.

done: bool

Set once the final value has been yielded.

end: T

Inclusive upper bound.

structRangeOfTo

struct RangeOfTo

Carries the exclusive upper bound of a start-less range [.., end). Slicing-index shape; not an iterator.

Fields

end: T

Exclusive upper bound.

structRangeOfToIncl

struct RangeOfToIncl

Carries the inclusive upper bound of a start-less range [.., end]. Slicing-index shape; not an iterator.

Fields

end: T

Inclusive upper bound.

structRangeToI32

struct RangeToI32

Carries the exclusive i32 upper bound of a start-less range [.., end); not an iterator.

Fields

end: i32

Methods

fn contains(self: RangeToI32, item: i32) -> bool

Returns true if item < end.

structRangeToI64

struct RangeToI64

Carries the exclusive i64 upper bound of a start-less range [.., end); not an iterator.

Fields

end: i64

Methods

fn contains(self: RangeToI64, item: i64) -> bool

Returns true if item < end.

structRevRangeI32

struct RevRangeI32

Iterates the elements of a RangeI32 in reverse order.

Implements: Iterator FusedIterator

Fields

current: i32

Exclusive upper cursor (decrement-then-yield).

start: i32

Inclusive lower bound (yielded last).

Methods

fn all(self: RevRangeI32, pred: AllFn) -> bool
fn any(self: RevRangeI32, pred: AnyFn) -> bool
fn chain(self: RevRangeI32, other: ChainOther) -> ChainIter<RevRangeI32, ChainOther, i32>
fn collect(self: RevRangeI32) -> C
fn count(self: RevRangeI32) -> i64
fn enumerate(self: RevRangeI32) -> EnumIter<RevRangeI32, i32>
fn filter(self: RevRangeI32, pred: fn(i32) -> bool) -> FilterIter<RevRangeI32, i32>
fn find(self: &mut RevRangeI32, pred: FindFn) -> Option
fn find_map(self: RevRangeI32, f: FindMapFn) -> Option
fn fold(self: RevRangeI32, init: Acc, f: FoldFn) -> Acc
fn for_each(self: RevRangeI32, f: EachFn) -> void
fn inspect(self: RevRangeI32, visit: fn(i32) -> void, zero: i32) -> InspectIter<RevRangeI32, i32>
fn last(self: RevRangeI32) -> Option
fn map(self: RevRangeI32, f: MapFn) -> MapIter<RevRangeI32, i32, MapOut, MapFn>
fn max(self: RevRangeI32) -> Option
fn max_by(self: RevRangeI32, cmp: fn(i32, i32) -> i32) -> Option
fn min(self: RevRangeI32) -> Option
fn min_by(self: RevRangeI32, cmp: fn(i32, i32) -> i32) -> Option
fn next(self: &mut RevRangeI32) -> Option
fn nth(self: &mut RevRangeI32, n: i64) -> Option
fn peekable(self: RevRangeI32) -> PeekableIter<RevRangeI32, i32>
fn position(self: &mut RevRangeI32, pred: PosFn) -> Option
fn product(self: RevRangeI32) -> S
fn reduce(self: RevRangeI32, f: ReduceFn) -> Option
fn skip(self: RevRangeI32, n: i64) -> SkipIter<RevRangeI32, i32>
fn skip_while(self: RevRangeI32, pred: fn(i32) -> bool, zero: i32) -> SkipWhileIter<RevRangeI32, i32>
fn step_by(self: RevRangeI32, step: i64, zero: i32) -> StepByIter<RevRangeI32, i32>
fn sum(self: RevRangeI32) -> S
fn take(self: RevRangeI32, n: i64) -> TakeIter<RevRangeI32, i32>
fn take_while(self: RevRangeI32, pred: fn(i32) -> bool, zero: i32) -> TakeWhileIter<RevRangeI32, i32>
fn try_fold(self: RevRangeI32, init: Acc, f: TryFoldFn) -> ControlFlow
fn try_for_each(self: RevRangeI32, f: TryEachFn) -> ControlFlow
fn zip(self: RevRangeI32, other: ZipOther) -> ZipIter<RevRangeI32, ZipOther, i32, ZipOtherItem>

structRevRangeI64

struct RevRangeI64

Iterates the elements of a RangeI64 in reverse order.

Implements: Iterator FusedIterator

Fields

current: i64

Exclusive upper cursor (decrement-then-yield).

start: i64

Inclusive lower bound (yielded last).

Methods

fn all(self: RevRangeI64, pred: AllFn) -> bool
fn any(self: RevRangeI64, pred: AnyFn) -> bool
fn chain(self: RevRangeI64, other: ChainOther) -> ChainIter<RevRangeI64, ChainOther, i64>
fn collect(self: RevRangeI64) -> C
fn count(self: RevRangeI64) -> i64
fn enumerate(self: RevRangeI64) -> EnumIter<RevRangeI64, i64>
fn filter(self: RevRangeI64, pred: fn(i64) -> bool) -> FilterIter<RevRangeI64, i64>
fn find(self: &mut RevRangeI64, pred: FindFn) -> Option
fn find_map(self: RevRangeI64, f: FindMapFn) -> Option
fn fold(self: RevRangeI64, init: Acc, f: FoldFn) -> Acc
fn for_each(self: RevRangeI64, f: EachFn) -> void
fn inspect(self: RevRangeI64, visit: fn(i64) -> void, zero: i64) -> InspectIter<RevRangeI64, i64>
fn last(self: RevRangeI64) -> Option
fn map(self: RevRangeI64, f: MapFn) -> MapIter<RevRangeI64, i64, MapOut, MapFn>
fn max(self: RevRangeI64) -> Option
fn max_by(self: RevRangeI64, cmp: fn(i64, i64) -> i32) -> Option
fn min(self: RevRangeI64) -> Option
fn min_by(self: RevRangeI64, cmp: fn(i64, i64) -> i32) -> Option
fn next(self: &mut RevRangeI64) -> Option
fn nth(self: &mut RevRangeI64, n: i64) -> Option
fn peekable(self: RevRangeI64) -> PeekableIter<RevRangeI64, i64>
fn position(self: &mut RevRangeI64, pred: PosFn) -> Option
fn product(self: RevRangeI64) -> S
fn reduce(self: RevRangeI64, f: ReduceFn) -> Option
fn skip(self: RevRangeI64, n: i64) -> SkipIter<RevRangeI64, i64>
fn skip_while(self: RevRangeI64, pred: fn(i64) -> bool, zero: i64) -> SkipWhileIter<RevRangeI64, i64>
fn step_by(self: RevRangeI64, step: i64, zero: i64) -> StepByIter<RevRangeI64, i64>
fn sum(self: RevRangeI64) -> S
fn take(self: RevRangeI64, n: i64) -> TakeIter<RevRangeI64, i64>
fn take_while(self: RevRangeI64, pred: fn(i64) -> bool, zero: i64) -> TakeWhileIter<RevRangeI64, i64>
fn try_fold(self: RevRangeI64, init: Acc, f: TryFoldFn) -> ControlFlow
fn try_for_each(self: RevRangeI64, f: TryEachFn) -> ControlFlow
fn zip(self: RevRangeI64, other: ZipOther) -> ZipIter<RevRangeI64, ZipOther, i64, ZipOtherItem>

Functions

fnrange_from_i32

fn range_from_i32(start: i32) -> RangeFromI32

Creates the unbounded i32 range [start, ..); terminate externally (e.g. .take(n)).

fnrange_from_i64

fn range_from_i64(start: i64) -> RangeFromI64

Creates the unbounded i64 range [start, ..); terminate externally (e.g. .take(n)).

fnrange_from_of

fn range_from_of(start: T) -> RangeOfFrom<T>

Creates the unbounded range [start, ..); terminate externally (e.g. .take(n)).

fnrange_full

fn range_full() -> RangeFull

Creates the stateless RangeFull marker.

fnrange_full_of

fn range_full_of() -> RangeOfFull

Creates the stateless RangeOfFull marker.

fnrange_i32

fn range_i32(lo: i32, hi: i32) -> RangeI32

Creates the half-open i32 range [lo, hi).

fnrange_i64

fn range_i64(lo: i64, hi: i64) -> RangeI64

Creates the half-open i64 range [lo, hi).

fnrange_incl_i32

fn range_incl_i32(lo: i32, hi: i32) -> RangeInclI32

Creates the inclusive i32 range [lo, hi]; empty when lo > hi.

fnrange_incl_i64

fn range_incl_i64(lo: i64, hi: i64) -> RangeInclI64

Creates the inclusive i64 range [lo, hi]; empty when lo > hi.

fnrange_incl_of

fn range_incl_of(start: T, end: T) -> RangeOfIncl<T>

Creates the inclusive range [start, end]; empty when end precedes start.

fnrange_of

fn range_of(start: T, end: T) -> RangeOf<T>

Creates the half-open range [start, end).

fnrange_to_i32

fn range_to_i32(end: i32) -> RangeToI32

Creates a RangeToI32 carrying the exclusive upper bound end.

fnrange_to_i64

fn range_to_i64(end: i64) -> RangeToI64

Creates a RangeToI64 carrying the exclusive upper bound end.

fnrange_to_incl_of

fn range_to_incl_of(end: T) -> RangeOfToIncl<T>

Creates a RangeOfToIncl<T> carrying the inclusive upper bound end.

fnrange_to_of

fn range_to_of(end: T) -> RangeOfTo<T>

Creates a RangeOfTo<T> carrying the exclusive upper bound end.