Trait ShrLogic 

pub trait ShrLogic<Rhs = Self> {
    type Output;

    // Required method
    fn shr_logic(self, other: Rhs) -> Self::Output;
}

Trait for right shift (>>) in logic code.

Required Associated Types

type Output

Required Methods

fn shr_logic(self, other: Rhs) -> Self::Output

logic

requires

false

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl ShrLogic for i8

fn shr_logic(self, other: Self) -> Self

logic

type Output = i8

impl ShrLogic for i16

fn shr_logic(self, other: Self) -> Self

logic

type Output = i16

impl ShrLogic for i32

fn shr_logic(self, other: Self) -> Self

logic

type Output = i32

impl ShrLogic for i64

fn shr_logic(self, other: Self) -> Self

logic

type Output = i64

impl ShrLogic for i128

fn shr_logic(self, other: Self) -> Self

logic

type Output = i128

impl ShrLogic for isize

fn shr_logic(self, other: Self) -> Self

logic

type Output = isize

impl ShrLogic for u8

fn shr_logic(self, other: Self) -> Self

logic

type Output = u8

impl ShrLogic for u16

fn shr_logic(self, other: Self) -> Self

logic

type Output = u16

impl ShrLogic for u32

fn shr_logic(self, other: Self) -> Self

logic

type Output = u32

impl ShrLogic for u64

fn shr_logic(self, other: Self) -> Self

logic

type Output = u64

impl ShrLogic for u128

fn shr_logic(self, other: Self) -> Self

logic

type Output = u128

impl ShrLogic for usize

fn shr_logic(self, other: Self) -> Self

logic

type Output = usize

impl ShrLogic<i8> for i16

fn shr_logic(self, rhs: i8) -> i16

logic(open, inline)

self >> rhs as $lhs

type Output = i16

impl ShrLogic<i8> for i32

fn shr_logic(self, rhs: i8) -> i32

logic(open, inline)

self >> rhs as $lhs

type Output = i32

impl ShrLogic<i8> for i64

fn shr_logic(self, rhs: i8) -> i64

logic(open, inline)

self >> rhs as $lhs

type Output = i64

impl ShrLogic<i8> for i128

fn shr_logic(self, rhs: i8) -> i128

logic(open, inline)

self >> rhs as $lhs

type Output = i128

impl ShrLogic<i8> for isize

fn shr_logic(self, rhs: i8) -> isize

logic(open, inline)

self >> rhs as $lhs

type Output = isize

impl ShrLogic<i8> for u8

fn shr_logic(self, rhs: i8) -> u8

logic(open, inline)

self >> rhs as $lhs

type Output = u8

impl ShrLogic<i8> for u16

fn shr_logic(self, rhs: i8) -> u16

logic(open, inline)

self >> rhs as $lhs

type Output = u16

impl ShrLogic<i8> for u32

fn shr_logic(self, rhs: i8) -> u32

logic(open, inline)

self >> rhs as $lhs

type Output = u32

impl ShrLogic<i8> for u64

fn shr_logic(self, rhs: i8) -> u64

logic(open, inline)

self >> rhs as $lhs

type Output = u64

impl ShrLogic<i8> for u128

fn shr_logic(self, rhs: i8) -> u128

logic(open, inline)

self >> rhs as $lhs

type Output = u128

impl ShrLogic<i8> for usize

fn shr_logic(self, rhs: i8) -> usize

logic(open, inline)

self >> rhs as $lhs

type Output = usize

impl ShrLogic<i16> for i8

fn shr_logic(self, rhs: i16) -> i8

logic(open, inline)

self >> rhs as $lhs

type Output = i8

impl ShrLogic<i16> for i32

fn shr_logic(self, rhs: i16) -> i32

logic(open, inline)

self >> rhs as $lhs

type Output = i32

impl ShrLogic<i16> for i64

fn shr_logic(self, rhs: i16) -> i64

logic(open, inline)

self >> rhs as $lhs

