Trait ShlLogic 

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

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

Trait for left shift (<<) in logic code.

Required Associated Types

type Output

Required Methods

fn shl_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 ShlLogic for i8

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

logic

type Output = i8

impl ShlLogic for i16

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

logic

type Output = i16

impl ShlLogic for i32

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

logic

type Output = i32

impl ShlLogic for i64

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

logic

type Output = i64

impl ShlLogic for i128

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

logic

type Output = i128

impl ShlLogic for isize

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

logic

type Output = isize

impl ShlLogic for u8

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

logic

type Output = u8

impl ShlLogic for u16

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

logic

type Output = u16

impl ShlLogic for u32

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

logic

type Output = u32

impl ShlLogic for u64

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

logic

type Output = u64

impl ShlLogic for u128

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

logic

type Output = u128

impl ShlLogic for usize

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

logic

type Output = usize

impl ShlLogic<i8> for i16

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

logic(open, inline)

self << rhs as $lhs

type Output = i16

impl ShlLogic<i8> for i32

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

logic(open, inline)

self << rhs as $lhs

type Output = i32

impl ShlLogic<i8> for i64

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

logic(open, inline)

self << rhs as $lhs

type Output = i64

impl ShlLogic<i8> for i128

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

logic(open, inline)

self << rhs as $lhs

type Output = i128

impl ShlLogic<i8> for isize

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

logic(open, inline)

self << rhs as $lhs

type Output = isize

impl ShlLogic<i8> for u8

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

logic(open, inline)

self << rhs as $lhs

type Output = u8

impl ShlLogic<i8> for u16

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

logic(open, inline)

self << rhs as $lhs

type Output = u16

impl ShlLogic<i8> for u32

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

logic(open, inline)

self << rhs as $lhs

type Output = u32

impl ShlLogic<i8> for u64

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

logic(open, inline)

self << rhs as $lhs

type Output = u64

impl ShlLogic<i8> for u128

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

logic(open, inline)

self << rhs as $lhs

type Output = u128

impl ShlLogic<i8> for usize

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

logic(open, inline)

self << rhs as $lhs

type Output = usize

impl ShlLogic<i16> for i8

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

logic(open, inline)

self << rhs as $lhs

type Output = i8

impl ShlLogic<i16> for i32

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

logic(open, inline)

self << rhs as $lhs

type Output = i32

impl ShlLogic<i16> for i64

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

logic(open, inline)

self << rhs as $lhs

type Output = i64

impl ShlLogic<i16> for i128

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

logic(open, inline)

self << rhs as $lhs

type Output = i128

impl ShlLogic<i16> for isize

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

logic(open, inline)

self << rhs as $lhs

type Output = isize

impl ShlLogic<i16> for u8

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

logic(open, inline)

self << rhs as $lhs

type Output = u8

impl ShlLogic<i16> for u16

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

logic(open, inline)

self << rhs as $lhs

type Output = u16

impl ShlLogic<i16> for u32

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

logic(open, inline)

self << rhs as $lhs

type Output = u32

impl ShlLogic<i16> for u64

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

logic(open, inline)

self << rhs as $lhs

type Output = u64

impl ShlLogic<i16> for u128

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

logic(open, inline)

self << rhs as $lhs

type Output = u128

impl ShlLogic<i16> for usize

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

logic(open, inline)

self << rhs as $lhs

type Output = usize

impl ShlLogic<i32> for i8

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

logic(open, inline)

self << rhs as $lhs

type Output = i8

impl ShlLogic<i32> for i16

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

logic(open, inline)

self << rhs as $lhs

type Output = i16

impl ShlLogic<i32> for i64

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

logic(open, inline)

self << rhs as $lhs

type Output = i64

impl ShlLogic<i32> for i128

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

logic(open, inline)

self << rhs as $lhs

type Output = i128

impl ShlLogic<i32> for isize

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

logic(open, inline)

self << rhs as $lhs

type Output = isize

impl ShlLogic<i32> for u8

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

