rustmax::cxx_build::core::ops

Struct RangeInclusive

1.26.0 · Source

pub struct RangeInclusive<Idx> { /* private fields */ }

Expand description

A range bounded inclusively below and above (start..=end).

The RangeInclusive start..=end contains all values with x >= start and x <= end. It is empty unless start <= end.

This iterator is fused, but the specific values of start and end after iteration has finished are unspecified other than that .is_empty() will return true once no more values will be produced.

§Examples

The start..=end syntax is a RangeInclusive:

assert_eq!((3..=5), std::ops::RangeInclusive::new(3, 5));
assert_eq!(3 + 4 + 5, (3..=5).sum());

let arr = [0, 1, 2, 3, 4];
assert_eq!(arr[ ..  ], [0, 1, 2, 3, 4]);
assert_eq!(arr[ .. 3], [0, 1, 2      ]);
assert_eq!(arr[ ..=3], [0, 1, 2, 3   ]);
assert_eq!(arr[1..  ], [   1, 2, 3, 4]);
assert_eq!(arr[1.. 3], [   1, 2      ]);
assert_eq!(arr[1..=3], [   1, 2, 3   ]); // This is a `RangeInclusive`

Implementations§

Source §

impl<Idx> RangeInclusive<Idx>

1.27.0 (const: 1.32.0) · Source

pub const fn new(start: Idx, end: Idx) -> RangeInclusive<Idx> ⓘ

Creates a new inclusive range. Equivalent to writing start..=end.

§Examples

use std::ops::RangeInclusive;

assert_eq!(3..=5, RangeInclusive::new(3, 5));

1.27.0 (const: 1.32.0) · Source

pub const fn start(&self) -> &Idx

Returns the lower bound of the range (inclusive).

When using an inclusive range for iteration, the values of start() and end() are unspecified after the iteration ended. To determine whether the inclusive range is empty, use the is_empty() method instead of comparing start() > end().

Note: the value returned by this method is unspecified after the range has been iterated to exhaustion.

§Examples

assert_eq!((3..=5).start(), &3);

1.27.0 (const: 1.32.0) · Source

pub const fn end(&self) -> &Idx

Returns the upper bound of the range (inclusive).

When using an inclusive range for iteration, the values of start() and end() are unspecified after the iteration ended. To determine whether the inclusive range is empty, use the is_empty() method instead of comparing start() > end().

Note: the value returned by this method is unspecified after the range has been iterated to exhaustion.

§Examples

assert_eq!((3..=5).end(), &5);

1.27.0 (const: unstable) · Source

pub fn into_inner(self) -> (Idx, Idx)

Destructures the RangeInclusive into (lower bound, upper (inclusive) bound).

Note: the value returned by this method is unspecified after the range has been iterated to exhaustion.

§Examples

assert_eq!((3..=5).into_inner(), (3, 5));

Source §

impl<Idx> RangeInclusive<Idx>
where Idx: PartialOrd,

1.35.0 · Source

pub fn contains(&self, item: &U) -> bool
where Idx: PartialOrd, U: PartialOrd<Idx> + ?Sized,

Returns true if item is contained in the range.

§Examples

assert!(!(3..=5).contains(&2));
assert!( (3..=5).contains(&3));
assert!( (3..=5).contains(&4));
assert!( (3..=5).contains(&5));
assert!(!(3..=5).contains(&6));

assert!( (3..=3).contains(&3));
assert!(!(3..=2).contains(&3));

assert!( (0.0..=1.0).contains(&1.0));
assert!(!(0.0..=1.0).contains(&f32::NAN));
assert!(!(0.0..=f32::NAN).contains(&0.0));
assert!(!(f32::NAN..=1.0).contains(&1.0));

This method always returns false after iteration has finished:

let mut r = 3..=5;
assert!(r.contains(&3) && r.contains(&5));
for _ in r.by_ref() {}
// Precise field values are unspecified here
assert!(!r.contains(&3) && !r.contains(&5));

1.47.0 · Source

pub fn is_empty(&self) -> bool