type Output = i64

impl ShrLogic<i16> for i128

fn shr_logic(self, rhs: i16) -> i128

logic(open, inline)

self >> rhs as $lhs

type Output = i128

impl ShrLogic<i16> for isize

fn shr_logic(self, rhs: i16) -> isize

logic(open, inline)

self >> rhs as $lhs

type Output = isize

impl ShrLogic<i16> for u8

fn shr_logic(self, rhs: i16) -> u8

logic(open, inline)

self >> rhs as $lhs

type Output = u8

impl ShrLogic<i16> for u16

fn shr_logic(self, rhs: i16) -> u16

logic(open, inline)

self >> rhs as $lhs

type Output = u16

impl ShrLogic<i16> for u32

fn shr_logic(self, rhs: i16) -> u32

logic(open, inline)

self >> rhs as $lhs

type Output = u32

impl ShrLogic<i16> for u64

fn shr_logic(self, rhs: i16) -> u64

logic(open, inline)

self >> rhs as $lhs

type Output = u64

impl ShrLogic<i16> for u128

fn shr_logic(self, rhs: i16) -> u128

logic(open, inline)

self >> rhs as $lhs

type Output = u128

impl ShrLogic<i16> for usize

fn shr_logic(self, rhs: i16) -> usize

logic(open, inline)

self >> rhs as $lhs

type Output = usize

impl ShrLogic<i32> for i8

fn shr_logic(self, rhs: i32) -> i8

logic(open, inline)

self >> rhs as $lhs

type Output = i8

impl ShrLogic<i32> for i16

fn shr_logic(self, rhs: i32) -> i16

logic(open, inline)

self >> rhs as $lhs

type Output = i16

impl ShrLogic<i32> for i64

fn shr_logic(self, rhs: i32) -> i64

logic(open, inline)

self >> rhs as $lhs

type Output = i64

impl ShrLogic<i32> for i128

fn shr_logic(self, rhs: i32) -> i128

logic(open, inline)

self >> rhs as $lhs

type Output = i128

impl ShrLogic<i32> for isize

fn shr_logic(self, rhs: i32) -> isize

logic(open, inline)

self >> rhs as $lhs

type Output = isize

impl ShrLogic<i32> for u8

fn shr_logic(self, rhs: i32) -> u8

logic(open, inline)

self >> rhs as $lhs

type Output = u8

impl ShrLogic<i32> for u16

fn shr_logic(self, rhs: i32) -> u16

logic(open, inline)

self >> rhs as $lhs

type Output = u16

impl ShrLogic<i32> for u32

fn shr_logic(self, rhs: i32) -> u32

logic(open, inline)

self >> rhs as $lhs

type Output = u32

impl ShrLogic<i32> for u64

fn shr_logic(self, rhs: i32) -> u64

logic(open, inline)

self >> rhs as $lhs

type Output = u64

impl ShrLogic<i32> for u128

fn shr_logic(self, rhs: i32) -> u128

logic(open, inline)

self >> rhs as $lhs

type Output = u128

impl ShrLogic<i32> for usize

fn shr_logic(self, rhs: i32) -> usize

logic(open, inline)

self >> rhs as $lhs

type Output = usize

impl ShrLogic<i64> for i8

fn shr_logic(self, rhs: i64) -> i8

logic(open, inline)

self >> rhs as $lhs

type Output = i8

impl ShrLogic<i64> for i16

fn shr_logic(self, rhs: i64) -> i16

logic(open, inline)

self >> rhs as $lhs

type Output = i16

impl ShrLogic<i64> for i32

fn shr_logic(self, rhs: i64) -> i32

logic(open, inline)

self >> rhs as $lhs

type Output = i32

impl ShrLogic<i64> for i128

fn shr_logic(self, rhs: i64) -> i128

logic(open, inline)

self >> rhs as $lhs

type Output = i128

impl ShrLogic<i64> for isize

fn shr_logic(self, rhs: i64) -> isize

