Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://doc.rust-lang.org/nightly/std/ops/trait.RangeBounds.html below:

RangeBounds in std::ops - Rust

pub trait RangeBounds<T>{
    // Required methods
    fn start_bound(&self) -> Bound<&T>;
    fn end_bound(&self) -> Bound<&T>;

    // Provided methods
    fn contains<U>(&self, item: &U) -> bool
       where T: PartialOrd<U>,
             U: PartialOrd<T> + ?Sized { ... }
    fn is_empty(&self) -> bool
       where T: PartialOrd { ... }
}

RangeBounds is implemented by Rust’s built-in range types, produced by range syntax like .., a.., ..b, ..=c, d..e, or f..=g.

Start index bound.

Returns the start value as a Bound.

use std::ops::Bound::*;
use std::ops::RangeBounds;

assert_eq!((..10).start_bound(), Unbounded);
assert_eq!((3..10).start_bound(), Included(&3));

End index bound.

Returns the end value as a Bound.

use std::ops::Bound::*;
use std::ops::RangeBounds;

assert_eq!((3..).end_bound(), Unbounded);
assert_eq!((3..10).end_bound(), Excluded(&10));

Returns true if item is contained in the range.

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

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

Returns true if the range contains no items. One-sided ranges (RangeFrom, etc) always return false.

#![feature(range_bounds_is_empty)]
use std::ops::RangeBounds;

assert!(!(3..).is_empty());
assert!(!(..2).is_empty());
assert!(!RangeBounds::is_empty(&(3..5)));
assert!( RangeBounds::is_empty(&(3..3)));
assert!( RangeBounds::is_empty(&(3..2)));

The range is empty if either side is incomparable:

#![feature(range_bounds_is_empty)]
use std::ops::RangeBounds;

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

But never empty if either side is unbounded:

#![feature(range_bounds_is_empty)]
use std::ops::RangeBounds;

assert!(!(..0).is_empty());
assert!(!(i32::MAX..).is_empty());
assert!(!RangeBounds::<u8>::is_empty(&(..)));

(Excluded(a), Excluded(b)) is only empty if a >= b:

#![feature(range_bounds_is_empty)]
use std::ops::Bound::*;
use std::ops::RangeBounds;

assert!(!(Excluded(1), Excluded(3)).is_empty());
assert!(!(Excluded(1), Excluded(2)).is_empty());
assert!( (Excluded(1), Excluded(1)).is_empty());
assert!( (Excluded(2), Excluded(1)).is_empty());
assert!( (Excluded(3), Excluded(1)).is_empty());

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

If you need to use this implementation where T is unsized, consider using the RangeBounds impl for a 2-tuple of Bound<&T>, i.e. replace start..end with (Bound::Included(start), Bound::Excluded(end)).

If you need to use this implementation where T is unsized, consider using the RangeBounds impl for a 2-tuple of Bound<&T>, i.e. replace start.. with (Bound::Included(start), Bound::Unbounded).

If you need to use this implementation where T is unsized, consider using the RangeBounds impl for a 2-tuple of Bound<&T>, i.e. replace start..=end with (Bound::Included(start), Bound::Included(end)).

If you need to use this implementation where T is unsized, consider using the RangeBounds impl for a 2-tuple of Bound<&T>, i.e. replace start..end with (Bound::Included(start), Bound::Excluded(end)).

If you need to use this implementation where T is unsized, consider using the RangeBounds impl for a 2-tuple of Bound<&T>, i.e. replace start.. with (Bound::Included(start), Bound::Unbounded).

If you need to use this implementation where T is unsized, consider using the RangeBounds impl for a 2-tuple of Bound<&T>, i.e. replace start..=end with (Bound::Included(start), Bound::Included(end)).

If you need to use this implementation where T is unsized, consider using the RangeBounds impl for a 2-tuple of Bound<&T>, i.e. replace ..end with (Bound::Unbounded, Bound::Excluded(end)).

If you need to use this implementation where T is unsized, consider using the RangeBounds impl for a 2-tuple of Bound<&T>, i.e. replace ..=end with (Bound::Unbounded, Bound::Included(end)).

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4