# Struct bitflags::__core::ops::RangeFrom [−] [src]

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

1.0.0

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  ]);
    }

## Fields

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

## Methods

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

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

Unstable (`step_by`)

: recent addition

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

# Examples

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

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

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

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

Unstable (`range_contains`)

: 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));
    }

## Trait Implementations

### `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 F: FnMut(&Self::Item) -> bool, B: Default + Extend<Self::Item>`

#### `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 FromB: Default + Extend<B>, FromA: Default + Extend<A>, 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<Idx> Debug for RangeFrom<Idx> where Idx: Debug`

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

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

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

Unstable (`collections_range`)

: 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`)