logic(open, inline)

self >> rhs as $lhs

type Output = isize

impl ShrLogic<i64> for u8

fn shr_logic(self, rhs: i64) -> u8

logic(open, inline)

self >> rhs as $lhs

type Output = u8

impl ShrLogic<i64> for u16

fn shr_logic(self, rhs: i64) -> u16

logic(open, inline)

self >> rhs as $lhs

type Output = u16

impl ShrLogic<i64> for u32

fn shr_logic(self, rhs: i64) -> u32

logic(open, inline)

self >> rhs as $lhs

type Output = u32

impl ShrLogic<i64> for u64

fn shr_logic(self, rhs: i64) -> u64

logic(open, inline)

self >> rhs as $lhs

type Output = u64

impl ShrLogic<i64> for u128

fn shr_logic(self, rhs: i64) -> u128

logic(open, inline)

self >> rhs as $lhs

type Output = u128

impl ShrLogic<i64> for usize

fn shr_logic(self, rhs: i64) -> usize

logic(open, inline)

self >> rhs as $lhs

type Output = usize

impl ShrLogic<i128> for i8

fn shr_logic(self, rhs: i128) -> i8

logic(open, inline)

self >> rhs as $lhs

type Output = i8

impl ShrLogic<i128> for i16

fn shr_logic(self, rhs: i128) -> i16

logic(open, inline)

self >> rhs as $lhs

type Output = i16

impl ShrLogic<i128> for i32

fn shr_logic(self, rhs: i128) -> i32

logic(open, inline)

self >> rhs as $lhs

type Output = i32

impl ShrLogic<i128> for i64

fn shr_logic(self, rhs: i128) -> i64

logic(open, inline)

self >> rhs as $lhs

type Output = i64

impl ShrLogic<i128> for isize

fn shr_logic(self, rhs: i128) -> isize

logic(open, inline)

self >> rhs as $lhs

type Output = isize

impl ShrLogic<i128> for u8

fn shr_logic(self, rhs: i128) -> u8

logic(open, inline)

self >> rhs as $lhs

type Output = u8

impl ShrLogic<i128> for u16

fn shr_logic(self, rhs: i128) -> u16

logic(open, inline)

self >> rhs as $lhs

type Output = u16

impl ShrLogic<i128> for u32

fn shr_logic(self, rhs: i128) -> u32

logic(open, inline)

self >> rhs as $lhs

type Output = u32

impl ShrLogic<i128> for u64

fn shr_logic(self, rhs: i128) -> u64

logic(open, inline)

self >> rhs as $lhs

type Output = u64

impl ShrLogic<i128> for u128

fn shr_logic(self, rhs: i128) -> u128

logic(open, inline)

self >> rhs as $lhs

type Output = u128

impl ShrLogic<i128> for usize

fn shr_logic(self, rhs: i128) -> usize

logic(open, inline)

self >> rhs as $lhs

type Output = usize

impl ShrLogic<isize> for i8

fn shr_logic(self, rhs: isize) -> i8

logic(open, inline)

self >> rhs as $lhs

type Output = i8

impl ShrLogic<isize> for i16

fn shr_logic(self, rhs: isize) -> i16

logic(open, inline)

self >> rhs as $lhs

type Output = i16

impl ShrLogic<isize> for i32

fn shr_logic(self, rhs: isize) -> i32

logic(open, inline)

self >> rhs as $lhs

type Output = i32

impl ShrLogic<isize> for i64

fn shr_logic(self, rhs: isize) -> i64

logic(open, inline)

self >> rhs as $lhs

type Output = i64

impl ShrLogic<isize> for i128

fn shr_logic(self, rhs: isize) -> i128

logic(open, inline)

self >> rhs as $lhs

type Output = i128

impl ShrLogic<isize> for u8

fn shr_logic(self, rhs: isize) -> u8

logic(open, inline)

self >> rhs as $lhs

type Output = u8

impl ShrLogic<isize> for u16

