Trait scale_info::prelude::ops::Not

1.0.0 · source · [−]

pub trait Not {
    type Output;
    fn not(self) -> Self::Output;
}

Expand description

The unary logical negation operator !.

Examples

An implementation of Not for Answer, which enables the use of ! to invert its value.

use std::ops::Not;

#[derive(Debug, PartialEq)]
enum Answer {
    Yes,
    No,
}

impl Not for Answer {
    type Output = Self;

    fn not(self) -> Self::Output {
        match self {
            Answer::Yes => Answer::No,
            Answer::No => Answer::Yes
        }
    }
}

assert_eq!(!Answer::Yes, Answer::No);
assert_eq!(!Answer::No, Answer::Yes);

Associated Types

source

type Output

The resulting type after applying the ! operator.

Required methods

source

fn not(self) -> Self::Output

Performs the unary ! operation.

Examples

assert_eq!(!true, false);
assert_eq!(!false, true);
assert_eq!(!1u8, 254);
assert_eq!(!0u8, 255);

Implementations on Foreign Types

const: unstable · source

impl<'_> Not for &'_ usize

type Output = <usize as Not>::Output

const: unstable · source

pub fn not(self) -> <usize as Not>::Output

const: unstable · source

impl Not for bool

type Output = bool

const: unstable · source

pub fn not(self) -> bool

const: unstable · source

impl<'_> Not for &'_ i32

type Output = <i32 as Not>::Output

const: unstable · source

pub fn not(self) -> <i32 as Not>::Output

source

impl<const LANES: usize> Not for Simd<u8, LANES> where
u8: SimdElement,
LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<u8, LANES>

source

pub fn not(self) -> <Simd<u8, LANES> as Not>::Output

const: unstable · source

impl<'_> Not for &'_ u8

type Output = <u8 as Not>::Output

const: unstable · source

pub fn not(self) -> <u8 as Not>::Output

source

impl<const LANES: usize> Not for Simd<u16, LANES> where
u16: SimdElement,
LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<u16, LANES>

source

pub fn not(self) -> <Simd<u16, LANES> as Not>::Output

const: unstable · source

impl Not for i128

type Output = i128

const: unstable · source

pub fn not(self) -> i128

const: unstable · source

impl<'_> Not for &'_ u128

type Output = <u128 as Not>::Output

const: unstable · source

pub fn not(self) -> <u128 as Not>::Output

const: unstable · source

impl Not for i8

type Output = i8

const: unstable · source

pub fn not(self) -> i8

const: unstable · source

impl Not for u8

type Output = u8

const: unstable · source

pub fn not(self) -> u8

const: unstable · source

impl<'_> Not for &'_ u32

type Output = <u32 as Not>::Output

const: unstable · source

pub fn not(self) -> <u32 as Not>::Output

source

impl<const LANES: usize> Not for Simd<u64, LANES> where
u64: SimdElement,
LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<u64, LANES>

source

pub fn not(self) -> <Simd<u64, LANES> as Not>::Output

const: unstable · source

impl Not for i32

type Output = i32

const: unstable · source

pub fn not(self) -> i32

1.60.0 (const: unstable) · source

impl Not for !

type Output = !

const: unstable · source

pub fn not(self) -> !

const: unstable · source

impl Not for u128

type Output = u128

const: unstable · source

pub fn not(self) -> u128

const: unstable · source

impl Not for usize

type Output = usize

const: unstable · source

pub fn not(self) -> usize

const: unstable · source

impl<'_> Not for &'_ i8

type Output = <i8 as Not>::Output

const: unstable · source

pub fn not(self) -> <i8 as Not>::Output

const: unstable · source

impl Not for u16

type Output = u16

const: unstable · source

pub fn not(self) -> u16

source

impl<const LANES: usize> Not for Simd<i64, LANES> where
i64: SimdElement,
LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<i64, LANES>

source

pub fn not(self) -> <Simd<i64, LANES> as Not>::Output

const: unstable · source

impl<'_> Not for &'_ i128

type Output = <i128 as Not>::Output

const: unstable · source

pub fn not(self) -> <i128 as Not>::Output

const: unstable · source

impl Not for u64

type Output = u64

const: unstable · source

pub fn not(self) -> u64

source

impl<const LANES: usize> Not for Simd<isize, LANES> where
isize: SimdElement,
LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<isize, LANES>

source

pub fn not(self) -> <Simd<isize, LANES> as Not>::Output

source

