Trait nom::lib::std::ops::Not

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

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

type Output

The resulting type after applying the ! operator.

Required methods

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

impl Not for Wrapping<i8>

type Output = Wrapping<i8>

pub fn not(self) -> Wrapping<i8>

impl Not for u64

type Output = u64

pub fn not(self) -> u64

impl<'_> Not for &'_ Wrapping<isize>

type Output = <Wrapping<isize> as Not>::Output

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

impl Not for Saturating<u32>

type Output = Saturating<u32>

pub fn not(self) -> Saturating<u32>

impl<'_> Not for &'_ u8

type Output = <u8 as Not>::Output

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

impl Not for Wrapping<u64>

type Output = Wrapping<u64>

pub fn not(self) -> Wrapping<u64>

impl<'_> Not for &'_ Wrapping<i8>

type Output = <Wrapping<i8> as Not>::Output

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

impl Not for u16

type Output = u16

pub fn not(self) -> u16

impl<'_> Not for &'_ Wrapping<i64>

type Output = <Wrapping<i64> as Not>::Output

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

impl Not for Saturating<i8>

type Output = Saturating<i8>

pub fn not(self) -> Saturating<i8>

impl Not for Wrapping<i128>

type Output = Wrapping<i128>

pub fn not(self) -> Wrapping<i128>

impl Not for i128

type Output = i128

pub fn not(self) -> i128

impl Not for Wrapping<u8>

type Output = Wrapping<u8>

pub fn not(self) -> Wrapping<u8>

impl Not for Wrapping<isize>

type Output = Wrapping<isize>

pub fn not(self) -> Wrapping<isize>

impl Not for Saturating<usize>

type Output = Saturating<usize>

pub fn not(self) -> Saturating<usize>

impl Not for usize

type Output = usize

pub fn not(self) -> usize

impl Not for i64

type Output = i64

pub fn not(self) -> i64

impl<'_> Not for &'_ Wrapping<u32>

type Output = <Wrapping<u32> as Not>::Output

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

impl Not for Wrapping<i32>

type Output = Wrapping<i32>

pub fn not(self) -> Wrapping<i32>

impl<'_> Not for &'_ Wrapping<u8>

type Output = <Wrapping<u8> as Not>::Output

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

impl<'_> Not for &'_ i16

type Output = <i16 as Not>::Output

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

impl<'_> Not for &'_ Saturating<isize>

type Output = <Saturating<isize> as Not>::Output

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

impl<'_> Not for &'_ i128

type Output = <i128 as Not>::Output

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

impl Not for Saturating<i64>

type Output = Saturating<i64>

pub fn not(self) -> Saturating<i64>

impl Not for Saturating<i16>

type Output = Saturating<i16>

pub fn not(self) -> Saturating<i16>

impl<'_> Not for &'_ u128

type Output = <u128 as Not>::Output

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

impl Not for Wrapping<usize>

type Output = Wrapping<usize>

pub fn not(self) -> Wrapping<usize>

impl<'_> Not for &'_ bool

type Output = <bool as Not>::Output

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

impl<'_> Not for &'_ Wrapping<u16>

type Output = <Wrapping<u16> as Not>::Output

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

impl Not for isize

type Output = isize

pub fn not(self) -> isize

impl Not for i32

type Output = i32

pub fn not(self) -> i32

impl<'_> Not for &'_ u64

type Output = <u64 as Not>::Output

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

impl Not for Wrapping<u128>

type Output = Wrapping<u128>

pub fn not(self) -> Wrapping<u128>

impl<'_> Not for &'_ Wrapping<usize>

type Output = <Wrapping<usize> as Not>::Output

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

impl<'_> Not for &'_ Saturating<i64>

type Output = <Saturating<i64> as Not>::Output

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

impl<'_> Not for &'_ Saturating<u32>

type Output = <Saturating<u32> as Not>::Output

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

impl<'_> Not for &'_ u32

type Output = <u32 as Not>::Output

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

impl Not for Saturating<u8>

type Output = Saturating<u8>

pub fn not(self) -> Saturating<u8>

impl<'_> Not for &'_ Saturating<u16>

type Output = <Saturating<u16> as Not>::Output

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

impl<'_> Not for &'_ Saturating<u8>

type Output = <Saturating<u8> as Not>::Output

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

impl<'_> Not for &'_ Wrapping<i32>

type Output = <Wrapping<i32> as Not>::Output

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

impl<'_> Not for &'_ Wrapping<u128>

type Output = <Wrapping<u128> as Not>::Output

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

impl<'_> Not for &'_ Saturating<i8>