fn shr_logic(self, rhs: isize) -> u16

logic(open, inline)

self >> rhs as $lhs

type Output = u16

impl ShrLogic<isize> for u32

fn shr_logic(self, rhs: isize) -> u32

logic(open, inline)

self >> rhs as $lhs

type Output = u32

impl ShrLogic<isize> for u64

fn shr_logic(self, rhs: isize) -> u64

logic(open, inline)

self >> rhs as $lhs

type Output = u64

impl ShrLogic<isize> for u128

fn shr_logic(self, rhs: isize) -> u128

logic(open, inline)

self >> rhs as $lhs

type Output = u128

impl ShrLogic<isize> for usize

fn shr_logic(self, rhs: isize) -> usize

logic(open, inline)

self >> rhs as $lhs

type Output = usize

impl ShrLogic<u8> for i8

fn shr_logic(self, rhs: u8) -> i8

logic(open, inline)

self >> rhs as $lhs

type Output = i8

impl ShrLogic<u8> for i16

fn shr_logic(self, rhs: u8) -> i16

logic(open, inline)

self >> rhs as $lhs

type Output = i16

impl ShrLogic<u8> for i32

fn shr_logic(self, rhs: u8) -> i32

logic(open, inline)

self >> rhs as $lhs

type Output = i32

impl ShrLogic<u8> for i64

fn shr_logic(self, rhs: u8) -> i64

logic(open, inline)

self >> rhs as $lhs

type Output = i64

impl ShrLogic<u8> for i128

fn shr_logic(self, rhs: u8) -> i128

logic(open, inline)

self >> rhs as $lhs

type Output = i128

impl ShrLogic<u8> for isize

fn shr_logic(self, rhs: u8) -> isize

logic(open, inline)

self >> rhs as $lhs

type Output = isize

impl ShrLogic<u8> for u16

fn shr_logic(self, rhs: u8) -> u16

logic(open, inline)

self >> rhs as $lhs

type Output = u16

impl ShrLogic<u8> for u32

fn shr_logic(self, rhs: u8) -> u32

logic(open, inline)

self >> rhs as $lhs

type Output = u32

impl ShrLogic<u8> for u64

fn shr_logic(self, rhs: u8) -> u64

logic(open, inline)

self >> rhs as $lhs

type Output = u64

impl ShrLogic<u8> for u128

fn shr_logic(self, rhs: u8) -> u128

logic(open, inline)

self >> rhs as $lhs

type Output = u128

impl ShrLogic<u8> for usize

fn shr_logic(self, rhs: u8) -> usize

logic(open, inline)

self >> rhs as $lhs

type Output = usize

impl ShrLogic<u16> for i8

fn shr_logic(self, rhs: u16) -> i8

logic(open, inline)

self >> rhs as $lhs

type Output = i8

impl ShrLogic<u16> for i16

fn shr_logic(self, rhs: u16) -> i16

logic(open, inline)

self >> rhs as $lhs

type Output = i16

impl ShrLogic<u16> for i32

fn shr_logic(self, rhs: u16) -> i32

logic(open, inline)

self >> rhs as $lhs

type Output = i32

impl ShrLogic<u16> for i64

fn shr_logic(self, rhs: u16) -> i64

logic(open, inline)

self >> rhs as $lhs

type Output = i64

impl ShrLogic<u16> for i128

fn shr_logic(self, rhs: u16) -> i128

logic(open, inline)

self >> rhs as $lhs

type Output = i128

impl ShrLogic<u16> for isize

fn shr_logic(self, rhs: u16) -> isize

logic(open, inline)

self >> rhs as $lhs

type Output = isize

impl ShrLogic<u16> for u8

fn shr_logic(self, rhs: u16) -> u8

logic(open, inline)

self >> rhs as $lhs

type Output = u8

impl ShrLogic<u16> for u32

fn shr_logic(self, rhs: u16) -> u32

logic(open, inline)