Returns true if the range contains no items.

§Examples

assert!(!(3..=5).is_empty());
assert!(!(3..=3).is_empty());
assert!( (3..=2).is_empty());

The range is empty if either side is incomparable:

assert!(!(3.0..=5.0).is_empty());
assert!( (3.0..=f32::NAN).is_empty());
assert!( (f32::NAN..=5.0).is_empty());

This method returns true after iteration has finished:

let mut r = 3..=5;
for _ in r.by_ref() {}
// Precise field values are unspecified here
assert!(r.is_empty());

Trait Implementations§

Source §

impl<A> Arbitrary for RangeInclusive<A>
where A: PartialOrd + Arbitrary,

Source §

type Parameters = (<A as Arbitrary>::Parameters, <A as Arbitrary>::Parameters)

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

Source §

type Strategy = Map<<(A, A) as Arbitrary>::Strategy, fn((A, A)) -> RangeInclusive<A>>

The type of Strategy used to generate values of type Self.

Source §

fn arbitrary_with( args: <RangeInclusive<A> as Arbitrary>::Parameters, ) -> <RangeInclusive<A> as Arbitrary>::Strategy ⓘ

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args. Read more

Source §

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). Read more

Source §

impl<A> ArbitraryF1<A> for RangeInclusive<A>
where A: Debug + PartialOrd,

Source §

type Parameters = ()

The type of parameters that lift1_with accepts for configuration of the lifted and generated Strategy. Parameters must implement Default.

Source §

fn lift1_with<S>( base: S, _args: <RangeInclusive<A> as ArbitraryF1<A>>::Parameters, ) -> BoxedStrategy<RangeInclusive<A>>
where S: Strategy<Value = A> + 'static,

Lifts a given Strategy to a new Strategy for the (presumably) bigger type. This is useful for lifting a Strategy for SomeType to a container such as Vec of SomeType. The composite strategy is passed the arguments given in args. Read more

Source §

fn lift1<AS>(base: AS) -> BoxedStrategy<Self>
where AS: Strategy<Value = A> + 'static,

Lifts a given Strategy to a new Strategy for the (presumably) bigger type. This is useful for lifting a Strategy for SomeType to a container such as Vec<SomeType>. Read more

1.26.0 · Source§

impl<Idx> Clone for RangeInclusive<Idx>
where Idx: Clone,

Source §

fn clone(&self) -> RangeInclusive<Idx> ⓘ

Returns a copy of the value. Read more

Returns the nth element from the end of the iterator. Read more

Source §

fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
where RangeInclusive<A>: Sized, F: FnMut(B, <RangeInclusive<A> as Iterator>::Item) -> R, R: Try<Output = B>,

This is the reverse version of Iterator::try_fold(): it takes elements starting from the back of the iterator. Read more

Source §

fn rfold<AAA, FFF>(self, init: AAA, fold: FFF) -> AAA
where FFF: FnMut(AAA, <RangeInclusive<A> as Iterator>::Item) -> AAA,

An iterator method that reduces the iterator’s elements to a single, final value, starting from the back. Read more

Source §

fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)

Advances the iterator from the back by n elements. Read more

1.27.0 · Source§

Source §

fn from(value: RangeInclusive<T>) -> RangeInclusive<T>

Converts to this type from the input type.

Source §

impl<X> From<RangeInclusive<X>> for Uniform<X>
where X: SampleUniform,

Source §

fn from(r: RangeInclusive<X>) -> Uniform<X>

Converts to this type from the input type.

Source §

impl From<RangeInclusive<i64>> for ValueParser

Create an i64 ValueParser from a N..=M range

See RangedI64ValueParser for more control over the output type.

§Examples

let mut cmd = clap::Command::new("raw")
    .arg(
        clap::Arg::new("port")
            .long("port")
            .value_parser(3000..=4000)
            .action(clap::ArgAction::Set)
            .required(true)
    );

let m = cmd.try_get_matches_from_mut(["cmd", "--port", "3001"]).unwrap();
let port: i64 = *m.get_one("port")
    .expect("required");
