# 1.0.0[−][src]Struct sgx_tstd::ops::Range

```pub struct Range<Idx> {
pub start: Idx,
pub end: Idx,
}```

A (half-open) range bounded inclusively below and exclusively above (`start..end`).

The `Range` `start..end` contains all values with `x >= start` and `x < end`. It is empty unless `start < end`.

# Examples

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

## Fields

`start: Idx`

The lower bound of the range (inclusive).

`end: Idx`

The upper bound of the range (exclusive).

## Methods

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

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

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

# Examples

```assert!(!(3..5).contains(&2));
assert!( (3..5).contains(&3));
assert!( (3..5).contains(&4));
assert!(!(3..5).contains(&5));

assert!(!(3..3).contains(&3));
assert!(!(3..2).contains(&3));

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

#### `pub fn is_empty(&self) -> bool`[src]

🔬 This is a nightly-only experimental API. (`range_is_empty`)

Returns `true` if the range contains no items.

# Examples

```#![feature(range_is_empty)]

assert!(!(3..5).is_empty());
assert!( (3..3).is_empty());
assert!( (3..2).is_empty());```

The range is empty if either side is incomparable:

```#![feature(range_is_empty)]

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

## Trait Implementations

### `impl Index<Range<usize>> for String`[src]

#### `type Output = str`

The returned type after indexing.

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

#### `type Item = A`

The type of the elements being iterated over.

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

#### `type Output = [T]`

The output type returned by methods.

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

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

Returns a slice of the given string from the byte range [`begin`, `end`).

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` or `end` does not point to the starting byte offset of a character (as defined by `is_char_boundary`), if `begin > end`, or if `end > len`.

# Examples

```let s = "Löwe 老虎 Léopard";
assert_eq!(&s[0 .. 1], "L");

assert_eq!(&s[1 .. 9], "öwe 老");

// these will panic:
// byte 2 lies within `ö`:
// &s[2 ..3];

// byte 8 lies within `老`
// &s[1 .. 8];

// byte 100 is outside the string
// &s[3 .. 100];```

#### `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.