self >> rhs as $lhs

type Output = u32

impl ShrLogic<u16> for u64

fn shr_logic(self, rhs: u16) -> u64

logic(open, inline)

self >> rhs as $lhs

type Output = u64

impl ShrLogic<u16> for u128

fn shr_logic(self, rhs: u16) -> u128

logic(open, inline)

self >> rhs as $lhs

type Output = u128

impl ShrLogic<u16> for usize

fn shr_logic(self, rhs: u16) -> usize

logic(open, inline)

self >> rhs as $lhs

type Output = usize

impl ShrLogic<u32> for i8

fn shr_logic(self, rhs: u32) -> i8

logic(open, inline)

self >> rhs as $lhs

type Output = i8

impl ShrLogic<u32> for i16

fn shr_logic(self, rhs: u32) -> i16

logic(open, inline)

self >> rhs as $lhs

type Output = i16

impl ShrLogic<u32> for i32

fn shr_logic(self, rhs: u32) -> i32

logic(open, inline)

self >> rhs as $lhs

type Output = i32

impl ShrLogic<u32> for i64

fn shr_logic(self, rhs: u32) -> i64

logic(open, inline)

self >> rhs as $lhs

type Output = i64

impl ShrLogic<u32> for i128

fn shr_logic(self, rhs: u32) -> i128

logic(open, inline)

self >> rhs as $lhs

type Output = i128

impl ShrLogic<u32> for isize

fn shr_logic(self, rhs: u32) -> isize

logic(open, inline)

self >> rhs as $lhs

type Output = isize

impl ShrLogic<u32> for u8

fn shr_logic(self, rhs: u32) -> u8

logic(open, inline)

self >> rhs as $lhs

type Output = u8

impl ShrLogic<u32> for u16

fn shr_logic(self, rhs: u32) -> u16

logic(open, inline)

self >> rhs as $lhs

type Output = u16

impl ShrLogic<u32> for u64

fn shr_logic(self, rhs: u32) -> u64

logic(open, inline)

self >> rhs as $lhs

type Output = u64

impl ShrLogic<u32> for u128

fn shr_logic(self, rhs: u32) -> u128

logic(open, inline)

self >> rhs as $lhs

type Output = u128

impl ShrLogic<u32> for usize

fn shr_logic(self, rhs: u32) -> usize

logic(open, inline)

self >> rhs as $lhs

type Output = usize

impl ShrLogic<u64> for i8

fn shr_logic(self, rhs: u64) -> i8

logic(open, inline)

self >> rhs as $lhs

type Output = i8

impl ShrLogic<u64> for i16

fn shr_logic(self, rhs: u64) -> i16

logic(open, inline)

self >> rhs as $lhs

type Output = i16

impl ShrLogic<u64> for i32

fn shr_logic(self, rhs: u64) -> i32

logic(open, inline)

self >> rhs as $lhs

type Output = i32

impl ShrLogic<u64> for i64

fn shr_logic(self, rhs: u64) -> i64

logic(open, inline)

self >> rhs as $lhs

type Output = i64

impl ShrLogic<u64> for i128

fn shr_logic(self, rhs: u64) -> i128

logic(open, inline)

self >> rhs as $lhs

type Output = i128

impl ShrLogic<u64> for isize

fn shr_logic(self, rhs: u64) -> isize

logic(open, inline)

self >> rhs as $lhs

type Output = isize

impl ShrLogic<u64> for u8

fn shr_logic(self, rhs: u64) -> u8

logic(open, inline)

self >> rhs as $lhs

type Output = u8

impl ShrLogic<u64> for u16

fn shr_logic(self, rhs: u64) -> u16

logic(open, inline)

self >> rhs as $lhs

type Output = u16

impl ShrLogic<u64> for u32

fn shr_logic(self, rhs: u64) -> u32

logic(open, inline)

self >> rhs as $lhs

type Output = u32

impl ShrLogic<u64> for u128

fn shr_logic(self, rhs: u64) -> u128