logic(open, inline)

self << rhs as $lhs

type Output = u8

impl ShlLogic<i32> for u16

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

logic(open, inline)

self << rhs as $lhs

type Output = u16

impl ShlLogic<i32> for u32

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

logic(open, inline)

self << rhs as $lhs

type Output = u32

impl ShlLogic<i32> for u64

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

logic(open, inline)

self << rhs as $lhs

type Output = u64

impl ShlLogic<i32> for u128

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

logic(open, inline)

self << rhs as $lhs

type Output = u128

impl ShlLogic<i32> for usize

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

logic(open, inline)

self << rhs as $lhs

type Output = usize

impl ShlLogic<i64> for i8

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

logic(open, inline)

self << rhs as $lhs

type Output = i8

impl ShlLogic<i64> for i16

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

logic(open, inline)

self << rhs as $lhs

type Output = i16

impl ShlLogic<i64> for i32

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

logic(open, inline)

self << rhs as $lhs

type Output = i32

impl ShlLogic<i64> for i128

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

logic(open, inline)

self << rhs as $lhs

type Output = i128

impl ShlLogic<i64> for isize

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

logic(open, inline)

self << rhs as $lhs

type Output = isize

impl ShlLogic<i64> for u8

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

logic(open, inline)

self << rhs as $lhs

type Output = u8

impl ShlLogic<i64> for u16

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

logic(open, inline)

self << rhs as $lhs

type Output = u16

impl ShlLogic<i64> for u32

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

logic(open, inline)

self << rhs as $lhs

type Output = u32

impl ShlLogic<i64> for u64

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

logic(open, inline)

self << rhs as $lhs

type Output = u64

impl ShlLogic<i64> for u128

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

logic(open, inline)

self << rhs as $lhs

type Output = u128

impl ShlLogic<i64> for usize

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

logic(open, inline)

self << rhs as $lhs

type Output = usize

impl ShlLogic<i128> for i8

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

logic(open, inline)

self << rhs as $lhs

type Output = i8

impl ShlLogic<i128> for i16

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

logic(open, inline)

self << rhs as $lhs

type Output = i16

impl ShlLogic<i128> for i32

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

logic(open, inline)

self << rhs as $lhs

type Output = i32

impl ShlLogic<i128> for i64

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

logic(open, inline)

self << rhs as $lhs

type Output = i64

impl ShlLogic<i128> for isize

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

logic(open, inline)

self << rhs as $lhs

type Output = isize

impl ShlLogic<i128> for u8

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

logic(open, inline)

self << rhs as $lhs

type Output = u8

impl ShlLogic<i128> for u16

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

logic(open, inline)

self << rhs as $lhs

type Output = u16

impl ShlLogic<i128> for u32

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

logic(open, inline)

self << rhs as $lhs

type Output = u32

impl ShlLogic<i128> for u64

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

logic(open, inline)

self << rhs as $lhs

type Output = u64

impl ShlLogic<i128> for u128

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

logic(open, inline)

self << rhs as $lhs

type Output = u128

impl ShlLogic<i128> for usize

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

logic(open, inline)

self << rhs as $lhs

type Output = usize

impl ShlLogic<isize> for i8

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

logic(open, inline)

self << rhs as $lhs

type Output = i8

impl ShlLogic<isize> for i16

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

logic(open, inline)

self << rhs as $lhs

type Output = i16

impl ShlLogic<isize> for i32

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

logic(open, inline)

self << rhs as $lhs

type Output = i32

impl ShlLogic<isize> for i64

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

logic(open, inline)

self << rhs as $lhs

type Output = i64

impl ShlLogic<isize> for i128

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

logic(open, inline)

self << rhs as $lhs

type Output = i128

impl ShlLogic<isize> for u8

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

logic(open, inline)

self << rhs as $lhs

type Output = u8

impl ShlLogic<isize> for u16

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

logic(open, inline)

self << rhs as $lhs

type Output = u16

impl ShlLogic<isize> for u32

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