assert_eq!(port, 3001);

Source §

fn from(value: RangeInclusive<i64>) -> ValueParser

Converts to this type from the input type.

Source §

impl From<RangeInclusive<usize>> for Range

Source §

fn from(range: RangeInclusive<usize>) -> Range

Converts to this type from the input type.

Source §

impl From<RangeInclusive<usize>> for SizeRange

Given low ..= high, then a size range [low, high] is the result.

Source §

fn from(r: RangeInclusive<usize>) -> SizeRange

Converts to this type from the input type.

Source §

impl From<RangeInclusive<usize>> for ValueRange

Source §

fn from(range: RangeInclusive<usize>) -> ValueRange

Converts to this type from the input type.

Implemented for ranges of all primitive integer types and char.

Source §

type Item = <Iter<T> as ParallelIterator>::Item

The type of item that the parallel iterator will produce.

Source §

type Iter = Iter<T>

The parallel iterator type that will be created.

Source §

fn into_par_iter(self) -> <RangeInclusive<T> as IntoParallelIterator>::Iter ⓘ

Converts self into a parallel iterator. Read more

1.26.0 · Source§

🔬This is a nightly-only experimental API. (iter_next_chunk)

Advances the iterator and returns an array containing the next N values. Read more

Source §

fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)

Advances the iterator by n elements. Read more

1.28.0 · Source§

fn step_by(self, step: usize) -> StepBy<Self> ⓘ
where Self: Sized,

Creates an iterator starting at the same point, but stepping by the given amount at each iteration. Read more

1.0.0 · Source§

fn chain(self, other: U) -> Chain<Self, ::IntoIter> ⓘ
where Self: Sized, U: IntoIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both in sequence. Read more

1.0.0 · Source§

fn zip(self, other: U) -> Zip<Self, ::IntoIter> ⓘ
where Self: Sized, U: IntoIterator,

‘Zips up’ two iterators into a single iterator of pairs. Read more

Source §

fn intersperse(self, separator: Self::Item) -> Intersperse<Self> ⓘ
where Self: Sized, Self::Item: Clone,

🔬This is a nightly-only experimental API. (iter_intersperse)

Creates a new iterator which places a copy of separator between adjacent items of the original iterator. Read more

Source §

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> ⓘ
where Self: Sized, G: FnMut() -> Self::Item,

🔬This is a nightly-only experimental API. (iter_intersperse)

fn fuse(self) -> Fuse<Self> ⓘ
where Self: Sized,

Creates an iterator which ends after the first None. Read more

1.0.0 · Source§

fn inspect<F>(self, f: F) -> Inspect<Self, F> ⓘ
where Self: Sized, F: FnMut(&Self::Item),

Does something with each element of an iterator, passing the value on. Read more

1.0.0 · Source§

fn by_ref(&mut self) -> &mut Self
where Self: Sized,

Creates a “by reference” adapter for this instance of Iterator. Read more

1.0.0 · Source§

fn collect(self) -> B
where B: FromIterator<Self::Item>, Self: Sized,

Transforms an iterator into a collection. Read more

Source §

fn try_collect( &mut self, ) -> <<Self::Item as Try>::Residual as Residual>::TryType
where Self: Sized, Self::Item: Try, <Self::Item as Try>::Residual: Residual, B: FromIterator<<Self::Item as Try>::Output>,

🔬This is a nightly-only experimental API. (iterator_try_collect)

Fallibly transforms an iterator into a collection, short circuiting if a failure is encountered. Read more

Source §

fn collect_into<E>(self, collection: &mut E) -> &mut E
where E: Extend<Self::Item>, Self: Sized,

🔬This is a nightly-only experimental API. (iter_collect_into)

Collects all the items from an iterator into a collection. Read more

1.0.0 · Source§

fn partition<B, F>(self, f: F) -> (B, B)
where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,

Consumes an iterator, creating two collections from it. Read more

Source §

fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
where T: 'a, Self: Sized + DoubleEndedIterator<Item = &'a mut T>, P: FnMut(&T) -> bool,

