/Rust

Struct std::ops::RangeFrom

```#[lang = "RangeFrom"]pub struct RangeFrom<Idx> {
pub start: 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

```assert_eq!((2..), std::ops::RangeFrom { start: 2 });
assert_eq!(2 + 3 + 4, (2..).take(3).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]);  // RangeFrom
assert_eq!(arr[1.. 3], [  1,2    ]);
assert_eq!(arr[1..=3], [  1,2,3  ]);```

Fields

`start: Idx`

The lower bound of the range (inclusive).

Implementations

`impl<Idx> RangeFrom<Idx> where    Idx: PartialOrd<Idx>, `[src]

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

Returns `true` if `item` is contained in the range.

Examples

```assert!(!(3..).contains(&2));
assert!( (3..).contains(&3));
assert!( (3..).contains(&1_000_000_000));

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

Trait Implementations

`impl Index<RangeFrom<usize>> for String`[src]

`type Output = str`

The returned type after indexing.

`impl Index<RangeFrom<usize>> for CStr`[src]1.47.0

`type Output = CStr`

The returned type after indexing.

`impl<A> Iterator for RangeFrom<A> where    A: Step, `[src]

`type Item = A`

The type of the elements being iterated over.

`impl<T> SliceIndex<[T]> for RangeFrom<usize>`[src]1.15.0

`type Output = [T]`

The output type returned by methods.

`impl SliceIndex<str> for RangeFrom<usize>`[src]1.20.0

Implements substring slicing with syntax `&self[begin ..]` or `&mut self[begin ..]`.

Returns a slice of the given string from the byte range [`begin`, `len`). Equivalent to `&self[begin .. len]` or `&mut self[begin .. len]`.

This operation is `O(1)`.

Prior to 1.20.0, these indexing operations were still supported by direct implementation of `Index` and `IndexMut`.

Panics

Panics if `begin` does not point to the starting byte offset of a character (as defined by `is_char_boundary`), or if `begin > len`.

`type Output = str`

The output type returned by methods.

Blanket Implementations

`impl<I> IntoIterator for I where    I: Iterator, `[src]

`type Item = <I as Iterator>::Item`

The type of the elements being iterated over.

`type IntoIter = I`

Which kind of iterator are we turning this into?

`impl<T> ToOwned for T where    T: Clone, `[src]

`type Owned = T`

The resulting type after obtaining ownership.

`impl<T, U> TryFrom<U> for T where    U: Into<T>, `[src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`impl<T, U> TryInto<U> for T where    U: TryFrom<T>, `[src]

`type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

© 2010 The Rust Project Developers