logic(open, inline)

self << rhs as $lhs

type Output = u32

impl ShlLogic<isize> for u64

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

logic(open, inline)

self << rhs as $lhs

type Output = u64

impl ShlLogic<isize> for u128

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

logic(open, inline)

self << rhs as $lhs

type Output = u128

impl ShlLogic<isize> for usize

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

logic(open, inline)

self << rhs as $lhs

type Output = usize

impl ShlLogic<u8> for i8

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

logic(open, inline)

self << rhs as $lhs

type Output = i8

impl ShlLogic<u8> for i16

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

logic(open, inline)

self << rhs as $lhs

type Output = i16

impl ShlLogic<u8> for i32

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

logic(open, inline)

self << rhs as $lhs

type Output = i32

impl ShlLogic<u8> for i64

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

logic(open, inline)

self << rhs as $lhs

type Output = i64

impl ShlLogic<u8> for i128

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

logic(open, inline)

self << rhs as $lhs

type Output = i128

impl ShlLogic<u8> for isize

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

logic(open, inline)

self << rhs as $lhs

type Output = isize

impl ShlLogic<u8> for u16

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

logic(open, inline)

self << rhs as $lhs

type Output = u16

impl ShlLogic<u8> for u32

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

logic(open, inline)

self << rhs as $lhs

type Output = u32

impl ShlLogic<u8> for u64

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

logic(open, inline)

self << rhs as $lhs

type Output = u64

impl ShlLogic<u8> for u128

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

logic(open, inline)

self << rhs as $lhs

type Output = u128

impl ShlLogic<u8> for usize

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

logic(open, inline)

self << rhs as $lhs

type Output = usize

impl ShlLogic<u16> for i8

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

logic(open, inline)

self << rhs as $lhs

type Output = i8

impl ShlLogic<u16> for i16

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

logic(open, inline)

self << rhs as $lhs

type Output = i16

impl ShlLogic<u16> for i32

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

logic(open, inline)

self << rhs as $lhs

type Output = i32

impl ShlLogic<u16> for i64

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

logic(open, inline)

self << rhs as $lhs

type Output = i64

impl ShlLogic<u16> for i128

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

logic(open, inline)

self << rhs as $lhs

type Output = i128

impl ShlLogic<u16> for isize

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

logic(open, inline)

self << rhs as $lhs

type Output = isize

impl ShlLogic<u16> for u8

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

logic(open, inline)

self << rhs as $lhs

type Output = u8

impl ShlLogic<u16> for u32

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

logic(open, inline)

self << rhs as $lhs

type Output = u32

impl ShlLogic<u16> for u64

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

logic(open, inline)

self << rhs as $lhs

type Output = u64

impl ShlLogic<u16> for u128

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

logic(open, inline)

self << rhs as $lhs

type Output = u128

impl ShlLogic<u16> for usize

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

logic(open, inline)

self << rhs as $lhs

type Output = usize

impl ShlLogic<u32> for i8

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

logic(open, inline)

self << rhs as $lhs

type Output = i8

impl ShlLogic<u32> for i16

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

logic(open, inline)

self << rhs as $lhs

type Output = i16

impl ShlLogic<u32> for i32

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

logic(open, inline)

self << rhs as $lhs

type Output = i32

impl ShlLogic<u32> for i64

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

logic(open, inline)

self << rhs as $lhs

type Output = i64

impl ShlLogic<u32> for i128

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

logic(open, inline)

self << rhs as $lhs

type Output = i128

impl ShlLogic<u32> for isize

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

logic(open, inline)

self << rhs as $lhs

type Output = isize

impl ShlLogic<u32> for u8

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

logic(open, inline)

self << rhs as $lhs

type Output = u8

impl ShlLogic<u32> for u16

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

logic(open, inline)

self << rhs as $lhs

type Output = u16

impl ShlLogic<u32> for u64

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

logic(open, inline)

self << rhs as $lhs

type Output = u64