impl<const LANES: usize> Not for Simd<usize, LANES> where
usize: SimdElement,
LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<usize, LANES>

source

pub fn not(self) -> <Simd<usize, LANES> as Not>::Output

const: unstable · source

impl<'_> Not for &'_ i64

type Output = <i64 as Not>::Output

const: unstable · source

pub fn not(self) -> <i64 as Not>::Output

const: unstable · source

impl Not for i64

type Output = i64

const: unstable · source

pub fn not(self) -> i64

const: unstable · source

impl<'_> Not for &'_ u64

type Output = <u64 as Not>::Output

const: unstable · source

pub fn not(self) -> <u64 as Not>::Output

const: unstable · source

impl<'_> Not for &'_ u16

type Output = <u16 as Not>::Output

const: unstable · source

pub fn not(self) -> <u16 as Not>::Output

const: unstable · source

impl Not for u32

type Output = u32

const: unstable · source

pub fn not(self) -> u32

const: unstable · source

impl<'_> Not for &'_ isize

type Output = <isize as Not>::Output

const: unstable · source

pub fn not(self) -> <isize as Not>::Output

const: unstable · source

impl<'_> Not for &'_ i16

type Output = <i16 as Not>::Output

const: unstable · source

pub fn not(self) -> <i16 as Not>::Output

const: unstable · source

impl Not for i16

type Output = i16

const: unstable · source

pub fn not(self) -> i16

const: unstable · source

impl<'_> Not for &'_ bool

type Output = <bool as Not>::Output

const: unstable · source

pub fn not(self) -> <bool as Not>::Output

source

impl<T, const LANES: usize> Not for Mask<T, LANES> where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,

type Output = Mask<T, LANES>

source

pub fn not(self) -> <Mask<T, LANES> as Not>::Output

source

impl<const LANES: usize> Not for Simd<i8, LANES> where
i8: SimdElement,
LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<i8, LANES>

source

pub fn not(self) -> <Simd<i8, LANES> as Not>::Output

const: unstable · source

impl Not for isize

type Output = isize

const: unstable · source

pub fn not(self) -> isize

source

impl<const LANES: usize> Not for Simd<i32, LANES> where
i32: SimdElement,
LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<i32, LANES>

source

pub fn not(self) -> <Simd<i32, LANES> as Not>::Output

source

impl<const LANES: usize> Not for Simd<i16, LANES> where
i16: SimdElement,
LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<i16, LANES>

source

pub fn not(self) -> <Simd<i16, LANES> as Not>::Output

source

impl<const LANES: usize> Not for Simd<u32, LANES> where
u32: SimdElement,
LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<u32, LANES>

source

pub fn not(self) -> <Simd<u32, LANES> as Not>::Output

source

impl<'a, O, T> Not for &'a mut BitSlice<O, T> where
O: BitOrder,
T: BitStore,

type Output = &'a mut BitSlice<O, T>

source

pub fn not(self) -> <&'a mut BitSlice<O, T> as Not>::Outputⓘ
Notable traits for &'a mut BitSlice<O, T>
`impl<'a, O, T> Write for &'a mut BitSlice<O, T> where O: BitOrder, T: BitStore, BitSlice<O, T>: BitField, impl<'a, O, T> Read for &'a BitSlice<O, T> where O: BitOrder, T: BitStore, BitSlice<O, T>: BitField,`

source

impl<'_, M, O, T> Not for BitRef<'_, M, O, T> where
    M: Mutability,
    O: BitOrder,
    T: BitStore,

type Output = bool

source

pub fn not(self) -> <BitRef<'_, M, O, T> as Not>::Output

source

impl<O, T> Not for BitBox<O, T> where
O: BitOrder,
T: BitStore,

type Output = BitBox<O, T>

source

pub fn not(self) -> <BitBox<O, T> as Not>::Output

source

impl<O, V> Not for BitArray<O, V> where
O: BitOrder,
V: BitView,

type Output = BitArray<O, V>

source

pub fn not(self) -> <BitArray<O, V> as Not>::Output

source

impl<R> Not for BitMask<R> where
R: BitRegister,

type Output = BitMask<R>

source

pub fn not(self) -> <BitMask<R> as Not>::Output

source

impl<O, T> Not for BitVec<O, T> where
O: BitOrder,
T: BitStore,

This implementation inverts all elements in the live buffer. You cannot rely on the value of bits in the buffer that are outside the domain of BitVec::as_mit_bitslice.