Trait ethers::core::k256::elliptic_curve::ops::Sub 1.0.0[−][src]
Expand description
The subtraction operator -
.
Note that Rhs
is Self
by default, but this is not mandatory. For
example, std::time::SystemTime
implements Sub<Duration>
, which permits
operations of the form SystemTime = SystemTime - Duration
.
Examples
Sub
tractable points
use std::ops::Sub;
#[derive(Debug, Copy, Clone, PartialEq)]
struct Point {
x: i32,
y: i32,
}
impl Sub for Point {
type Output = Self;
fn sub(self, other: Self) -> Self::Output {
Self {
x: self.x - other.x,
y: self.y - other.y,
}
}
}
assert_eq!(Point { x: 3, y: 3 } - Point { x: 2, y: 3 },
Point { x: 1, y: 0 });
Implementing Sub
with generics
Here is an example of the same Point
struct implementing the Sub
trait
using generics.
use std::ops::Sub;
#[derive(Debug, PartialEq)]
struct Point<T> {
x: T,
y: T,
}
// Notice that the implementation uses the associated type `Output`.
impl<T: Sub<Output = T>> Sub for Point<T> {
type Output = Self;
fn sub(self, other: Self) -> Self::Output {
Point {
x: self.x - other.x,
y: self.y - other.y,
}
}
}
assert_eq!(Point { x: 2, y: 3 } - Point { x: 1, y: 0 },
Point { x: 1, y: 3 });
Associated Types
Required methods
Implementations on Foreign Types
Returns the difference of self
and rhs
as a new HashSet<T, S>
.
Examples
use std::collections::HashSet;
let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
let b: HashSet<_> = vec![3, 4, 5].into_iter().collect();
let set = &a - &b;
let mut i = 0;
let expected = [1, 2];
for x in &set {
assert!(expected.contains(x));
i += 1;
}
assert_eq!(i, expected.len());
type Output = SystemTime
type Output = <Saturating<i128> as Sub<Saturating<i128>>>::Output
pub fn sub(
self,
other: Saturating<i128>
) -> <Saturating<i128> as Sub<Saturating<i128>>>::Output
type Output = <Saturating<i128> as Sub<Saturating<i128>>>::Output
pub fn sub(
self,
other: &Saturating<i128>
) -> <Saturating<i128> as Sub<Saturating<i128>>>::Output
type Output = Saturating<u16>
type Output = <Saturating<i32> as Sub<Saturating<i32>>>::Output
type Output = <Saturating<i32> as Sub<Saturating<i32>>>::Output
pub fn sub(
self,
other: &Saturating<i32>
) -> <Saturating<i32> as Sub<Saturating<i32>>>::Output
type Output = <Saturating<i16> as Sub<Saturating<i16>>>::Output
pub fn sub(
self,
other: &Saturating<i16>
) -> <Saturating<i16> as Sub<Saturating<i16>>>::Output
type Output = <Saturating<usize> as Sub<Saturating<usize>>>::Output
pub fn sub(
self,
other: &Saturating<usize>
) -> <Saturating<usize> as Sub<Saturating<usize>>>::Output
type Output = <Saturating<u32> as Sub<Saturating<u32>>>::Output
type Output = Saturating<i8>
type Output = <Saturating<u16> as Sub<Saturating<u16>>>::Output
type Output = <Saturating<u8> as Sub<Saturating<u8>>>::Output
type Output = <Saturating<isize> as Sub<Saturating<isize>>>::Output
pub fn sub(
self,
other: &Saturating<isize>
) -> <Saturating<isize> as Sub<Saturating<isize>>>::Output
type Output = Saturating<i128>
type Output = <Saturating<i16> as Sub<Saturating<i16>>>::Output
pub fn sub(
self,
other: &Saturating<i16>
) -> <Saturating<i16> as Sub<Saturating<i16>>>::Output
type Output = Saturating<i16>
type Output = Saturating<isize>
type Output = <Saturating<u64> as Sub<Saturating<u64>>>::Output
pub fn sub(
self,
other: &Saturating<u64>
) -> <Saturating<u64> as Sub<Saturating<u64>>>::Output
type Output = Saturating<u32>
type Output = <Saturating<u16> as Sub<Saturating<u16>>>::Output
pub fn sub(
self,
other: &Saturating<u16>
) -> <Saturating<u16> as Sub<Saturating<u16>>>::Output
type Output = Saturating<u64>
type Output = <Saturating<usize> as Sub<Saturating<usize>>>::Output
pub fn sub(
self,
other: &Saturating<usize>
) -> <Saturating<usize> as Sub<Saturating<usize>>>::Output
type Output = <Saturating<u64> as Sub<Saturating<u64>>>::Output
pub fn sub(
self,
other: &Saturating<u64>
) -> <Saturating<u64> as Sub<Saturating<u64>>>::Output
type Output = Saturating<u128>
type Output = <Saturating<i128> as Sub<Saturating<i128>>>::Output
pub fn sub(
self,
other: &Saturating<i128>
) -> <Saturating<i128> as Sub<Saturating<i128>>>::Output
type Output = <Saturating<u32> as Sub<Saturating<u32>>>::Output
pub fn sub(
self,
other: &Saturating<u32>
) -> <Saturating<u32> as Sub<Saturating<u32>>>::Output
type Output = <Saturating<isize> as Sub<Saturating<isize>>>::Output
pub fn sub(
self,
other: Saturating<isize>
) -> <Saturating<isize> as Sub<Saturating<isize>>>::Output
type Output = Saturating<u8>
type Output = <Saturating<u64> as Sub<Saturating<u64>>>::Output
type Output = <Saturating<i8> as Sub<Saturating<i8>>>::Output
type Output = <Saturating<u8> as Sub<Saturating<u8>>>::Output
type Output = <Saturating<i16> as Sub<Saturating<i16>>>::Output
type Output = <Saturating<i64> as Sub<Saturating<i64>>>::Output
pub fn sub(
self,
other: &Saturating<i64>
) -> <Saturating<i64> as Sub<Saturating<i64>>>::Output
type Output = Saturating<usize>
type Output = <Saturating<i64> as Sub<Saturating<i64>>>::Output
type Output = <Saturating<i8> as Sub<Saturating<i8>>>::Output
type Output = <Saturating<i32> as Sub<Saturating<i32>>>::Output
pub fn sub(
self,
other: &Saturating<i32>
) -> <Saturating<i32> as Sub<Saturating<i32>>>::Output
type Output = <Saturating<i64> as Sub<Saturating<i64>>>::Output
pub fn sub(
self,
other: &Saturating<i64>
) -> <Saturating<i64> as Sub<Saturating<i64>>>::Output
type Output = Saturating<i32>
type Output = <Saturating<usize> as Sub<Saturating<usize>>>::Output
pub fn sub(
self,
other: Saturating<usize>
) -> <Saturating<usize> as Sub<Saturating<usize>>>::Output
type Output = <Saturating<u32> as Sub<Saturating<u32>>>::Output
pub fn sub(
self,
other: &Saturating<u32>
) -> <Saturating<u32> as Sub<Saturating<u32>>>::Output
type Output = <Saturating<u128> as Sub<Saturating<u128>>>::Output
pub fn sub(
self,
other: &Saturating<u128>
) -> <Saturating<u128> as Sub<Saturating<u128>>>::Output
type Output = <Saturating<u128> as Sub<Saturating<u128>>>::Output
pub fn sub(
self,
other: Saturating<u128>
) -> <Saturating<u128> as Sub<Saturating<u128>>>::Output
type Output = <Saturating<isize> as Sub<Saturating<isize>>>::Output
pub fn sub(
self,
other: &Saturating<isize>
) -> <Saturating<isize> as Sub<Saturating<isize>>>::Output
type Output = <Saturating<u8> as Sub<Saturating<u8>>>::Output
type Output = <Saturating<u128> as Sub<Saturating<u128>>>::Output
pub fn sub(
self,
other: &Saturating<u128>
) -> <Saturating<u128> as Sub<Saturating<u128>>>::Output
type Output = Saturating<i64>
type Output = <Saturating<i8> as Sub<Saturating<i8>>>::Output
type Output = <Saturating<u16> as Sub<Saturating<u16>>>::Output
pub fn sub(
self,
other: &Saturating<u16>
) -> <Saturating<u16> as Sub<Saturating<u16>>>::Output
Returns the difference of self
and rhs
as a new BTreeSet<T>
.
Examples
use std::collections::BTreeSet;
let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect();
let b: BTreeSet<_> = vec![3, 4, 5].into_iter().collect();
let result = &a - &b;
let result_vec: Vec<_> = result.into_iter().collect();
assert_eq!(result_vec, [1, 2]);
type Output = ScalarCore<C>
type Output = ScalarCore<C>
impl<'_, '_, T, S1, S2> Sub<&'_ IndexSet<T, S2>> for &'_ IndexSet<T, S1> where
T: Eq + Hash + Clone,
S1: BuildHasher + Default,
S2: BuildHasher,
impl<'_, '_, T, S1, S2> Sub<&'_ IndexSet<T, S2>> for &'_ IndexSet<T, S1> where
T: Eq + Hash + Clone,
S1: BuildHasher + Default,
S2: BuildHasher,
pub fn sub(self, rhs: &HashSet<T, S, Global>) -> HashSet<T, S, Global>
pub fn sub(self, rhs: &HashSet<T, S, Global>) -> HashSet<T, S, Global>
Returns the difference of self
and rhs
as a new HashSet<T, S>
.
Examples
use hashbrown::HashSet;
let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
let b: HashSet<_> = vec![3, 4, 5].into_iter().collect();
let set = &a - &b;
let mut i = 0;
let expected = [1, 2];
for x in &set {
assert!(expected.contains(x));
i += 1;
}
assert_eq!(i, expected.len());
type Output = HashSet<T, S, Global>
Returns the set difference of the two sets of flags.
type Output = SslSessionCacheMode
Returns the set difference of the two sets of flags.
type Output = ShutdownState
Returns the set difference of the two sets of flags.
type Output = X509CheckFlags
Returns the set difference of the two sets of flags.
type Output = SslVerifyMode
Returns the set difference of the two sets of flags.
type Output = X509VerifyFlags
Returns the set difference of the two sets of flags.
type Output = Pkcs7Flags
Returns the set difference of the two sets of flags.
type Output = ExtensionContext
Returns the set difference of the two sets of flags.
type Output = CMSOptions
Returns the set difference of the two sets of flags.
type Output = SslOptions
impl<O, T> Sub<BitVec<O, T>> for BitVec<O, T> where
O: BitOrder,
T: BitStore,
impl<O, T> Sub<BitVec<O, T>> for BitVec<O, T> where
O: BitOrder,
T: BitStore,
Subtracts one BitVec
from another assuming 2’s-complement encoding.
Subtraction is a more complex operation than addition. The bit-level work is largely the same, but semantic distinctions must be made. Unlike addition, which is commutative and tolerant of switching the order of the addends, subtraction cannot swap the minuend (LHS) and subtrahend (RHS).
Because of the properties of 2’s-complement arithmetic, M - S is equivalent to M + (!S + 1). Subtraction therefore bitflips the subtrahend and adds one. This may, in a degenerate case, cause the subtrahend to increase in length.
Once the subtrahend is stable, the minuend zero-extends its left side in order
to match the length of the subtrahend if needed (this is provided by the >>
operator).
When the minuend is stable, the minuend and subtrahend are added together by the
<BitVec as Add>
implementation. The output will be encoded in 2’s-complement,
so a leading one means that the output is considered negative.
Interpreting the contents of a BitVec
as an integer is beyond the scope of
this crate.
Numeric arithmetic is provided on BitVec
as a convenience. Serious numeric
computation on variable-length integers should use the num_bigint
crate
instead, which is written specifically for that use case. BitVec
s are not
intended for arithmetic, and bitvec
makes no guarantees about sustained
correctness in arithmetic at this time.
Subtracts one BitVec
from another.
Examples
Minuend larger than subtrahend, positive difference.
use bitvec::prelude::*;
let a = bitvec![1, 0];
let b = bitvec![ 1];
let c = a - b;
assert_eq!(bitvec![0, 1], c);
Minuend smaller than subtrahend, negative difference.
use bitvec::prelude::*;
let a = bitvec![ 1];
let b = bitvec![1, 0];
let c = a - b;
assert_eq!(bitvec![1, 1], c);
Subtraction from self is correctly handled.
use bitvec::prelude::*;
let a = bitvec![0, 1, 1, 0];
let b = a.clone();
let c = a - b;
assert!(c.not_any(), "{:?}", c);
type Output = BitVec<O, T>
type Output = NaiveDateTime
A subtraction of Duration
from NaiveTime
wraps around and never overflows or underflows.
In particular the addition ignores integral number of days.
It is the same as the addition with a negated Duration
.
As a part of Chrono’s leap second handling,
the addition assumes that there is no leap second ever,
except when the NaiveTime
itself represents a leap second
in which case the assumption becomes that there is exactly a single leap second ever.
Example
use chrono::{Duration, NaiveTime};
let from_hmsm = NaiveTime::from_hms_milli;
assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::zero(), from_hmsm(3, 5, 7, 0));
assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(1), from_hmsm(3, 5, 6, 0));
assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(60 + 5), from_hmsm(3, 4, 2, 0));
assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(2*60*60 + 6*60), from_hmsm(0, 59, 7, 0));
assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::milliseconds(80), from_hmsm(3, 5, 6, 920));
assert_eq!(from_hmsm(3, 5, 7, 950) - Duration::milliseconds(280), from_hmsm(3, 5, 7, 670));
The subtraction wraps around.
assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::seconds(8*60*60), from_hmsm(19, 5, 7, 0));
assert_eq!(from_hmsm(3, 5, 7, 0) - Duration::days(800), from_hmsm(3, 5, 7, 0));
Leap seconds are handled, but the subtraction assumes that it is the only leap second happened.
let leap = from_hmsm(3, 5, 59, 1_300);
assert_eq!(leap - Duration::zero(), from_hmsm(3, 5, 59, 1_300));
assert_eq!(leap - Duration::milliseconds(200), from_hmsm(3, 5, 59, 1_100));
assert_eq!(leap - Duration::milliseconds(500), from_hmsm(3, 5, 59, 800));
assert_eq!(leap - Duration::seconds(60), from_hmsm(3, 5, 0, 300));
assert_eq!(leap - Duration::days(1), from_hmsm(3, 6, 0, 300));
Subtracts another NaiveTime
from the current time.
Returns a Duration
within +/- 1 day.
This does not overflow or underflow at all.
As a part of Chrono’s leap second handling,
the subtraction assumes that there is no leap second ever,
except when any of the NaiveTime
s themselves represents a leap second
in which case the assumption becomes that
there are exactly one (or two) leap second(s) ever.
The implementation is a wrapper around
NaiveTime::signed_duration_since
.
Example
use chrono::{Duration, NaiveTime};
let from_hmsm = NaiveTime::from_hms_milli;
assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 5, 7, 900), Duration::zero());
assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 5, 7, 875), Duration::milliseconds(25));
assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 5, 6, 925), Duration::milliseconds(975));
assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 5, 0, 900), Duration::seconds(7));
assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(3, 0, 7, 900), Duration::seconds(5 * 60));
assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(0, 5, 7, 900), Duration::seconds(3 * 3600));
assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(4, 5, 7, 900), Duration::seconds(-3600));
assert_eq!(from_hmsm(3, 5, 7, 900) - from_hmsm(2, 4, 6, 800),
Duration::seconds(3600 + 60 + 1) + Duration::milliseconds(100));
Leap seconds are handled, but the subtraction assumes that there were no other leap seconds happened.
assert_eq!(from_hmsm(3, 0, 59, 1_000) - from_hmsm(3, 0, 59, 0), Duration::seconds(1));
assert_eq!(from_hmsm(3, 0, 59, 1_500) - from_hmsm(3, 0, 59, 0),
Duration::milliseconds(1500));
assert_eq!(from_hmsm(3, 0, 59, 1_000) - from_hmsm(3, 0, 0, 0), Duration::seconds(60));
assert_eq!(from_hmsm(3, 0, 0, 0) - from_hmsm(2, 59, 59, 1_000), Duration::seconds(1));
assert_eq!(from_hmsm(3, 0, 59, 1_000) - from_hmsm(2, 59, 59, 1_000),
Duration::seconds(61));
A subtraction of Duration
from NaiveDateTime
yields another NaiveDateTime
.
It is the same as the addition with a negated Duration
.
As a part of Chrono’s leap second handling,
the addition assumes that there is no leap second ever,
except when the NaiveDateTime
itself represents a leap second
in which case the assumption becomes that there is exactly a single leap second ever.
Panics on underflow or overflow.
Use NaiveDateTime::checked_sub_signed
to detect that.
Example
use chrono::{Duration, NaiveDate};
let from_ymd = NaiveDate::from_ymd;
let d = from_ymd(2016, 7, 8);
let hms = |h, m, s| d.and_hms(h, m, s);
assert_eq!(hms(3, 5, 7) - Duration::zero(), hms(3, 5, 7));
assert_eq!(hms(3, 5, 7) - Duration::seconds(1), hms(3, 5, 6));
assert_eq!(hms(3, 5, 7) - Duration::seconds(-1), hms(3, 5, 8));
assert_eq!(hms(3, 5, 7) - Duration::seconds(3600 + 60), hms(2, 4, 7));
assert_eq!(hms(3, 5, 7) - Duration::seconds(86_400),
from_ymd(2016, 7, 7).and_hms(3, 5, 7));
assert_eq!(hms(3, 5, 7) - Duration::days(365),
from_ymd(2015, 7, 9).and_hms(3, 5, 7));
let hmsm = |h, m, s, milli| d.and_hms_milli(h, m, s, milli);
assert_eq!(hmsm(3, 5, 7, 450) - Duration::milliseconds(670), hmsm(3, 5, 6, 780));
Leap seconds are handled, but the subtraction assumes that it is the only leap second happened.
let leap = hmsm(3, 5, 59, 1_300);
assert_eq!(leap - Duration::zero(), hmsm(3, 5, 59, 1_300));
assert_eq!(leap - Duration::milliseconds(200), hmsm(3, 5, 59, 1_100));
assert_eq!(leap - Duration::milliseconds(500), hmsm(3, 5, 59, 800));
assert_eq!(leap - Duration::seconds(60), hmsm(3, 5, 0, 300));
assert_eq!(leap - Duration::days(1),
from_ymd(2016, 7, 7).and_hms_milli(3, 6, 0, 300));
type Output = NaiveDateTime
Subtracts another NaiveDate
from the current date.
Returns a Duration
of integral numbers.
This does not overflow or underflow at all,
as all possible output fits in the range of Duration
.
The implementation is a wrapper around
NaiveDate::signed_duration_since
.
Example
use chrono::{Duration, NaiveDate};
let from_ymd = NaiveDate::from_ymd;
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2014, 1, 1), Duration::zero());
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 12, 31), Duration::days(1));
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2014, 1, 2), Duration::days(-1));
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 9, 23), Duration::days(100));
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2013, 1, 1), Duration::days(365));
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(2010, 1, 1), Duration::days(365*4 + 1));
assert_eq!(from_ymd(2014, 1, 1) - from_ymd(1614, 1, 1), Duration::days(365*400 + 97));
Subtracts another NaiveDateTime
from the current date and time.
This does not overflow or underflow at all.
As a part of Chrono’s leap second handling,
the subtraction assumes that there is no leap second ever,
except when any of the NaiveDateTime
s themselves represents a leap second
in which case the assumption becomes that
there are exactly one (or two) leap second(s) ever.
The implementation is a wrapper around
NaiveDateTime::signed_duration_since
.
Example
use chrono::{Duration, NaiveDate};
let from_ymd = NaiveDate::from_ymd;
let d = from_ymd(2016, 7, 8);
assert_eq!(d.and_hms(3, 5, 7) - d.and_hms(2, 4, 6), Duration::seconds(3600 + 60 + 1));
// July 8 is 190th day in the year 2016
let d0 = from_ymd(2016, 1, 1);
assert_eq!(d.and_hms_milli(0, 7, 6, 500) - d0.and_hms(0, 0, 0),
Duration::seconds(189 * 86_400 + 7 * 60 + 6) + Duration::milliseconds(500));
Leap seconds are handled, but the subtraction assumes that there were no other leap seconds happened.
let leap = from_ymd(2015, 6, 30).and_hms_milli(23, 59, 59, 1_500);
assert_eq!(leap - from_ymd(2015, 6, 30).and_hms(23, 0, 0),
Duration::seconds(3600) + Duration::milliseconds(500));
assert_eq!(from_ymd(2015, 7, 1).and_hms(1, 0, 0) - leap,
Duration::seconds(3600) - Duration::milliseconds(500));
A subtraction of Duration
from NaiveDate
discards the fractional days,
rounding to the closest integral number of days towards Duration::zero()
.
It is the same as the addition with a negated Duration
.
Panics on underflow or overflow.
Use NaiveDate::checked_sub_signed
to detect that.
Example
use chrono::{Duration, NaiveDate};
let from_ymd = NaiveDate::from_ymd;
assert_eq!(from_ymd(2014, 1, 1) - Duration::zero(), from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) - Duration::seconds(86399), from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) - Duration::seconds(-86399), from_ymd(2014, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(1), from_ymd(2013, 12, 31));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(-1), from_ymd(2014, 1, 2));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(364), from_ymd(2013, 1, 2));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(365*4 + 1), from_ymd(2010, 1, 1));
assert_eq!(from_ymd(2014, 1, 1) - Duration::days(365*400 + 97), from_ymd(1614, 1, 1));
type Output = SteadyTime
impl Sub<InputFlags> for InputFlags
impl Sub<InputFlags> for InputFlags
impl Sub<MapFlags> for MapFlags
impl Sub<MapFlags> for MapFlags
impl Sub<MlockAllFlags> for MlockAllFlags
impl Sub<MlockAllFlags> for MlockAllFlags
impl Sub<SaFlags> for SaFlags
impl Sub<SaFlags> for SaFlags
impl Sub<SfdFlags> for SfdFlags
impl Sub<SfdFlags> for SfdFlags
impl Sub<FdFlag> for FdFlag
impl Sub<FdFlag> for FdFlag
impl Sub<CloneFlags> for CloneFlags
impl Sub<CloneFlags> for CloneFlags
impl Sub<SFlag> for SFlag
impl Sub<SFlag> for SFlag
impl Sub<MsgFlags> for MsgFlags
impl Sub<MsgFlags> for MsgFlags
impl Sub<MemFdCreateFlag> for MemFdCreateFlag
impl Sub<MemFdCreateFlag> for MemFdCreateFlag
impl Sub<ModuleInitFlags> for ModuleInitFlags
impl Sub<ModuleInitFlags> for ModuleInitFlags
impl Sub<Mode> for Mode
impl Sub<Mode> for Mode
impl Sub<FdFlag> for FdFlag
impl Sub<FdFlag> for FdFlag
impl Sub<MsFlags> for MsFlags
impl Sub<MsFlags> for MsFlags
impl Sub<ControlFlags> for ControlFlags
impl Sub<ControlFlags> for ControlFlags
impl Sub<OutputFlags> for OutputFlags
impl Sub<OutputFlags> for OutputFlags
impl Sub<EpollCreateFlags> for EpollCreateFlags
impl Sub<EpollCreateFlags> for EpollCreateFlags
impl Sub<AtFlags> for AtFlags
impl Sub<AtFlags> for AtFlags
impl Sub<SealFlag> for SealFlag
impl Sub<SealFlag> for SealFlag
impl Sub<EfdFlags> for EfdFlags
impl Sub<EfdFlags> for EfdFlags
impl Sub<EventFlags> for EventFlags
impl Sub<EventFlags> for EventFlags
impl Sub<SockFlag> for SockFlag
impl Sub<SockFlag> for SockFlag
impl Sub<EpollFlags> for EpollFlags
impl Sub<EpollFlags> for EpollFlags
impl Sub<MsFlags> for MsFlags
impl Sub<MsFlags> for MsFlags
impl Sub<MntFlags> for MntFlags
impl Sub<MntFlags> for MntFlags
impl Sub<MQ_OFlag> for MQ_OFlag
impl Sub<MQ_OFlag> for MQ_OFlag
impl Sub<LocalFlags> for LocalFlags
impl Sub<LocalFlags> for LocalFlags
impl Sub<InterfaceFlags> for InterfaceFlags
impl Sub<InterfaceFlags> for InterfaceFlags
impl Sub<QuotaValidFlags> for QuotaValidFlags
impl Sub<QuotaValidFlags> for QuotaValidFlags
impl Sub<WaitPidFlag> for WaitPidFlag
impl Sub<WaitPidFlag> for WaitPidFlag
impl Sub<DeleteModuleFlags> for DeleteModuleFlags
impl Sub<DeleteModuleFlags> for DeleteModuleFlags
impl Sub<OFlag> for OFlag
impl Sub<OFlag> for OFlag
impl Sub<ProtFlags> for ProtFlags
impl Sub<ProtFlags> for ProtFlags
impl Sub<FallocateFlags> for FallocateFlags
impl Sub<FallocateFlags> for FallocateFlags
impl Sub<Options> for Options
impl Sub<Options> for Options
impl Sub<FsFlags> for FsFlags
impl Sub<FsFlags> for FsFlags
impl Sub<SpliceFFlags> for SpliceFFlags
impl Sub<SpliceFFlags> for SpliceFFlags
Implementors
type Output = Capability
type Output = ProjectivePoint
type Output = ProjectivePoint
type Output = ProjectivePoint
type Output = ProjectivePoint
type Output = ProjectivePoint
type Output = ProjectivePoint
UInt<U, B0> - B1 = UInt<U - B1, B1>
NInt - Z0 = NInt
PInt - Z0 = PInt
UInt - B0 = UInt
UInt<U, B1> - B1 = UInt<U, B0>
Subtracting unsigned integers. We just do our PrivateSub
and then Trim
the output.
N(Ul) - N(Ur)
: We resolve this with our PrivateAdd
P(Ul) - N(Ur) = P(Ul + Ur)
N(Ul) - P(Ur) = N(Ul + Ur)
P(Ul) - P(Ur)
: We resolve this with our PrivateAdd