impl ShlLogic<u32> for u128

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

logic(open, inline)

self << rhs as $lhs

type Output = u128

impl ShlLogic<u32> for usize

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

logic(open, inline)

self << rhs as $lhs

type Output = usize

impl ShlLogic<u64> for i8

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

logic(open, inline)

self << rhs as $lhs

type Output = i8

impl ShlLogic<u64> for i16

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

logic(open, inline)

self << rhs as $lhs

type Output = i16

impl ShlLogic<u64> for i32

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

logic(open, inline)

self << rhs as $lhs

type Output = i32

impl ShlLogic<u64> for i64

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

logic(open, inline)

self << rhs as $lhs

type Output = i64

impl ShlLogic<u64> for i128

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

logic(open, inline)

self << rhs as $lhs

type Output = i128

impl ShlLogic<u64> for isize

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

logic(open, inline)

self << rhs as $lhs

type Output = isize

impl ShlLogic<u64> for u8

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

logic(open, inline)

self << rhs as $lhs

type Output = u8

impl ShlLogic<u64> for u16

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

logic(open, inline)

self << rhs as $lhs

type Output = u16

impl ShlLogic<u64> for u32

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

logic(open, inline)

self << rhs as $lhs

type Output = u32

impl ShlLogic<u64> for u128

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

logic(open, inline)

self << rhs as $lhs

type Output = u128

impl ShlLogic<u64> for usize

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

logic(open, inline)

self << rhs as $lhs

type Output = usize

impl ShlLogic<u128> for i8

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

logic(open, inline)

self << rhs as $lhs

type Output = i8

impl ShlLogic<u128> for i16

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

logic(open, inline)

self << rhs as $lhs

type Output = i16

impl ShlLogic<u128> for i32

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

logic(open, inline)

self << rhs as $lhs

type Output = i32

impl ShlLogic<u128> for i64

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

logic(open, inline)

self << rhs as $lhs

type Output = i64

impl ShlLogic<u128> for i128

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

logic(open, inline)

self << rhs as $lhs

type Output = i128

impl ShlLogic<u128> for isize

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

logic(open, inline)

self << rhs as $lhs

type Output = isize

impl ShlLogic<u128> for u8

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

logic(open, inline)

self << rhs as $lhs

type Output = u8

impl ShlLogic<u128> for u16

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

logic(open, inline)

self << rhs as $lhs

type Output = u16

impl ShlLogic<u128> for u32

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

logic(open, inline)

self << rhs as $lhs

type Output = u32

impl ShlLogic<u128> for u64

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

logic(open, inline)

self << rhs as $lhs

type Output = u64

impl ShlLogic<u128> for usize

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

logic(open, inline)

self << rhs as $lhs

type Output = usize

impl ShlLogic<usize> for i8

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

logic(open, inline)

self << rhs as $lhs

type Output = i8

impl ShlLogic<usize> for i16

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

logic(open, inline)

self << rhs as $lhs

type Output = i16

impl ShlLogic<usize> for i32

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

logic(open, inline)

self << rhs as $lhs

type Output = i32

impl ShlLogic<usize> for i64

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

logic(open, inline)

self << rhs as $lhs

type Output = i64

impl ShlLogic<usize> for i128

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

logic(open, inline)

self << rhs as $lhs

type Output = i128

impl ShlLogic<usize> for isize

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

logic(open, inline)

self << rhs as $lhs

type Output = isize

impl ShlLogic<usize> for u8

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

logic(open, inline)

self << rhs as $lhs

type Output = u8

impl ShlLogic<usize> for u16

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

logic(open, inline)

self << rhs as $lhs

type Output = u16

impl ShlLogic<usize> for u32

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

logic(open, inline)

self << rhs as $lhs

type Output = u32

impl ShlLogic<usize> for u64

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

logic(open, inline)

self << rhs as $lhs

type Output = u64

impl ShlLogic<usize> for u128

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

logic(open, inline)

self << rhs as $lhs

type Output = u128

Implementors