type Output = <Saturating<i8> as Not>::Output

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

impl Not for Wrapping<u32>

type Output = Wrapping<u32>

pub fn not(self) -> Wrapping<u32>

impl Not for u32

type Output = u32

pub fn not(self) -> u32

impl<'_> Not for &'_ Saturating<usize>

type Output = <Saturating<usize> as Not>::Output

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

impl Not for Saturating<u64>

type Output = Saturating<u64>

pub fn not(self) -> Saturating<u64>

impl Not for Wrapping<i64>

type Output = Wrapping<i64>

pub fn not(self) -> Wrapping<i64>

impl Not for Saturating<u16>

type Output = Saturating<u16>

pub fn not(self) -> Saturating<u16>

impl<'_> Not for &'_ Wrapping<i128>

type Output = <Wrapping<i128> as Not>::Output

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

impl Not for Saturating<i128>

type Output = Saturating<i128>

pub fn not(self) -> Saturating<i128>

impl<'_> Not for &'_ i8

type Output = <i8 as Not>::Output

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

impl Not for u128

type Output = u128

pub fn not(self) -> u128

impl<'_> Not for &'_ isize

type Output = <isize as Not>::Output

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

impl<'_> Not for &'_ Saturating<i32>

type Output = <Saturating<i32> as Not>::Output

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

impl<'_> Not for &'_ Saturating<u64>

type Output = <Saturating<u64> as Not>::Output

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

impl Not for i16

type Output = i16

pub fn not(self) -> i16

impl<'_> Not for &'_ Saturating<u128>

type Output = <Saturating<u128> as Not>::Output

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

impl<'_> Not for &'_ Saturating<i128>

type Output = <Saturating<i128> as Not>::Output

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

impl Not for Saturating<u128>

type Output = Saturating<u128>

pub fn not(self) -> Saturating<u128>

impl<'_> Not for &'_ usize

type Output = <usize as Not>::Output

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

impl Not for Wrapping<i16>

type Output = Wrapping<i16>

pub fn not(self) -> Wrapping<i16>

impl<'_> Not for &'_ u16

type Output = <u16 as Not>::Output

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

impl Not for bool

type Output = bool

pub fn not(self) -> bool

impl<'_> Not for &'_ Wrapping<i16>

type Output = <Wrapping<i16> as Not>::Output

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

impl<'_> Not for &'_ i64

type Output = <i64 as Not>::Output

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

impl Not for Saturating<i32>

type Output = Saturating<i32>

pub fn not(self) -> Saturating<i32>

impl<'_> Not for &'_ Wrapping<u64>

type Output = <Wrapping<u64> as Not>::Output

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

impl Not for u8

type Output = u8

pub fn not(self) -> u8

impl Not for Wrapping<u16>

type Output = Wrapping<u16>

pub fn not(self) -> Wrapping<u16>

impl<'_> Not for &'_ i32

type Output = <i32 as Not>::Output

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

impl Not for Saturating<isize>

type Output = Saturating<isize>

pub fn not(self) -> Saturating<isize>

impl<'_> Not for &'_ Saturating<i16>

type Output = <Saturating<i16> as Not>::Output

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

impl Not for i8

type Output = i8

pub fn not(self) -> i8

Implementors

impl Not for AtFlags

impl Not for OFlag

impl Not for RenameFlags

impl Not for SealFlag

impl Not for FdFlag

impl Not for SpliceFFlags

impl Not for FallocateFlags

impl Not for ModuleInitFlags

impl Not for DeleteModuleFlags

impl Not for MsFlags

impl Not for MntFlags

impl Not for MQ_OFlag

impl Not for FdFlag

impl Not for InterfaceFlags

impl Not for PollFlags

impl Not for CloneFlags

impl Not for EpollFlags

impl Not for EpollCreateFlags

impl Not for EfdFlags

impl Not for MemFdCreateFlag

impl Not for ProtFlags

impl Not for MapFlags

impl Not for MRemapFlags

impl Not for MsFlags

impl Not for MlockAllFlags

impl Not for Persona

impl Not for Options

impl Not for QuotaValidFlags

impl Not for SaFlags

impl Not for SfdFlags

impl Not for SockFlag

impl Not for MsgFlags

impl Not for SFlag

impl Not for Mode

impl Not for FsFlags

impl Not for InputFlags

impl Not for OutputFlags

impl Not for ControlFlags

impl Not for LocalFlags

impl Not for WaitPidFlag

impl Not for AddWatchFlags

impl Not for InitFlags

impl Not for TimerFlags

impl Not for TimerSetTimeFlags

impl Not for AccessFlags