🔬This is a nightly-only experimental API. (iter_partition_in_place)

Reorders the elements of this iterator in-place according to the given predicate, such that all those that return true precede all those that return false. Returns the number of true elements found. Read more

Source §

fn is_partitioned(self, predicate: P) -> bool
where Self: Sized, P: FnMut(Self::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_is_partitioned)

Checks if the elements of this iterator are partitioned according to the given predicate, such that all those that return true precede all those that return false. Read more

1.27.0 · Source§

fn try_for_each<F, R>(&mut self, f: F) -> R
where Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = ()>,

An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error. Read more

1.51.0 · Source§

fn reduce<F>(self, f: F) -> Option<Self::Item>
where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the elements to a single one, by repeatedly applying a reducing operation. Read more

Source §

fn try_reduce<R>( &mut self, f: impl FnMut(Self::Item, Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
where Self: Sized, R: Try<Output = Self::Item>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (iterator_try_reduce)

1.11.0 · Source§

fn sum<S>(self) -> S
where Self: Sized, S: Sum<Self::Item>,

Sums the elements of an iterator. Read more

1.11.0 · Source§

Source §

type Output = Take<Skip>

The type returned for this type of index.

Source §

fn index(self, iter: I) -> <RangeInclusive<usize> as IteratorIndex>::Output ⓘ

Returns an adapted iterator for the current index. Read more

Source §

Source §

fn eq(&self, other: &RangeInclusive<Idx>) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

1.28.0 · Source§

impl<T> RangeBounds<T> for RangeInclusive<&T>

Source §

fn start_bound(&self) -> Bound<&T>

impl<T> SliceIndex<[T]> for RangeInclusive<usize>

The methods index and index_mut panic if:

the end of the range is usize::MAX or
the start of the range is greater than the end of the range or
the end of the range is out of bounds.

Source §

Source §

Panics if begin does not point to the starting byte offset of a character (as defined by is_char_boundary), if end does not point to the ending byte offset of a character (end + 1 is either a starting byte offset or equal to len), if begin > end, or if end >= len.

Source §

Wraps this strategy to prevent values from being subject to shrinking. Read more

Source §

Wraps this strategy to prevent values from being subject to shrinking. Read more

Source §

Wraps this strategy to prevent values from being subject to shrinking. Read more

Source §

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

type IntoIter = I

Which kind of iterator are we turning this into?

Uniformly sample one element (stable) Read more

Source §

fn choose_multiple_fill<R>(self, rng: &mut R, buf: &mut [Self::Item]) -> usize
where R: Rng + ?Sized,

Uniformly sample amount distinct elements into a buffer Read more

Source §

fn choose_multiple<R>(self, rng: &mut R, amount: usize) -> Vec<Self::Item>
where R: Rng + ?Sized,

Uniformly sample amount distinct elements into a Vec Read more

Source §

impl IteratorRandom for I
where I: Iterator,

Source §

fn choose<R>(self, rng: &mut R) -> Option<Self::Item>
where R: Rng + ?Sized,

Choose one element at random from the iterator. Read more

Source §

fn choose_stable<R>(self, rng: &mut R) -> Option<Self::Item>
where R: Rng + ?Sized,

Choose one element at random from the iterator. Read more

Source §

fn choose_multiple_fill<R>(self, rng: &mut R, buf: &mut [Self::Item]) -> usize
where R: Rng + ?Sized,

Collects values at random from the iterator into a supplied buffer until that buffer is filled. Read more

Source §

fn choose_multiple<R>(self, rng: &mut R, amount: usize) -> Vec<Self::Item>
where R: Rng + ?Sized,

Collects amount values at random from the iterator into a vector. Read more

Source §

👎Deprecated since 0.13.0: Use .chunk_by() instead

👎Deprecated since 0.10.2: Use Iterator::reduce instead

Accumulator of the elements in the iterator. Read more

Source §

fn tree_reduce<F>(self, f: F) -> Option<Self::Item>
where F: FnMut(Self::Item, Self::Item) -> Self::Item, Self: Sized,

Accumulate the elements in the iterator in a tree-like manner. Read more

Source §

fn tree_fold1<F>(self, f: F) -> Option<Self::Item>
where F: FnMut(Self::Item, Self::Item) -> Self::Item, Self: Sized,

👎Deprecated since 0.13.0: Use .tree_reduce() instead

Returns the length of the iterator if one exists. Otherwise return self.size_hint(). Read more

Source §

Return an iterator that groups the items in tuples of a specific size (up to 4). Read more

Source §

fn step(self, n: usize) -> Step<Self> ⓘ
where Self: Sized,

👎Deprecated since 0.8.0: Use std .step_by() instead

Return an iterator adaptor that steps n elements in the base iterator for each iteration. Read more

Source §

fn map_into<R>(self) -> MapSpecialCase<Self, MapSpecialCaseFnInto<R>>
where Self: Sized, Self::Item: Into<R>,

Convert each item of the iterator using the Into trait. Read more

Source §

fn map_results<F, T, U, E>( self, f: F, ) -> MapSpecialCase<Self, MapSpecialCaseFnOk<F>>
where Self: Sized + Iterator<Item = Result<T, E>>, F: FnMut(T) -> U,

👎Deprecated since 0.10.0: Use .map_ok() instead

fn concat(self) -> Self::Item
where Self: Sized, Self::Item: Extend<<Self::Item as IntoIterator>::Item> + IntoIterator + Default,

Combine all an iterator’s elements into one element by using Extend. Read more

Source §

fn set_from<'a, A, J>(&mut self, from: J) -> usize
where A: 'a, Self: Iterator<Item = &'a mut A>, J: IntoIterator<Item = A>,

Assign to each reference in self from the from iterator, stopping at the shortest of the two iterators. Read more

Source §

fn format(self, sep: &str) -> Format<'_, Self>
where Self: Sized,

Format all iterator elements, separated by sep. Read more

Source §

fn format_with<F>(self, sep: &str, format: F) -> FormatWith<'_, Self, F>
where Self: Sized, F: FnMut(Self::Item, &mut dyn FnMut(&dyn Display) -> Result<(), Error>) -> Result<(), Error>,

Format all iterator elements, separated by sep. Read more

Source §

fn fold_results<A, E, B, F>(&mut self, start: B, f: F) -> Result<B, E>
where Self: Iterator<Item = Result<A, E>>, F: FnMut(B, A) -> B,

👎Deprecated since 0.10.0: Use .fold_ok() instead

Source §

impl<T> PolicyExt for T
where T: ?Sized,

Source §

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow only if self and other return Action::Follow. Read more

Source §

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow if either self or other returns Action::Follow. Read more

impl<T> ToOwned for T
where T: Clone,

Source §

type Owned = T

The resulting type after obtaining ownership.

Source §

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

Source §

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

Source §

impl<T, U> TryFrom for T
where U: Into<T>,

Source §

type Error = Infallible

The type returned in the event of a conversion error.

Source §

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Source §

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘ
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

Source §

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

Source §

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,

Source §

Struct RangeInclusiveCopy item path

§Examples

Implementations§

impl<Idx> RangeInclusive<Idx>

pub const fn new(start: Idx, end: Idx) -> RangeInclusive<Idx> ⓘ

§Examples

pub const fn start(&self) -> &Idx

§Examples

pub const fn end(&self) -> &Idx

§Examples

pub fn into_inner(self) -> (Idx, Idx)

§Examples

impl<Idx> RangeInclusive<Idx>where Idx: PartialOrd,

pub fn contains<U>(&self, item: &U) -> boolwhere Idx: PartialOrd<U>, U: PartialOrd<Idx> + ?Sized,

§Examples

pub fn is_empty(&self) -> bool

§Examples

Trait Implementations§

impl<A> Arbitrary for RangeInclusive<A>where A: PartialOrd + Arbitrary,

type Parameters = (<A as Arbitrary>::Parameters, <A as Arbitrary>::Parameters)

type Strategy = Map<<(A, A) as Arbitrary>::Strategy, fn((A, A)) -> RangeInclusive<A>>

fn arbitrary_with( args: <RangeInclusive<A> as Arbitrary>::Parameters, ) -> <RangeInclusive<A> as Arbitrary>::Strategy ⓘ

fn arbitrary() -> Self::Strategy

impl<A> ArbitraryF1<A> for RangeInclusive<A>where A: Debug + PartialOrd,

type Parameters = ()

fn lift1_with<S>( base: S, _args: <RangeInclusive<A> as ArbitraryF1<A>>::Parameters, ) -> BoxedStrategy<RangeInclusive<A>>where S: Strategy<Value = A> + 'static,

fn lift1<AS>(base: AS) -> BoxedStrategy<Self>where AS: Strategy<Value = A> + 'static,

impl<Idx> Clone for RangeInclusive<Idx>where Idx: Clone,

fn clone(&self) -> RangeInclusive<Idx> ⓘ

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

impl<C1, C2> ContainsToken<C1> for RangeInclusive<C2>where C1: AsChar, C2: AsChar + Clone,

fn contains_token(&self, token: C1) -> bool

impl<Idx> Debug for RangeInclusive<Idx>where Idx: Debug,

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

impl<'de, Idx> Deserialize<'de> for RangeInclusive<Idx>where Idx: Deserialize<'de>,

fn deserialize<D>( deserializer: D, ) -> Result<RangeInclusive<Idx>, <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

impl<A> DoubleEndedIterator for RangeInclusive<A>where A: Step,

fn next_back(&mut self) -> Option<A>

fn nth_back(&mut self, n: usize) -> Option<A>

fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> Rwhere RangeInclusive<A>: Sized, F: FnMut(B, <RangeInclusive<A> as Iterator>::Item) -> R, R: Try<Output = B>,

fn rfold<AAA, FFF>(self, init: AAA, fold: FFF) -> AAAwhere FFF: FnMut(AAA, <RangeInclusive<A> as Iterator>::Item) -> AAA,

fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>where Self: Sized, P: FnMut(&Self::Item) -> bool,

impl ExactSizeIterator for RangeInclusive<i16>

fn len(&self) -> usize

fn is_empty(&self) -> bool

impl ExactSizeIterator for RangeInclusive<i8>

fn len(&self) -> usize

fn is_empty(&self) -> bool

impl ExactSizeIterator for RangeInclusive<u16>

fn len(&self) -> usize

fn is_empty(&self) -> bool

impl ExactSizeIterator for RangeInclusive<u8>

fn len(&self) -> usize

fn is_empty(&self) -> bool

impl<T> From<RangeInclusive<T>> for RangeInclusive<T>

fn from(value: RangeInclusive<T>) -> RangeInclusive<T> ⓘ

impl<T> From<RangeInclusive<T>> for RangeInclusive<T>

fn from(value: RangeInclusive<T>) -> RangeInclusive<T>

impl<X> From<RangeInclusive<X>> for Uniform<X>where X: SampleUniform,

fn from(r: RangeInclusive<X>) -> Uniform<X>

impl From<RangeInclusive<i64>> for ValueParser

§Examples

fn from(value: RangeInclusive<i64>) -> ValueParser

impl From<RangeInclusive<usize>> for Range

fn from(range: RangeInclusive<usize>) -> Range

impl From<RangeInclusive<usize>> for SizeRange

fn from(r: RangeInclusive<usize>) -> SizeRange

impl From<RangeInclusive<usize>> for ValueRange

fn from(range: RangeInclusive<usize>) -> ValueRange

impl GetDisjointMutIndex for RangeInclusive<usize>

fn is_in_bounds(&self, len: usize) -> bool

fn is_overlapping(&self, other: &RangeInclusive<usize>) -> bool

impl<Idx> Hash for RangeInclusive<Idx>where Idx: Hash,

fn hash<__H>(&self, state: &mut __H)where __H: Hasher,

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

impl Index<RangeInclusive<usize>> for BStr

type Output = BStr

fn index(&self, r: RangeInclusive<usize>) -> &BStr

impl Index<RangeInclusive<usize>> for BStr

Struct RangeInclusive

impl<Idx> RangeInclusive<Idx>
where Idx: PartialOrd,

pub fn contains<U>(&self, item: &U) -> bool
where Idx: PartialOrd<U>, U: PartialOrd<Idx> + ?Sized,

impl<A> Arbitrary for RangeInclusive<A>
where A: PartialOrd + Arbitrary,

impl<A> ArbitraryF1<A> for RangeInclusive<A>
where A: Debug + PartialOrd,

fn lift1_with<S>( base: S, _args: <RangeInclusive<A> as ArbitraryF1<A>>::Parameters, ) -> BoxedStrategy<RangeInclusive<A>>
where S: Strategy<Value = A> + 'static,

fn lift1<AS>(base: AS) -> BoxedStrategy<Self>
where AS: Strategy<Value = A> + 'static,

impl<Idx> Clone for RangeInclusive<Idx>
where Idx: Clone,

impl<C1, C2> ContainsToken<C1> for RangeInclusive<C2>
where C1: AsChar, C2: AsChar + Clone,

impl<Idx> Debug for RangeInclusive<Idx>
where Idx: Debug,

impl<'de, Idx> Deserialize<'de> for RangeInclusive<Idx>
where Idx: Deserialize<'de>,

fn deserialize<D>( deserializer: D, ) -> Result<RangeInclusive<Idx>, <D as Deserializer<'de>>::Error>
where D: Deserializer<'de>,

impl<A> DoubleEndedIterator for RangeInclusive<A>
where A: Step,

fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
where RangeInclusive<A>: Sized, F: FnMut(B, <RangeInclusive<A> as Iterator>::Item) -> R, R: Try<Output = B>,

fn rfold<AAA, FFF>(self, init: AAA, fold: FFF) -> AAA
where FFF: FnMut(AAA, <RangeInclusive<A> as Iterator>::Item) -> AAA,

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
where Self: Sized, P: FnMut(&Self::Item) -> bool,

impl<X> From<RangeInclusive<X>> for Uniform<X>
where X: SampleUniform,

impl<Idx> Hash for RangeInclusive<Idx>
where Idx: Hash,

fn hash<H>(&self, state: &mut H)
where __H: Hasher,

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

fn intersect<R>(self, other: R) -> (Bound<T>, Bound<T>)
where Self: Sized, T: Ord, R: IntoBounds<T>,

impl<T> IntoParallelIterator for RangeInclusive<T>
where Iter<T>: ParallelIterator,

impl<A> Iterator for RangeInclusive<A>
where A: Step,

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
where RangeInclusive<A>: Sized, F: FnMut(B, <RangeInclusive<A> as Iterator>::Item) -> R, R: Try<Output = B>,

fn fold<AAA, FFF>(self, init: AAA, fold: FFF) -> AAA
where FFF: FnMut(AAA, <RangeInclusive<A> as Iterator>::Item) -> AAA,

fn min(self) -> Option<A>
where A: Ord,

fn max(self) -> Option<A>
where A: Ord,

fn next_chunk<const N: usize>( &mut self, ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
where Self: Sized,

fn step_by(self, step: usize) -> StepBy<Self> ⓘ
where Self: Sized,

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> ⓘ
where Self: Sized, U: IntoIterator<Item = Self::Item>,

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> ⓘ
where Self: Sized, U: IntoIterator,

fn intersperse(self, separator: Self::Item) -> Intersperse<Self> ⓘ
where Self: Sized, Self::Item: Clone,

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> ⓘ
where Self: Sized, G: FnMut() -> Self::Item,

fn map<B, F>(self, f: F) -> Map<Self, F> ⓘ
where Self: Sized, F: FnMut(Self::Item) -> B,

fn for_each<F>(self, f: F)
where Self: Sized, F: FnMut(Self::Item),

fn filter<P>(self, predicate: P) -> Filter<Self, P> ⓘ
where Self: Sized, P: FnMut(&Self::Item) -> bool,