self.pos
}
- /// Return a reference to the element removed
+ /// Returns a reference to the element removed.
#[inline]
fn element(&self) -> &T {
self.elt.as_ref().unwrap()
}
- /// Return a reference to the element at `index`.
+ /// Returns a reference to the element at `index`.
///
/// Unsafe because index must be within the data slice and not equal to pos.
#[inline]
}
}
- /// Returns true if the map contains a value for the specified key.
+ /// Returns `true` if the map contains a value for the specified key.
///
/// The key may be any borrowed form of the map's key type, but the ordering
/// on the borrowed form *must* match the ordering on the key type.
self.length
}
- /// Returns true if the map contains no elements.
+ /// Returns `true` if the map contains no elements.
///
/// # Examples
///
self.map.len()
}
- /// Returns true if the set contains no elements.
+ /// Returns `true` if the set contains no elements.
///
/// # Examples
///
self.bits.count_ones() as usize
}
- /// Returns true if the `EnumSet` is empty.
+ /// Returns `true` if the `EnumSet` is empty.
pub fn is_empty(&self) -> bool {
self.bits == 0
}
/// **RangeArgument** is implemented by Rust's built-in range types, produced
/// by range syntax like `..`, `a..`, `..b` or `c..d`.
pub trait RangeArgument<T: ?Sized> {
- /// Start index bound
+ /// Start index bound.
///
- /// Return start value as a `Bound`
+ /// Returns start value as a `Bound`.
///
/// # Examples
///
/// ```
fn start(&self) -> Bound<&T>;
- /// End index bound
+ /// End index bound.
///
- /// Return end value as a `Bound`
+ /// Returns end value as a `Bound`.
///
/// # Examples
///
core_slice::SliceExt::is_empty(self)
}
- /// Returns the first element of a slice, or `None` if it is empty.
+ /// Returns the first element of the slice, or `None` if it is empty.
///
/// # Examples
///
core_slice::SliceExt::first(self)
}
- /// Returns a mutable pointer to the first element of a slice, or `None` if it is empty.
+ /// Returns a mutable pointer to the first element of the slice, or `None` if it is empty.
///
/// # Examples
///
core_slice::SliceExt::first_mut(self)
}
- /// Returns the first and all the rest of the elements of a slice, or `None` if it is empty.
+ /// Returns the first and all the rest of the elements of the slice, or `None` if it is empty.
///
/// # Examples
///
core_slice::SliceExt::split_first(self)
}
- /// Returns the first and all the rest of the elements of a slice, or `None` if it is empty.
+ /// Returns the first and all the rest of the elements of the slice, or `None` if it is empty.
///
/// # Examples
///
core_slice::SliceExt::split_first_mut(self)
}
- /// Returns the last and all the rest of the elements of a slice, or `None` if it is empty.
+ /// Returns the last and all the rest of the elements of the slice, or `None` if it is empty.
///
/// # Examples
///
}
- /// Returns the last and all the rest of the elements of a slice, or `None` if it is empty.
+ /// Returns the last and all the rest of the elements of the slice, or `None` if it is empty.
///
/// # Examples
///
core_slice::SliceExt::split_last_mut(self)
}
- /// Returns the last element of a slice, or `None` if it is empty.
+ /// Returns the last element of the slice, or `None` if it is empty.
///
/// # Examples
///
core_slice::SliceExt::as_mut_ptr(self)
}
- /// Swaps two elements in a slice.
+ /// Swaps two elements in the slice.
///
/// # Arguments
///
core_slice::SliceExt::swap(self, a, b)
}
- /// Reverses the order of elements in a slice, in place.
+ /// Reverses the order of elements in the slice, in place.
///
/// # Example
///
core_slice::SliceExt::ends_with(self, needle)
}
- /// Binary search a sorted slice for a given element.
+ /// Binary searches this sorted slice for a given element.
///
/// If the value is found then `Ok` is returned, containing the
/// index of the matching element; if the value is not found then
core_slice::SliceExt::binary_search(self, x)
}
- /// Binary search a sorted slice with a comparator function.
+ /// Binary searches this sorted slice with a comparator function.
///
/// The comparator function should implement an order consistent
/// with the sort order of the underlying slice, returning an
core_slice::SliceExt::binary_search_by(self, f)
}
- /// Binary search a sorted slice with a key extraction function.
+ /// Binary searches this sorted slice with a key extraction function.
///
/// Assumes that the slice is sorted by the key, for instance with
/// [`sort_by_key`] using the same key extraction function.
merge_sort(self, |a, b| a.lt(b));
}
- /// Sorts the slice using `compare` to compare elements.
+ /// Sorts the slice with a comparator function.
///
/// This sort is stable (i.e. does not reorder equal elements) and `O(n log n)` worst-case.
///
merge_sort(self, |a, b| compare(a, b) == Less);
}
- /// Sorts the slice using `f` to extract a key to compare elements by.
+ /// Sorts the slice with a key extraction function.
///
/// This sort is stable (i.e. does not reorder equal elements) and `O(n log n)` worst-case.
///
core_slice::SliceExt::sort_unstable(self);
}
- /// Sorts the slice using `compare` to compare elements, but may not preserve the order of
- /// equal elements.
+ /// Sorts the slice with a comparator function, but may not preserve the order of equal
+ /// elements.
///
/// This sort is unstable (i.e. may reorder equal elements), in-place (i.e. does not allocate),
/// and `O(n log n)` worst-case.
core_slice::SliceExt::sort_unstable_by(self, compare);
}
- /// Sorts the slice using `f` to extract a key to compare elements by, but may not preserve the
- /// order of equal elements.
+ /// Sorts the slice with a key extraction function, but may not preserve the order of equal
+ /// elements.
///
/// This sort is unstable (i.e. may reorder equal elements), in-place (i.e. does not allocate),
/// and `O(n log n)` worst-case.
core_slice::SliceExt::copy_from_slice(self, src)
}
-
/// Copies `self` into a new `Vec`.
///
/// # Examples
core_str::StrExt::len(self)
}
- /// Returns true if this slice has a length of zero bytes.
+ /// Returns `true` if `self` has a length of zero bytes.
///
/// # Examples
///
ptr::write(self.ptr().offset(off as isize), value);
}
- /// Returns true if and only if the buffer is at capacity
+ /// Returns `true` if and only if the buffer is at full capacity.
#[inline]
fn is_full(&self) -> bool {
self.cap() - self.len() == 1
count(self.tail, self.head, self.cap())
}
- /// Returns true if the buffer contains no elements
+ /// Returns `true` if the `VecDeque` is empty.
///
/// # Examples
///
}
impl Any {
- /// Returns true if the boxed type is the same as `T`.
+ /// Returns `true` if the boxed type is the same as `T`.
///
/// # Examples
///
}
impl Ordering {
- /// Reverse the `Ordering`.
+ /// Reverses the `Ordering`.
///
/// * `Less` becomes `Greater`.
/// * `Greater` becomes `Less`.
}
}
-/// Compare and return the minimum of two values.
+/// Compares and returns the minimum of two values.
///
/// Returns the first argument if the comparison determines them to be equal.
///
if v1 <= v2 { v1 } else { v2 }
}
-/// Compare and return the maximum of two values.
+/// Compares and returns the maximum of two values.
///
/// Returns the second argument if the comparison determines them to be equal.
///
#[doc(hidden)]
pub unsafe trait TrustedRandomAccess : ExactSizeIterator {
unsafe fn get_unchecked(&mut self, i: usize) -> Self::Item;
- /// Return `true` if getting an iterator element may have
+ /// Returns `true` if getting an iterator element may have
/// side effects. Remember to take inner iterators into account.
fn may_have_side_effect() -> bool;
}
$name { size: sz, base: base }
}
- /// Return the internal digits as a slice `[a, b, c, ...]` such that the numeric
+ /// Returns the internal digits as a slice `[a, b, c, ...]` such that the numeric
/// value is `a + b * 2^W + c * 2^(2W) + ...` where `W` is the number of bits in
/// the digit type.
pub fn digits(&self) -> &[$ty] {
&self.base[..self.size]
}
- /// Return the `i`-th bit where bit 0 is the least significant one.
+ /// Returns the `i`-th bit where bit 0 is the least significant one.
/// In other words, the bit with weight `2^i`.
pub fn get_bit(&self, i: usize) -> u8 {
use mem;
((self.base[d] >> b) & 1) as u8
}
- /// Returns true if the bignum is zero.
+ /// Returns `true` if the bignum is zero.
pub fn is_zero(&self) -> bool {
self.digits().iter().all(|&v| v == 0)
}
implementable outside the standard library")]
fn one() -> Self;
- /// Returns true if this value is NaN and false otherwise.
+ /// Returns `true` if this value is NaN and false otherwise.
#[stable(feature = "core", since = "1.6.0")]
fn is_nan(self) -> bool;
- /// Returns true if this value is positive infinity or negative infinity and
+ /// Returns `true` if this value is positive infinity or negative infinity and
/// false otherwise.
#[stable(feature = "core", since = "1.6.0")]
fn is_infinite(self) -> bool;
- /// Returns true if this number is neither infinite nor NaN.
+ /// Returns `true` if this number is neither infinite nor NaN.
#[stable(feature = "core", since = "1.6.0")]
fn is_finite(self) -> bool;
- /// Returns true if this number is neither zero, infinite, denormal, or NaN.
+ /// Returns `true` if this number is neither zero, infinite, denormal, or NaN.
#[stable(feature = "core", since = "1.6.0")]
fn is_normal(self) -> bool;
/// Returns the category that this number falls into.
#[lang = "const_ptr"]
impl<T: ?Sized> *const T {
- /// Returns true if the pointer is null.
+ /// Returns `true` if the pointer is null.
///
/// # Examples
///
#[lang = "mut_ptr"]
impl<T: ?Sized> *mut T {
- /// Returns true if the pointer is null.
+ /// Returns `true` if the pointer is null.
///
/// # Examples
///
// Querying the contained values
/////////////////////////////////////////////////////////////////////////
- /// Returns true if the result is `Ok`.
+ /// Returns `true` if the result is `Ok`.
///
/// # Examples
///
}
}
- /// Returns true if the result is `Err`.
+ /// Returns `true` if the result is `Err`.
///
/// # Examples
///
trait PointerExt : Copy {
unsafe fn slice_offset(self, i: isize) -> Self;
- /// Increment self by 1, but return the old value
+ /// Increments `self` by 1, but returns the old value.
#[inline(always)]
unsafe fn post_inc(&mut self) -> Self {
let current = *self;
current
}
- /// Decrement self by 1, and return the new value
+ /// Decrements `self` by 1, and returns the new value.
#[inline(always)]
unsafe fn pre_dec(&mut self) -> Self {
*self = self.slice_offset(-1);
/// splitn, splitn_mut etc can be implemented once.
#[doc(hidden)]
trait SplitIter: DoubleEndedIterator {
- /// Mark the underlying iterator as complete, extracting the remaining
+ /// Marks the underlying iterator as complete, extracting the remaining
/// portion of the slice.
fn finish(&mut self) -> Option<Self::Item>;
}
//
extern {
- /// Call implementation provided memcmp
+ /// Calls implementation provided memcmp.
///
/// Interprets the data as u8.
///
- /// Return 0 for equal, < 0 for less than and > 0 for greater
+ /// Returns 0 for equal, < 0 for less than and > 0 for greater
/// than.
// FIXME(#32610): Return type should be c_int
fn memcmp(s1: *const u8, s2: *const u8, n: usize) -> i32;
/// Partially sorts a slice by shifting several out-of-order elements around.
///
-/// Returns true if the slice is sorted at the end. This function is `O(n)` worst-case.
+/// Returns `true` if the slice is sorted at the end. This function is `O(n)` worst-case.
#[cold]
fn partial_insertion_sort<T, F>(v: &mut [T], is_less: &mut F) -> bool
where F: FnMut(&T, &T) -> bool
}
}
-/// Chooses a pivot in `v` and returns the index and true if the slice is likely already sorted.
+/// Chooses a pivot in `v` and returns the index and `true` if the slice is likely already sorted.
///
/// Elements in `v` might be reordered in the process.
fn choose_pivot<T, F>(v: &mut [T], is_less: &mut F) -> (usize, bool)
iter: slice::Iter<'a, u8>
}
-/// Return the initial codepoint accumulator for the first byte.
+/// Returns the initial codepoint accumulator for the first byte.
/// The first byte is special, only want bottom 5 bits for width 2, 4 bits
/// for width 3, and 3 bits for width 4.
#[inline]
fn utf8_first_byte(byte: u8, width: u32) -> u32 { (byte & (0x7F >> width)) as u32 }
-/// Return the value of `ch` updated with continuation byte `byte`.
+/// Returns the value of `ch` updated with continuation byte `byte`.
#[inline]
fn utf8_acc_cont_byte(ch: u32, byte: u8) -> u32 { (ch << 6) | (byte & CONT_MASK) as u32 }
// use truncation to fit u64 into usize
const NONASCII_MASK: usize = 0x80808080_80808080u64 as usize;
-/// Return `true` if any byte in the word `x` is nonascii (>= 128).
+/// Returns `true` if any byte in the word `x` is nonascii (>= 128).
#[inline]
fn contains_nonascii(x: usize) -> bool {
(x & NONASCII_MASK) != 0
}
-/// Walk through `iter` checking that it's a valid UTF-8 sequence,
+/// Walks through `iter` checking that it's a valid UTF-8 sequence,
/// returning `true` in that case, or, if it is invalid, `false` with
/// `iter` reset such that it is pointing at the first byte in the
/// invalid sequence.
4,4,4,4,4,0,0,0,0,0,0,0,0,0,0,0, // 0xFF
];
-/// Given a first byte, determine how many bytes are in this UTF-8 character
+/// Given a first byte, determines how many bytes are in this UTF-8 character.
#[unstable(feature = "str_internals", issue = "0")]
#[inline]
pub fn utf8_char_width(b: u8) -> usize {
return UTF8_CHAR_WIDTH[b as usize] as usize;
}
-/// Mask of the value bits of a continuation byte
+/// Mask of the value bits of a continuation byte.
const CONT_MASK: u8 = 0b0011_1111;
-/// Value of the tag bits (tag mask is !CONT_MASK) of a continuation byte
+/// Value of the tag bits (tag mask is !CONT_MASK) of a continuation byte.
const TAG_CONT_U8: u8 = 0b1000_0000;
/*
projects / rust.git / commitdiff