logic(open, inline)

self >> rhs as $lhs

type Output = u128

impl ShrLogic<u64> for usize

fn shr_logic(self, rhs: u64) -> usize

logic(open, inline)

self >> rhs as $lhs

type Output = usize

impl ShrLogic<u128> for i8

fn shr_logic(self, rhs: u128) -> i8

logic(open, inline)

self >> rhs as $lhs

type Output = i8

impl ShrLogic<u128> for i16

fn shr_logic(self, rhs: u128) -> i16

logic(open, inline)

self >> rhs as $lhs

type Output = i16

impl ShrLogic<u128> for i32

fn shr_logic(self, rhs: u128) -> i32

logic(open, inline)

self >> rhs as $lhs

type Output = i32

impl ShrLogic<u128> for i64

fn shr_logic(self, rhs: u128) -> i64

logic(open, inline)

self >> rhs as $lhs

type Output = i64

impl ShrLogic<u128> for i128

fn shr_logic(self, rhs: u128) -> i128

logic(open, inline)

self >> rhs as $lhs

type Output = i128

impl ShrLogic<u128> for isize

fn shr_logic(self, rhs: u128) -> isize

logic(open, inline)

self >> rhs as $lhs

type Output = isize

impl ShrLogic<u128> for u8

fn shr_logic(self, rhs: u128) -> u8

logic(open, inline)

self >> rhs as $lhs

type Output = u8

impl ShrLogic<u128> for u16

fn shr_logic(self, rhs: u128) -> u16

logic(open, inline)

self >> rhs as $lhs

type Output = u16

impl ShrLogic<u128> for u32

fn shr_logic(self, rhs: u128) -> u32

logic(open, inline)

self >> rhs as $lhs

type Output = u32

impl ShrLogic<u128> for u64

fn shr_logic(self, rhs: u128) -> u64

logic(open, inline)

self >> rhs as $lhs

type Output = u64

impl ShrLogic<u128> for usize

fn shr_logic(self, rhs: u128) -> usize

logic(open, inline)

self >> rhs as $lhs

type Output = usize

impl ShrLogic<usize> for i8

fn shr_logic(self, rhs: usize) -> i8

logic(open, inline)

self >> rhs as $lhs

type Output = i8

impl ShrLogic<usize> for i16

fn shr_logic(self, rhs: usize) -> i16

logic(open, inline)

self >> rhs as $lhs

type Output = i16

impl ShrLogic<usize> for i32

fn shr_logic(self, rhs: usize) -> i32

logic(open, inline)

self >> rhs as $lhs

type Output = i32

impl ShrLogic<usize> for i64

fn shr_logic(self, rhs: usize) -> i64

logic(open, inline)

self >> rhs as $lhs

type Output = i64

impl ShrLogic<usize> for i128

fn shr_logic(self, rhs: usize) -> i128

logic(open, inline)

self >> rhs as $lhs

type Output = i128

impl ShrLogic<usize> for isize

fn shr_logic(self, rhs: usize) -> isize

logic(open, inline)

self >> rhs as $lhs

type Output = isize

impl ShrLogic<usize> for u8

fn shr_logic(self, rhs: usize) -> u8

logic(open, inline)

self >> rhs as $lhs

type Output = u8

impl ShrLogic<usize> for u16

fn shr_logic(self, rhs: usize) -> u16

logic(open, inline)

self >> rhs as $lhs

type Output = u16

impl ShrLogic<usize> for u32

fn shr_logic(self, rhs: usize) -> u32

logic(open, inline)

self >> rhs as $lhs

type Output = u32

impl ShrLogic<usize> for u64

fn shr_logic(self, rhs: usize) -> u64

logic(open, inline)

self >> rhs as $lhs

type Output = u64

impl ShrLogic<usize> for u128

fn shr_logic(self, rhs: usize) -> u128

logic(open, inline)

self >> rhs as $lhs

type Output = u128

Implementors