impl<Idx: PartialOrd<Idx>> Range<Idx>

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

Returns true if item is contained in the range.

Examples

#![feature(new_range_api)]
use core::range::Range;

assert!(!Range::from(3..5).contains(&2));
assert!( Range::from(3..5).contains(&3));
assert!( Range::from(3..5).contains(&4));
assert!(!Range::from(3..5).contains(&5));

assert!(!Range::from(3..3).contains(&3));
assert!(!Range::from(3..2).contains(&3));

assert!( Range::from(0.0..1.0).contains(&0.5));
assert!(!Range::from(0.0..1.0).contains(&f32::NAN));
assert!(!Range::from(0.0..f32::NAN).contains(&0.5));
assert!(!Range::from(f32::NAN..1.0).contains(&0.5));

const fn is_empty(self: &Self) -> bool
where
    Idx: ~const PartialOrd

Returns true if the range contains no items.

Examples

#![feature(new_range_api)]
use core::range::Range;

assert!(!Range::from(3..5).is_empty());
assert!( Range::from(3..3).is_empty());
assert!( Range::from(3..2).is_empty());

The range is empty if either side is incomparable:

#![feature(new_range_api)]
use core::range::Range;

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

impl<Idx: Step> Range<Idx>

fn iter(self: &Self) -> RangeIter<Idx>

Creates an iterator over the elements within this range.

Shorthand for .clone().into_iter()

Examples

#![feature(new_range_api)]
use core::range::Range;

let mut i = Range::from(3..9).iter().map(|n| n*n);
assert_eq!(i.next(), Some(9));
assert_eq!(i.next(), Some(16));
assert_eq!(i.next(), Some(25));

impl GetDisjointMutIndex for range::Range<usize>

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

fn is_overlapping(self: &Self, other: &Self) -> bool

impl SliceIndex for range::Range<usize>

fn get(self: Self, slice: &str) -> Option<&<Self as >::Output>

fn get_mut(self: Self, slice: &mut str) -> Option<&mut <Self as >::Output>

unsafe fn get_unchecked(self: Self, slice: *const str) -> *const <Self as >::Output

unsafe fn get_unchecked_mut(self: Self, slice: *mut str) -> *mut <Self as >::Output

fn index(self: Self, slice: &str) -> &<Self as >::Output

fn index_mut(self: Self, slice: &mut str) -> &mut <Self as >::Output

impl SliceIndex for range::Range<usize>

fn get(self: Self, slice: &ByteStr) -> Option<&<Self as >::Output>

fn get_mut(self: Self, slice: &mut ByteStr) -> Option<&mut <Self as >::Output>

unsafe fn get_unchecked(self: Self, slice: *const ByteStr) -> *const <Self as >::Output

unsafe fn get_unchecked_mut(self: Self, slice: *mut ByteStr) -> *mut <Self as >::Output

fn index(self: Self, slice: &ByteStr) -> &<Self as >::Output

fn index_mut(self: Self, slice: &mut ByteStr) -> &mut <Self as >::Output

impl<A: Step> IntoIterator for crate::range::Range<A>

fn into_iter(self: Self) -> <Self as >::IntoIter

impl<Idx> Freeze for Range<Idx>

impl<Idx> RefUnwindSafe for Range<Idx>

impl<Idx> Send for Range<Idx>

impl<Idx> StructuralPartialEq for Range<Idx>

impl<Idx> Sync for Range<Idx>

impl<Idx> Unpin for Range<Idx>

impl<Idx> UnwindSafe for Range<Idx>

impl<Idx: $crate::hash::Hash> Hash for Range<Idx>

fn hash<__H: $crate::hash::Hasher>(self: &Self, state: &mut __H)

impl<Idx: $crate::marker::Copy> Copy for Range<Idx>

impl<Idx: fmt::Debug> Debug for Range<Idx>

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

impl<Idx: ~const $crate::clone::Clone> Clone for Range<Idx>

fn clone(self: &Self) -> Range<Idx>

impl<Idx: ~const $crate::cmp::Eq> Eq for Range<Idx>

impl<Idx: ~const $crate::cmp::PartialEq> PartialEq for Range<Idx>

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

impl<Idx: ~const $crate::default::Default> Default for Range<Idx>

fn default() -> Range<Idx>

impl<T> Any for Range<Idx>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Range<Idx>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Range<Idx>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> CloneToUninit for Range<Idx>

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

impl<T> From for Range<Idx>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> From for Range<T>

fn from(value: legacy::Range<T>) -> Self

impl<T> IntoBounds for Range<T>

fn into_bounds(self: Self) -> (Bound<T>, Bound<T>)

impl<T> RangeBounds for Range<&T>

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

fn end_bound(self: &Self) -> Bound<&T>

impl<T> RangeBounds for Range<T>

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

fn end_bound(self: &Self) -> Bound<&T>

impl<T> SliceIndex for range::Range<usize>

fn get(self: Self, slice: &[T]) -> Option<&[T]>

fn get_mut(self: Self, slice: &mut [T]) -> Option<&mut [T]>

unsafe fn get_unchecked(self: Self, slice: *const [T]) -> *const [T]

unsafe fn get_unchecked_mut(self: Self, slice: *mut [T]) -> *mut [T]

fn index(self: Self, slice: &[T]) -> &[T]

fn index_mut(self: Self, slice: &mut [T]) -> &mut [T]

impl<T, U> Into for Range<Idx>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for Range<Idx>

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

impl<T, U> TryInto for Range<Idx>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

impl<T: CloneFromCell> CloneFromCell for range::Range<T>