Struct `RangeFrom`

struct RangeFrom<Idx> { ... }

A range only bounded inclusively below (start..).

The RangeFrom start.. contains all values with x >= start.

Note: Overflow in the Iterator implementation (when the contained data type reaches its numerical limit) is allowed to panic, wrap, or saturate. This behavior is defined by the implementation of the Step trait. For primitive integers, this follows the normal rules, and respects the overflow checks profile (panic in debug, wrap in release). Note also that overflow happens earlier than you might assume: the overflow happens in the call to next that yields the maximum value, as the range must be set to a state to yield the next value.

Examples

The start.. syntax is a RangeFrom:

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

assert_eq!(RangeFrom::from(2..), core::range::RangeFrom { start: 2 });
assert_eq!(2 + 3 + 4, RangeFrom::from(2..).into_iter().take(3).sum());

Fields

start: Idx: The lower bound of the range (inclusive).

Implementations

`impl<Idx: PartialOrd<Idx>> RangeFrom<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::RangeFrom;

assert!(!RangeFrom::from(3..).contains(&2));
assert!( RangeFrom::from(3..).contains(&3));
assert!( RangeFrom::from(3..).contains(&1_000_000_000));

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

`impl<Idx: Step> RangeFrom<Idx>`

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

Creates an iterator over the elements within this range.

Shorthand for .clone().into_iter()

Examples

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

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

`impl SliceIndex for range::RangeFrom<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 SliceIndex for range::RangeFrom<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<A: Step> IntoIterator for crate::range::RangeFrom<A>`

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

`impl<Idx> Freeze for RangeFrom<Idx>`

`impl<Idx> RefUnwindSafe for RangeFrom<Idx>`

`impl<Idx> Send for RangeFrom<Idx>`

`impl<Idx> StructuralPartialEq for RangeFrom<Idx>`

`impl<Idx> Sync for RangeFrom<Idx>`

`impl<Idx> Unpin for RangeFrom<Idx>`

`impl<Idx> UnwindSafe for RangeFrom<Idx>`

`impl<Idx: $crate::hash::Hash> Hash for RangeFrom<Idx>`

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

`impl<Idx: $crate::marker::Copy> Copy for RangeFrom<Idx>`

`impl<Idx: fmt::Debug> Debug for RangeFrom<Idx>`

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

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

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

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

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

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

`impl<T> Any for RangeFrom<Idx>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for RangeFrom<Idx>`

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

`impl<T> BorrowMut for RangeFrom<Idx>`

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

`impl<T> CloneToUninit for RangeFrom<Idx>`

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

`impl<T> From for RangeFrom<Idx>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> From for RangeFrom<T>`

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

`impl<T> IntoBounds for RangeFrom<T>`

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

`impl<T> RangeBounds for RangeFrom<&T>`

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

`impl<T> RangeBounds for RangeFrom<T>`

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

`impl<T> SliceIndex for range::RangeFrom<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 RangeFrom<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 RangeFrom<Idx>`

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

`impl<T, U> TryInto for RangeFrom<Idx>`

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