# Struct std::ops::RangeFrom 1.0.0 [−] [src]

    pub struct RangeFrom<Idx> {
        pub start: Idx,
    }

A range which is only bounded below: { x | start <= x }. Use `start..` for its shorthand.

See the `contains()` method for its characterization.

Note: Currently, no overflow checking is done for the iterator implementation; if you use an integer range and the integer overflows, it might panic in debug mode or create an endless loop in release mode. This overflow behavior might change in the future.

# Examples

#![feature(iter_arith)] fn main() { assert_eq!((2..), std::ops::RangeFrom{ start: 2 }); assert_eq!(2+3+4, (2..).take(3).sum()); let arr = [0, 1, 2, 3]; assert_eq!(arr[ .. ], [0,1,2,3]); assert_eq!(arr[ ..3], [0,1,2 ]); assert_eq!(arr[1.. ], [ 1,2,3]); // RangeFrom assert_eq!(arr[1..3], [ 1,2 ]); }

    #![feature(iter_arith)]
    fn main() {
        assert_eq!((2..), std::ops::RangeFrom{ start: 2 });
        assert_eq!(2+3+4, (2..).take(3).sum());

        let arr = [0, 1, 2, 3];
        assert_eq!(arr[ .. ], [0,1,2,3]);
        assert_eq!(arr[ ..3], [0,1,2  ]);
        assert_eq!(arr[1.. ], [  1,2,3]);  // RangeFrom
        assert_eq!(arr[1..3], [  1,2  ]);
    }

## Fields

`start` | The lower bound of the range (inclusive).

## Methods

### `impl<Idx> RangeFrom<Idx> where Idx: PartialOrd<Idx>`

#### `fn contains(&self, item: Idx) -> bool`

Unstable (`range_contains` #32311)

: recently added as per RFC

# Examples

#![feature(range_contains)] fn main() { assert!( ! (3..).contains(2)); assert!( (3..).contains(3)); assert!( (3..).contains(1_000_000_000)); }

    #![feature(range_contains)]
    fn main() {
        assert!( ! (3..).contains(2));
        assert!(   (3..).contains(3));
        assert!(   (3..).contains(1_000_000_000));
    }

### `impl<A> RangeFrom<A> where A: Step`

#### `fn step_by(self, by: A) -> StepBy<A, RangeFrom<A>>`

Unstable (`step_by` #27741)

: recent addition

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

# Examples

#![feature(step_by)] fn main() { for i in (0u8..).step_by(2).take(10) { println!("{}", i); } }

    for i in (0u8..).step_by(2).take(10) {
        println!("{}", i);
    }

This prints the first ten even natural integers (0 to 18).

## Trait Implementations

### `impl<Idx> Debug for RangeFrom<Idx> where Idx: Debug`

#### `fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error>`

### `impl<A> Iterator for RangeFrom<A> where A: One + Step, &'a A: Add<&'a A>, &'a A::Output == A`

#### `type Item = A`

#### `fn next(&mut self) -> Option<A>`

#### `fn size_hint(&self) -> (usize, Option<usize>)`

#### `fn count(self) -> usize`

#### `fn last(self) -> Option<Self::Item>`

#### `fn nth(&mut self, n: usize) -> Option<Self::Item>`

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

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

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

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

#### `fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<B>`

#### `fn enumerate(self) -> Enumerate<Self>`

#### `fn peekable(self) -> Peekable<Self>`

#### `fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool`

#### `fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool`

#### `fn skip(self, n: usize) -> Skip<Self>`

#### `fn take(self, n: usize) -> Take<Self>`

#### `fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where F: FnMut(&mut St, Self::Item) -> Option<B>`

#### `fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where F: FnMut(Self::Item) -> U, U: IntoIterator`

#### `fn fuse(self) -> Fuse<Self>`

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

#### `fn by_ref(&mut self) -> &mut Self`

#### `fn collect<B>(self) -> B where B: FromIterator<Self::Item>`

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

#### `fn fold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, Self::Item) -> B`

#### `fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool`

#### `fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool`

#### `fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool`

#### `fn position<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool`

#### `fn rposition<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool, Self: ExactSizeIterator + DoubleEndedIterator`

#### `fn max(self) -> Option<Self::Item> where Self::Item: Ord`

#### `fn min(self) -> Option<Self::Item> where Self::Item: Ord`

#### `fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B`
1.6.0

#### `fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B`
1.6.0

#### `fn rev(self) -> Rev<Self> where Self: DoubleEndedIterator`

#### `fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Iterator<Item=(A, B)>`

#### `fn cloned<'a, T>(self) -> Cloned<Self> where Self: Iterator<Item=&'a T>, T: 'a + Clone`

#### `fn cycle(self) -> Cycle<Self> where Self: Clone`

#### `fn sum<S>(self) -> S where S: Add<Self::Item, Output=S> + Zero`

#### `fn product<P>(self) -> P where P: Mul<Self::Item, Output=P> + One`

#### `fn cmp<I>(self, other: I) -> Ordering where I: IntoIterator<Item=Self::Item>, Self::Item: Ord`
1.5.0

#### `fn partial_cmp<I>(self, other: I) -> Option<Ordering> where I: IntoIterator, Self::Item: PartialOrd<I::Item>`
1.5.0

#### `fn eq<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>`
1.5.0

#### `fn ne<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>`
1.5.0

#### `fn lt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>`
1.5.0

#### `fn le<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>`
1.5.0

#### `fn gt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>`
1.5.0

#### `fn ge<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>`
1.5.0

### `impl<T> RangeArgument<T> for RangeFrom<T>`

#### `fn start(&self) -> Option<&T>`

Unstable (`collections_range` #30877)

: waiting for dust to settle on inclusive ranges

### Derived Implementations

### `impl<Idx> Eq for RangeFrom<Idx> where Idx: Eq`

### `impl<Idx> PartialEq<RangeFrom<Idx>> for RangeFrom<Idx> where Idx: PartialEq<Idx>`

#### `fn eq(&self, __arg_0: &RangeFrom<Idx>) -> bool`

#### `fn ne(&self, __arg_0: &RangeFrom<Idx>) -> bool`

### `impl<Idx> Clone for RangeFrom<Idx> where Idx: Clone`

#### `fn clone(&self) -> RangeFrom<Idx>`

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

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)