Rust Search
Find the best content on Rust, curated by the community; a
search engine for Rustaceans.
pub const fn wrapping_shl(self, rhs: u32) -> Self...Instead, the behaviour of this method matches what shift instructions do on many processors, and is what the << operator does when overflow checks are disabled, but numerically it's weird. Consider, instead, using Self::unbounded_shl which has nicer behaviour.
Note that this is not the same as a rotate...
pub const fn wrapping_shl(self, rhs: u32) -> Self...Instead, the behaviour of this method matches what shift instructions do on many processors, and is what the << operator does when overflow checks are disabled, but numerically it's weird. Consider, instead, using Self::unbounded_shl which has nicer behaviour.
Note that this is not the same as a rotate...
pub const fn wrapping_shl(self, rhs: u32) -> Self...Instead, the behaviour of this method matches what shift instructions do on many processors, and is what the << operator does when overflow checks are disabled, but numerically it's weird. Consider, instead, using Self::unbounded_shl which has nicer behaviour.
Note that this is not the same as a rotate...
pub const fn wrapping_shl(self, rhs: u32) -> Self...Instead, the behaviour of this method matches what shift instructions do on many processors, and is what the << operator does when overflow checks are disabled, but numerically it's weird. Consider, instead, using Self::unbounded_shl which has nicer behaviour.
Note that this is not the same as a rotate...
pub const fn wrapping_shl(self, rhs: u32) -> Self...Instead, the behaviour of this method matches what shift instructions do on many processors, and is what the << operator does when overflow checks are disabled, but numerically it's weird. Consider, instead, using Self::unbounded_shl which has nicer behaviour.
Note that this is not the same as a rotate...
pub const fn wrapping_shl(self, rhs: u32) -> Self...Instead, the behaviour of this method matches what shift instructions do on many processors, and is what the << operator does when overflow checks are disabled, but numerically it's weird. Consider, instead, using Self::unbounded_shl which has nicer behaviour.
Note that this is not the same as a rotate...
pub const fn wrapping_shr(self, rhs: u32) -> Self...Instead, the behaviour of this method matches what shift instructions do on many processors, and is what the >> operator does when overflow checks are disabled, but numerically it's weird. Consider, instead, using Self::unbounded_shr which has nicer behaviour.
Note that this is not the same as a rotate...
pub const fn wrapping_shr(self, rhs: u32) -> Self...Instead, the behaviour of this method matches what shift instructions do on many processors, and is what the >> operator does when overflow checks are disabled, but numerically it's weird. Consider, instead, using Self::unbounded_shr which has nicer behaviour.
Note that this is not the same as a rotate...
pub const fn wrapping_shr(self, rhs: u32) -> Self...Instead, the behaviour of this method matches what shift instructions do on many processors, and is what the >> operator does when overflow checks are disabled, but numerically it's weird. Consider, instead, using Self::unbounded_shr which has nicer behaviour.
Note that this is not the same as a rotate...
pub const fn wrapping_shr(self, rhs: u32) -> Self...Instead, the behaviour of this method matches what shift instructions do on many processors, and is what the >> operator does when overflow checks are disabled, but numerically it's weird. Consider, instead, using Self::unbounded_shr which has nicer behaviour.
Note that this is not the same as a rotate...
pub const fn wrapping_shr(self, rhs: u32) -> Self...Instead, the behaviour of this method matches what shift instructions do on many processors, and is what the >> operator does when overflow checks are disabled, but numerically it's weird. Consider, instead, using Self::unbounded_shr which has nicer behaviour.
Note that this is not the same as a rotate...
pub const fn wrapping_shr(self, rhs: u32) -> Self...Instead, the behaviour of this method matches what shift instructions do on many processors, and is what the >> operator does when overflow checks are disabled, but numerically it's weird. Consider, instead, using Self::unbounded_shr which has nicer behaviour.
Note that this is not the same as a rotate...
pub const fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering...The interpretation of the signaling NaN bit follows the definition in the IEEE 754 standard, which may not match the interpretation by some of the older, non-conformant (e.g. MIPS) hardware implementations.
Example
struct GoodBoy {
name: String,
weight: f32,
}
let mut bois = vec![
GoodBoy { name: "Pucci".to_owned(), weight...
pub const fn total_cmp(&self, other: &Self) -> crate::cmp::Ordering...The interpretation of the signaling NaN bit follows the definition in the IEEE 754 standard, which may not match the interpretation by some of the older, non-conformant (e.g. MIPS) hardware implementations.
Example
struct GoodBoy {
name: String,
weight: f64,
}
let mut bois = vec![
GoodBoy { name: "Pucci".to_owned(), weight...
pub const fn partition_point<P>(&self, pred: P) -> usize...Examples
let v = [1, 2, 3, 3, 5, 6, 7];
let i = v.partition_point(|&x| x < 5);
assert_eq!(i, 4);
assert!(v[..i].iter().all(|&x| x < 5));
assert!(v[i..].iter().all(|&x| !(x < 5)));
If all elements of the slice match the predicate, including if the...
pub mod iter...let values = vec![1, 2, 3, 4, 5];
{
let result = match IntoIterator::into_iter(values) {
mut iter => loop {
let next;
match iter.next() {
Some(val) => next = val,
None => break,
};
let x = next;
let () = { println!("{x}"); };
},
};
result
}
First, we call into_iter() on the value. Then, we match on the iterator...
pub unsafe fn from_raw(ptr: *mut c_char) -> CString...It should be noted that the length isn't just "recomputed," but that the recomputed length must match the original length from the CString::into_raw call. This means the CString::into_raw/from_raw methods should not be used when passing the string to C functions that can modify...
pub fn try_lock_shared(&self) -> Result<(), TryLockError>...Examples
use std::fs::{File, TryLockError};
fn main() -> std::io::Result<()> {
let f = File::open("foo.txt")?;
// Explicit handling of the WouldBlock error
match f.try_lock_shared() {
Ok(_) => (),
Err(TryLockError::WouldBlock) => (), // Lock not acquired
Err(TryLockError::Error(err)) => return Err(err),
}
// Alternately, propagate the error as an io::Error...
pub fn try_lock(&self) -> Result<(), TryLockError>...Examples
use std::fs::{File, TryLockError};
fn main() -> std::io::Result<()> {
let f = File::create("foo.txt")?;
// Explicit handling of the WouldBlock error
match f.try_lock() {
Ok(_) => (),
Err(TryLockError::WouldBlock) => (), // Lock not acquired
Err(TryLockError::Error(err)) => return Err(err),
}
// Alternately, propagate the error as an io::Error
f...
pub trait Wake...loop {
match fut.as_mut().poll(&mut cx) {
Poll::Ready(res) => return res,
Poll::Pending => thread::park(),
}
}
}
block_on(async {
println!("Hi from inside a future!");
});
"Freedom to shoot yourself in the foot is not a rust marketing point 😉"