Trait tract_hir::internal::tract_downcast_rs::__std::ops::Shl

#[lang = "shl"]pub trait Shl<Rhs = Self> {
    type Output;
#[must_use]    pub fn shl(self, rhs: Rhs) -> Self::Output;
}

The left shift operator <<. Note that because this trait is implemented for all integer types with multiple right-hand-side types, Rust’s type checker has special handling for _ << _, setting the result type for integer operations to the type of the left-hand-side operand. This means that though a << b and a.shl(b) are one and the same from an evaluation standpoint, they are different when it comes to type inference.

Examples

An implementation of Shl that lifts the << operation on integers to a wrapper around usize.

use std::ops::Shl;

#[derive(PartialEq, Debug)]
struct Scalar(usize);

impl Shl<Scalar> for Scalar {
    type Output = Self;

    fn shl(self, Self(rhs): Self) -> Self::Output {
        let Self(lhs) = self;
        Self(lhs << rhs)
    }
}

assert_eq!(Scalar(4) << Scalar(2), Scalar(16));

An implementation of Shl that spins a vector leftward by a given amount.

use std::ops::Shl;

#[derive(PartialEq, Debug)]
struct SpinVector<T: Clone> {
    vec: Vec<T>,
}

impl<T: Clone> Shl<usize> for SpinVector<T> {
    type Output = Self;

    fn shl(self, rhs: usize) -> Self::Output {
        // Rotate the vector by `rhs` places.
        let (a, b) = self.vec.split_at(rhs);
        let mut spun_vector = vec![];
        spun_vector.extend_from_slice(b);
        spun_vector.extend_from_slice(a);
        Self { vec: spun_vector }
    }
}

assert_eq!(SpinVector { vec: vec![0, 1, 2, 3, 4] } << 2,
           SpinVector { vec: vec![2, 3, 4, 0, 1] });

Associated Types

type Output

The resulting type after applying the << operator.

Loading content...

Required methods

#[must_use]pub fn shl(self, rhs: Rhs) -> Self::Output

Performs the << operation.

Examples

assert_eq!(5u8 << 1, 10);
assert_eq!(1u8 << 1, 2);

Loading content...

Implementations on Foreign Types

impl<'_> Shl<&'_ i32> for i128

type Output = <i128 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <i128 as Shl<i32>>::Output

impl<'_> Shl<&'_ u8> for u32

type Output = <u32 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <u32 as Shl<u8>>::Output

impl<'a> Shl<u128> for &'a i8

type Output = <i8 as Shl<u128>>::Output

pub fn shl(self, other: u128) -> <i8 as Shl<u128>>::Output

impl<'a> Shl<i128> for &'a u32

type Output = <u32 as Shl<i128>>::Output

pub fn shl(self, other: i128) -> <u32 as Shl<i128>>::Output

impl<'a> Shl<i128> for &'a u128

type Output = <u128 as Shl<i128>>::Output

pub fn shl(self, other: i128) -> <u128 as Shl<i128>>::Output

impl<'_, '_> Shl<&'_ u8> for &'_ i32

type Output = <i32 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <i32 as Shl<u8>>::Output

impl<'_> Shl<&'_ u16> for usize

type Output = <usize as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <usize as Shl<u16>>::Output

impl<'_, '_> Shl<&'_ u64> for &'_ u128

type Output = <u128 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <u128 as Shl<u64>>::Output

impl<'_> Shl<&'_ usize> for i128

type Output = <i128 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <i128 as Shl<usize>>::Output

impl<'_, '_> Shl<&'_ u32> for &'_ u8

type Output = <u8 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <u8 as Shl<u32>>::Output

impl<'a> Shl<u128> for &'a u64

type Output = <u64 as Shl<u128>>::Output

pub fn shl(self, other: u128) -> <u64 as Shl<u128>>::Output

impl Shl<i16> for i32

type Output = i32

pub fn shl(self, other: i16) -> i32

impl<'_> Shl<&'_ i16> for u16

type Output = <u16 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <u16 as Shl<i16>>::Output

impl Shl<u64> for isize

type Output = isize

pub fn shl(self, other: u64) -> isize

impl Shl<u128> for u64

type Output = u64

pub fn shl(self, other: u128) -> u64

impl<'a> Shl<usize> for &'a u32

type Output = <u32 as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <u32 as Shl<usize>>::Output

impl<'_, '_> Shl<&'_ i32> for &'_ u32

type Output = <u32 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <u32 as Shl<i32>>::Output

impl<'_> Shl<&'_ u32> for i16

type Output = <i16 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <i16 as Shl<u32>>::Output

impl<'a> Shl<isize> for &'a i16

type Output = <i16 as Shl<isize>>::Output

pub fn shl(self, other: isize) -> <i16 as Shl<isize>>::Output

impl Shl<u64> for u32

type Output = u32

pub fn shl(self, other: u64) -> u32

impl<'a> Shl<i32> for &'a i8

type Output = <i8 as Shl<i32>>::Output

pub fn shl(self, other: i32) -> <i8 as Shl<i32>>::Output

impl<'_, '_> Shl<&'_ isize> for &'_ i16

type Output = <i16 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <i16 as Shl<isize>>::Output

impl Shl<i8> for u64

type Output = u64

pub fn shl(self, other: i8) -> u64

impl<'_, '_> Shl<&'_ u16> for &'_ u128

type Output = <u128 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <u128 as Shl<u16>>::Output

impl Shl<u8> for i8

type Output = i8

pub fn shl(self, other: u8) -> i8

impl Shl<u8> for i128

type Output = i128

pub fn shl(self, other: u8) -> i128

impl<'_> Shl<&'_ i64> for u128

type Output = <u128 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <u128 as Shl<i64>>::Output

impl<'_> Shl<&'_ u32> for i32

type Output = <i32 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <i32 as Shl<u32>>::Output

impl Shl<i16> for u16

type Output = u16

pub fn shl(self, other: i16) -> u16

impl<'a> Shl<usize> for &'a i64

type Output = <i64 as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <i64 as Shl<usize>>::Output

impl<'a> Shl<usize> for &'a u128

type Output = <u128 as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <u128 as Shl<usize>>::Output

impl Shl<u16> for i8

type Output = i8

pub fn shl(self, other: u16) -> i8

impl Shl<u32> for isize

type Output = isize

pub fn shl(self, other: u32) -> isize

impl<'_, '_> Shl<&'_ i128> for &'_ u64

type Output = <u64 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <u64 as Shl<i128>>::Output

impl Shl<u32> for u128

type Output = u128

pub fn shl(self, other: u32) -> u128

impl<'a> Shl<i16> for &'a i8

type Output = <i8 as Shl<i16>>::Output

pub fn shl(self, other: i16) -> <i8 as Shl<i16>>::Output

impl Shl<i16> for i64

type Output = i64

pub fn shl(self, other: i16) -> i64

impl Shl<u128> for u32

type Output = u32

pub fn shl(self, other: u128) -> u32

impl<'a> Shl<i8> for &'a u16

type Output = <u16 as Shl<i8>>::Output

pub fn shl(self, other: i8) -> <u16 as Shl<i8>>::Output

impl Shl<i8> for i16

type Output = i16

pub fn shl(self, other: i8) -> i16

impl Shl<u128> for i8

type Output = i8

pub fn shl(self, other: u128) -> i8

impl<'_> Shl<&'_ u64> for isize

type Output = <isize as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <isize as Shl<u64>>::Output

impl<'_> Shl<&'_ i32> for i16

type Output = <i16 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <i16 as Shl<i32>>::Output

impl Shl<isize> for u64

type Output = u64

pub fn shl(self, other: isize) -> u64

impl<'_> Shl<&'_ i64> for usize

type Output = <usize as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <usize as Shl<i64>>::Output

impl<'a> Shl<i16> for &'a isize

type Output = <isize as Shl<i16>>::Output

pub fn shl(self, other: i16) -> <isize as Shl<i16>>::Output

impl<'_, '_> Shl<&'_ isize> for &'_ u8

type Output = <u8 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <u8 as Shl<isize>>::Output

impl<'_> Shl<&'_ u64> for i128

type Output = <i128 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <i128 as Shl<u64>>::Output

impl Shl<i64> for i16

type Output = i16

pub fn shl(self, other: i64) -> i16

impl<'a> Shl<i64> for &'a i16

type Output = <i16 as Shl<i64>>::Output

pub fn shl(self, other: i64) -> <i16 as Shl<i64>>::Output

impl<'_, '_> Shl<&'_ i16> for &'_ i64

type Output = <i64 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <i64 as Shl<i16>>::Output

impl<'_, '_> Shl<&'_ u128> for &'_ u16

type Output = <u16 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <u16 as Shl<u128>>::Output

impl<'_> Shl<&'_ i64> for i16

type Output = <i16 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <i16 as Shl<i64>>::Output

impl<'_, '_> Shl<&'_ i16> for &'_ u128

type Output = <u128 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <u128 as Shl<i16>>::Output

impl<'_> Shl<&'_ i128> for u8

type Output = <u8 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <u8 as Shl<i128>>::Output

impl<'_> Shl<&'_ usize> for i16

type Output = <i16 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <i16 as Shl<usize>>::Output

impl<'a> Shl<i8> for &'a i16

type Output = <i16 as Shl<i8>>::Output

pub fn shl(self, other: i8) -> <i16 as Shl<i8>>::Output

impl<'a> Shl<usize> for &'a isize

type Output = <isize as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <isize as Shl<usize>>::Output

impl Shl<u16> for u16

type Output = u16

pub fn shl(self, other: u16) -> u16

impl<'_, '_> Shl<&'_ usize> for &'_ i64

type Output = <i64 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <i64 as Shl<usize>>::Output

impl<'a> Shl<u8> for &'a i32

type Output = <i32 as Shl<u8>>::Output

pub fn shl(self, other: u8) -> <i32 as Shl<u8>>::Output

impl<'_, '_> Shl<&'_ u64> for &'_ i128

type Output = <i128 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <i128 as Shl<u64>>::Output

impl<'_, '_> Shl<&'_ isize> for &'_ usize

type Output = <usize as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <usize as Shl<isize>>::Output

impl<'_, '_> Shl<&'_ u64> for &'_ isize

type Output = <isize as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <isize as Shl<u64>>::Output

impl<'_> Shl<&'_ i64> for u16

type Output = <u16 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <u16 as Shl<i64>>::Output

impl<'_, '_> Shl<&'_ u8> for &'_ usize

type Output = <usize as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <usize as Shl<u8>>::Output

impl<'a> Shl<i64> for &'a usize

type Output = <usize as Shl<i64>>::Output

pub fn shl(self, other: i64) -> <usize as Shl<i64>>::Output

impl<'_, '_> Shl<&'_ i8> for &'_ u16

type Output = <u16 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <u16 as Shl<i8>>::Output

impl<'a> Shl<i128> for &'a u64

type Output = <u64 as Shl<i128>>::Output

pub fn shl(self, other: i128) -> <u64 as Shl<i128>>::Output

impl<'a> Shl<u64> for &'a i16

type Output = <i16 as Shl<u64>>::Output

pub fn shl(self, other: u64) -> <i16 as Shl<u64>>::Output

impl<'_, '_> Shl<&'_ i8> for &'_ u128

type Output = <u128 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <u128 as Shl<i8>>::Output

impl<'_, '_> Shl<&'_ i128> for &'_ i64

type Output = <i64 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <i64 as Shl<i128>>::Output

impl Shl<i128> for i8

type Output = i8

pub fn shl(self, other: i128) -> i8

impl<'_> Shl<&'_ u16> for u128

type Output = <u128 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <u128 as Shl<u16>>::Output

impl<'_> Shl<&'_ usize> for u8

type Output = <u8 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <u8 as Shl<usize>>::Output

impl Shl<i128> for i128

type Output = i128

pub fn shl(self, other: i128) -> i128

impl<'_> Shl<&'_ i128> for u128

type Output = <u128 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <u128 as Shl<i128>>::Output

impl<'_> Shl<&'_ usize> for usize

type Output = <usize as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <usize as Shl<usize>>::Output

impl Shl<isize> for i16

type Output = i16

pub fn shl(self, other: isize) -> i16

impl<'_> Shl<&'_ isize> for u32

type Output = <u32 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <u32 as Shl<isize>>::Output

impl<'a> Shl<u16> for &'a i64

type Output = <i64 as Shl<u16>>::Output

pub fn shl(self, other: u16) -> <i64 as Shl<u16>>::Output

impl<'_, '_> Shl<&'_ i64> for &'_ usize

type Output = <usize as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <usize as Shl<i64>>::Output

impl Shl<i128> for i16

type Output = i16

pub fn shl(self, other: i128) -> i16

impl<'a> Shl<u32> for &'a u32

type Output = <u32 as Shl<u32>>::Output

pub fn shl(self, other: u32) -> <u32 as Shl<u32>>::Output

impl<'a> Shl<u64> for &'a i8

type Output = <i8 as Shl<u64>>::Output

pub fn shl(self, other: u64) -> <i8 as Shl<u64>>::Output

impl<'a> Shl<i128> for &'a i8

type Output = <i8 as Shl<i128>>::Output

pub fn shl(self, other: i128) -> <i8 as Shl<i128>>::Output

impl<'_> Shl<&'_ i16> for i8

type Output = <i8 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <i8 as Shl<i16>>::Output

impl<'_, '_> Shl<&'_ i128> for &'_ isize

type Output = <isize as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <isize as Shl<i128>>::Output

impl<'a> Shl<u8> for &'a u16

type Output = <u16 as Shl<u8>>::Output

pub fn shl(self, other: u8) -> <u16 as Shl<u8>>::Output

impl<'a> Shl<u128> for &'a isize

type Output = <isize as Shl<u128>>::Output

pub fn shl(self, other: u128) -> <isize as Shl<u128>>::Output

impl<'a> Shl<i8> for &'a i128

type Output = <i128 as Shl<i8>>::Output

pub fn shl(self, other: i8) -> <i128 as Shl<i8>>::Output

impl<'_, '_> Shl<&'_ i8> for &'_ u64

type Output = <u64 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <u64 as Shl<i8>>::Output

impl<'_> Shl<&'_ i32> for u8

type Output = <u8 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <u8 as Shl<i32>>::Output

impl<'_, '_> Shl<&'_ u32> for &'_ u32

type Output = <u32 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <u32 as Shl<u32>>::Output

impl<'a> Shl<i128> for &'a i128

type Output = <i128 as Shl<i128>>::Output

pub fn shl(self, other: i128) -> <i128 as Shl<i128>>::Output

impl<'a> Shl<i32> for &'a u64

type Output = <u64 as Shl<i32>>::Output

pub fn shl(self, other: i32) -> <u64 as Shl<i32>>::Output

impl<'a> Shl<i16> for &'a i16

type Output = <i16 as Shl<i16>>::Output

pub fn shl(self, other: i16) -> <i16 as Shl<i16>>::Output

impl Shl<u64> for i64

type Output = i64

pub fn shl(self, other: u64) -> i64

impl Shl<u128> for isize

type Output = isize

pub fn shl(self, other: u128) -> isize

impl<'a> Shl<i16> for &'a u32

type Output = <u32 as Shl<i16>>::Output

pub fn shl(self, other: i16) -> <u32 as Shl<i16>>::Output

impl Shl<u128> for i128

type Output = i128

pub fn shl(self, other: u128) -> i128

impl<'_, '_> Shl<&'_ u16> for &'_ i128

type Output = <i128 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <i128 as Shl<u16>>::Output

impl Shl<usize> for i128

type Output = i128

pub fn shl(self, other: usize) -> i128

impl<'a> Shl<i8> for &'a i8

type Output = <i8 as Shl<i8>>::Output

pub fn shl(self, other: i8) -> <i8 as Shl<i8>>::Output

impl<'_, '_> Shl<&'_ i128> for &'_ u128

type Output = <u128 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <u128 as Shl<i128>>::Output

impl Shl<i8> for i8

type Output = i8

pub fn shl(self, other: i8) -> i8

impl Shl<u128> for i32

type Output = i32

pub fn shl(self, other: u128) -> i32

impl<'_, '_> Shl<&'_ u64> for &'_ i32

type Output = <i32 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <i32 as Shl<u64>>::Output

impl Shl<u8> for u128

type Output = u128

pub fn shl(self, other: u8) -> u128

impl Shl<isize> for u128

type Output = u128

pub fn shl(self, other: isize) -> u128

impl<'_> Shl<&'_ u16> for i128

type Output = <i128 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <i128 as Shl<u16>>::Output

impl Shl<i16> for usize

type Output = usize

pub fn shl(self, other: i16) -> usize

impl<'_, '_> Shl<&'_ isize> for &'_ i32

type Output = <i32 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <i32 as Shl<isize>>::Output

impl<'a> Shl<i16> for &'a u64

type Output = <u64 as Shl<i16>>::Output

pub fn shl(self, other: i16) -> <u64 as Shl<i16>>::Output

impl Shl<i8> for u16

type Output = u16

pub fn shl(self, other: i8) -> u16

impl<'_, '_> Shl<&'_ u32> for &'_ u128

type Output = <u128 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <u128 as Shl<u32>>::Output

impl Shl<i16> for i128

type Output = i128

pub fn shl(self, other: i16) -> i128

impl<'_> Shl<&'_ i16> for u128

type Output = <u128 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <u128 as Shl<i16>>::Output

impl Shl<u64> for u64

type Output = u64

pub fn shl(self, other: u64) -> u64

impl<'_> Shl<&'_ u128> for i64

type Output = <i64 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <i64 as Shl<u128>>::Output

impl Shl<u16> for u32

type Output = u32

pub fn shl(self, other: u16) -> u32

impl<'_, '_> Shl<&'_ i128> for &'_ u8

type Output = <u8 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <u8 as Shl<i128>>::Output

impl<'a> Shl<i128> for &'a usize

type Output = <usize as Shl<i128>>::Output

pub fn shl(self, other: i128) -> <usize as Shl<i128>>::Output

impl<'_, '_> Shl<&'_ u32> for &'_ i8

type Output = <i8 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <i8 as Shl<u32>>::Output

impl<'a> Shl<i16> for &'a i128

type Output = <i128 as Shl<i16>>::Output

pub fn shl(self, other: i16) -> <i128 as Shl<i16>>::Output

impl Shl<u32> for u16

type Output = u16

pub fn shl(self, other: u32) -> u16

impl Shl<u64> for i128

type Output = i128

pub fn shl(self, other: u64) -> i128

impl Shl<u32> for i32

type Output = i32

pub fn shl(self, other: u32) -> i32

impl<'a> Shl<i32> for &'a isize

type Output = <isize as Shl<i32>>::Output

pub fn shl(self, other: i32) -> <isize as Shl<i32>>::Output

impl Shl<usize> for u128

type Output = u128

pub fn shl(self, other: usize) -> u128

impl<'a> Shl<i8> for &'a u32

type Output = <u32 as Shl<i8>>::Output

pub fn shl(self, other: i8) -> <u32 as Shl<i8>>::Output

impl<'_> Shl<&'_ i16> for i32

type Output = <i32 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <i32 as Shl<i16>>::Output

impl Shl<i128> for i32

type Output = i32

pub fn shl(self, other: i128) -> i32

impl<'_, '_> Shl<&'_ usize> for &'_ u128

type Output = <u128 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <u128 as Shl<usize>>::Output

impl<'a> Shl<i32> for &'a i16

type Output = <i16 as Shl<i32>>::Output

pub fn shl(self, other: i32) -> <i16 as Shl<i32>>::Output

impl<'_, '_> Shl<&'_ u16> for &'_ u8

type Output = <u8 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <u8 as Shl<u16>>::Output

impl<'a> Shl<u8> for &'a i64

type Output = <i64 as Shl<u8>>::Output

pub fn shl(self, other: u8) -> <i64 as Shl<u8>>::Output

impl Shl<i64> for usize

type Output = usize

pub fn shl(self, other: i64) -> usize

impl<'_> Shl<&'_ i16> for i128

type Output = <i128 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <i128 as Shl<i16>>::Output

impl<'_> Shl<&'_ u8> for i8

type Output = <i8 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <i8 as Shl<u8>>::Output

impl<'_> Shl<&'_ i128> for u64

type Output = <u64 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <u64 as Shl<i128>>::Output

impl<'_, '_> Shl<&'_ i16> for &'_ usize

type Output = <usize as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <usize as Shl<i16>>::Output

impl<'a> Shl<i32> for &'a i64

type Output = <i64 as Shl<i32>>::Output

pub fn shl(self, other: i32) -> <i64 as Shl<i32>>::Output

impl<'_, '_> Shl<&'_ i16> for &'_ u64

type Output = <u64 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <u64 as Shl<i16>>::Output

impl<'a> Shl<u32> for &'a u128

type Output = <u128 as Shl<u32>>::Output

pub fn shl(self, other: u32) -> <u128 as Shl<u32>>::Output

impl Shl<isize> for u16

type Output = u16

pub fn shl(self, other: isize) -> u16

impl<'_, '_> Shl<&'_ u128> for &'_ i16

type Output = <i16 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <i16 as Shl<u128>>::Output

impl<'a> Shl<i64> for &'a u128

type Output = <u128 as Shl<i64>>::Output

pub fn shl(self, other: i64) -> <u128 as Shl<i64>>::Output

impl<'_> Shl<&'_ isize> for i16

type Output = <i16 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <i16 as Shl<isize>>::Output

impl<'_, '_> Shl<&'_ u128> for &'_ i32

type Output = <i32 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <i32 as Shl<u128>>::Output

impl<'_, '_> Shl<&'_ u128> for &'_ usize

type Output = <usize as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <usize as Shl<u128>>::Output

impl Shl<u32> for u8

type Output = u8

pub fn shl(self, other: u32) -> u8

impl<'a> Shl<u16> for &'a u64

type Output = <u64 as Shl<u16>>::Output

pub fn shl(self, other: u16) -> <u64 as Shl<u16>>::Output

impl Shl<u32> for i16

type Output = i16

pub fn shl(self, other: u32) -> i16

impl<'a> Shl<i128> for &'a i64

type Output = <i64 as Shl<i128>>::Output

pub fn shl(self, other: i128) -> <i64 as Shl<i128>>::Output

impl<'a> Shl<i64> for &'a i32

type Output = <i32 as Shl<i64>>::Output

pub fn shl(self, other: i64) -> <i32 as Shl<i64>>::Output

impl<'_, '_> Shl<&'_ u8> for &'_ u128

type Output = <u128 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <u128 as Shl<u8>>::Output

impl<'_, '_> Shl<&'_ u64> for &'_ u32

type Output = <u32 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <u32 as Shl<u64>>::Output

impl<'_> Shl<&'_ i128> for i8

type Output = <i8 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <i8 as Shl<i128>>::Output

impl<'_> Shl<&'_ u128> for i16

type Output = <i16 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <i16 as Shl<u128>>::Output

impl Shl<u64> for u16

type Output = u16

pub fn shl(self, other: u64) -> u16

impl<'_, '_> Shl<&'_ isize> for &'_ i8

type Output = <i8 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <i8 as Shl<isize>>::Output

impl Shl<i8> for isize

type Output = isize

pub fn shl(self, other: i8) -> isize

impl Shl<u32> for i128

type Output = i128

pub fn shl(self, other: u32) -> i128

impl<'_, '_> Shl<&'_ u32> for &'_ i128

type Output = <i128 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <i128 as Shl<u32>>::Output

impl<'_> Shl<&'_ i64> for u64

type Output = <u64 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <u64 as Shl<i64>>::Output

impl<'_> Shl<&'_ u32> for u16

type Output = <u16 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <u16 as Shl<u32>>::Output

impl<'a> Shl<isize> for &'a isize

type Output = <isize as Shl<isize>>::Output

pub fn shl(self, other: isize) -> <isize as Shl<isize>>::Output

impl<'_> Shl<&'_ isize> for i64

type Output = <i64 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <i64 as Shl<isize>>::Output

impl<'_, '_> Shl<&'_ u16> for &'_ u16

type Output = <u16 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <u16 as Shl<u16>>::Output

impl<'_> Shl<&'_ u8> for i128

type Output = <i128 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <i128 as Shl<u8>>::Output

impl<'_, '_> Shl<&'_ u32> for &'_ isize

type Output = <isize as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <isize as Shl<u32>>::Output

impl<'_> Shl<&'_ i128> for usize

type Output = <usize as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <usize as Shl<i128>>::Output

impl<'_, '_> Shl<&'_ u8> for &'_ u64

type Output = <u64 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <u64 as Shl<u8>>::Output

impl<'a> Shl<u32> for &'a u64

type Output = <u64 as Shl<u32>>::Output

pub fn shl(self, other: u32) -> <u64 as Shl<u32>>::Output

impl Shl<u64> for i16

type Output = i16

pub fn shl(self, other: u64) -> i16

impl<'_> Shl<&'_ i128> for i128

type Output = <i128 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <i128 as Shl<i128>>::Output

impl<'a> Shl<u16> for &'a u8

type Output = <u8 as Shl<u16>>::Output

pub fn shl(self, other: u16) -> <u8 as Shl<u16>>::Output

impl<'_, '_> Shl<&'_ i128> for &'_ usize

type Output = <usize as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <usize as Shl<i128>>::Output

impl Shl<i64> for i32

type Output = i32

pub fn shl(self, other: i64) -> i32

impl<'a> Shl<i16> for &'a u128

type Output = <u128 as Shl<i16>>::Output

pub fn shl(self, other: i16) -> <u128 as Shl<i16>>::Output

impl<'a> Shl<isize> for &'a u8

type Output = <u8 as Shl<isize>>::Output

pub fn shl(self, other: isize) -> <u8 as Shl<isize>>::Output

impl<'_, '_> Shl<&'_ i16> for &'_ u8

type Output = <u8 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <u8 as Shl<i16>>::Output

impl<'a> Shl<u8> for &'a i128

type Output = <i128 as Shl<u8>>::Output

pub fn shl(self, other: u8) -> <i128 as Shl<u8>>::Output

impl<'_, '_> Shl<&'_ u64> for &'_ i64

type Output = <i64 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <i64 as Shl<u64>>::Output

impl<'_> Shl<&'_ u64> for usize

type Output = <usize as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <usize as Shl<u64>>::Output

impl<'a> Shl<u32> for &'a i16

type Output = <i16 as Shl<u32>>::Output

pub fn shl(self, other: u32) -> <i16 as Shl<u32>>::Output

impl<'_> Shl<&'_ usize> for u64

type Output = <u64 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <u64 as Shl<usize>>::Output

impl<'a> Shl<isize> for &'a u128

type Output = <u128 as Shl<isize>>::Output

pub fn shl(self, other: isize) -> <u128 as Shl<isize>>::Output

impl Shl<usize> for isize

type Output = isize

pub fn shl(self, other: usize) -> isize

impl<'a> Shl<u128> for &'a i128

type Output = <i128 as Shl<u128>>::Output

pub fn shl(self, other: u128) -> <i128 as Shl<u128>>::Output

impl<'_, '_> Shl<&'_ i16> for &'_ i16

type Output = <i16 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <i16 as Shl<i16>>::Output

impl<'_> Shl<&'_ i32> for u32

type Output = <u32 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <u32 as Shl<i32>>::Output

impl<'_> Shl<&'_ usize> for isize

type Output = <isize as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <isize as Shl<usize>>::Output

impl<'a> Shl<u64> for &'a i128

type Output = <i128 as Shl<u64>>::Output

pub fn shl(self, other: u64) -> <i128 as Shl<u64>>::Output

impl Shl<u16> for isize

type Output = isize

pub fn shl(self, other: u16) -> isize

impl<'_, '_> Shl<&'_ u16> for &'_ i16

type Output = <i16 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <i16 as Shl<u16>>::Output

impl<'_, '_> Shl<&'_ i32> for &'_ isize

type Output = <isize as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <isize as Shl<i32>>::Output

impl<'_, '_> Shl<&'_ u8> for &'_ i128

type Output = <i128 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <i128 as Shl<u8>>::Output

impl<'_, '_> Shl<&'_ i64> for &'_ isize

type Output = <isize as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <isize as Shl<i64>>::Output

impl<'_> Shl<&'_ u8> for u8

type Output = <u8 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <u8 as Shl<u8>>::Output

impl<'_, '_> Shl<&'_ u16> for &'_ i32

type Output = <i32 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <i32 as Shl<u16>>::Output

impl<'a> Shl<u8> for &'a i8

type Output = <i8 as Shl<u8>>::Output

pub fn shl(self, other: u8) -> <i8 as Shl<u8>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ u64

type Output = <u64 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <u64 as Shl<usize>>::Output

impl<'a> Shl<usize> for &'a i32

type Output = <i32 as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <i32 as Shl<usize>>::Output

impl<'_> Shl<&'_ isize> for i8

type Output = <i8 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <i8 as Shl<isize>>::Output

impl<'_, '_> Shl<&'_ i32> for &'_ u128

type Output = <u128 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <u128 as Shl<i32>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ i128

type Output = <i128 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <i128 as Shl<usize>>::Output

impl Shl<i8> for u128

type Output = u128

pub fn shl(self, other: i8) -> u128

impl Shl<u128> for i16

type Output = i16

pub fn shl(self, other: u128) -> i16

impl Shl<u64> for usize

type Output = usize

pub fn shl(self, other: u64) -> usize

impl<'_> Shl<&'_ i8> for u32

type Output = <u32 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <u32 as Shl<i8>>::Output

impl<'_> Shl<&'_ u16> for i32

type Output = <i32 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <i32 as Shl<u16>>::Output

impl<'_> Shl<&'_ u32> for u64

type Output = <u64 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <u64 as Shl<u32>>::Output

impl<'_> Shl<&'_ i16> for usize

type Output = <usize as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <usize as Shl<i16>>::Output

impl Shl<i16> for i16

type Output = i16

pub fn shl(self, other: i16) -> i16

impl<'a> Shl<isize> for &'a i8

type Output = <i8 as Shl<isize>>::Output

pub fn shl(self, other: isize) -> <i8 as Shl<isize>>::Output

impl Shl<i16> for u128

type Output = u128

pub fn shl(self, other: i16) -> u128

impl<'_> Shl<&'_ u128> for i128

type Output = <i128 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <i128 as Shl<u128>>::Output

impl<'a> Shl<u128> for &'a u128

type Output = <u128 as Shl<u128>>::Output

pub fn shl(self, other: u128) -> <u128 as Shl<u128>>::Output

impl<'_> Shl<&'_ i128> for i64

type Output = <i64 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <i64 as Shl<i128>>::Output

impl<'_, '_> Shl<&'_ i8> for &'_ u32

type Output = <u32 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <u32 as Shl<i8>>::Output

impl Shl<i8> for i128

type Output = i128

pub fn shl(self, other: i8) -> i128

impl Shl<isize> for i32

type Output = i32

pub fn shl(self, other: isize) -> i32

impl<'_> Shl<&'_ usize> for i8

type Output = <i8 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <i8 as Shl<usize>>::Output

impl Shl<u16> for i64

type Output = i64

pub fn shl(self, other: u16) -> i64

impl<'_, '_> Shl<&'_ u64> for &'_ u16

type Output = <u16 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <u16 as Shl<u64>>::Output

impl<'a> Shl<u128> for &'a i64

type Output = <i64 as Shl<u128>>::Output

pub fn shl(self, other: u128) -> <i64 as Shl<u128>>::Output

impl<'_> Shl<&'_ i8> for i64

type Output = <i64 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <i64 as Shl<i8>>::Output

impl<'_> Shl<&'_ u32> for i8

type Output = <i8 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <i8 as Shl<u32>>::Output

impl<'a> Shl<i32> for &'a u8

type Output = <u8 as Shl<i32>>::Output

pub fn shl(self, other: i32) -> <u8 as Shl<i32>>::Output

impl<'a> Shl<i32> for &'a u32

type Output = <u32 as Shl<i32>>::Output

pub fn shl(self, other: i32) -> <u32 as Shl<i32>>::Output

impl<'a> Shl<i128> for &'a i16

type Output = <i16 as Shl<i128>>::Output

pub fn shl(self, other: i128) -> <i16 as Shl<i128>>::Output

impl<'a> Shl<i32> for &'a u16

type Output = <u16 as Shl<i32>>::Output

pub fn shl(self, other: i32) -> <u16 as Shl<i32>>::Output

impl Shl<u32> for u32

type Output = u32

pub fn shl(self, other: u32) -> u32

impl Shl<i16> for u32

type Output = u32

pub fn shl(self, other: i16) -> u32

impl<'_, '_> Shl<&'_ u32> for &'_ u64

type Output = <u64 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <u64 as Shl<u32>>::Output

impl<'a> Shl<u8> for &'a u8

type Output = <u8 as Shl<u8>>::Output

pub fn shl(self, other: u8) -> <u8 as Shl<u8>>::Output

impl<'_> Shl<&'_ i64> for isize

type Output = <isize as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <isize as Shl<i64>>::Output

impl<'_> Shl<&'_ isize> for u16

type Output = <u16 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <u16 as Shl<isize>>::Output

impl<'a> Shl<u8> for &'a u64

type Output = <u64 as Shl<u8>>::Output

pub fn shl(self, other: u8) -> <u64 as Shl<u8>>::Output

impl<'a> Shl<isize> for &'a i32

type Output = <i32 as Shl<isize>>::Output

pub fn shl(self, other: isize) -> <i32 as Shl<isize>>::Output

impl<'_> Shl<&'_ i64> for u8

type Output = <u8 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <u8 as Shl<i64>>::Output

impl<'_> Shl<&'_ i8> for u64

type Output = <u64 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <u64 as Shl<i8>>::Output

impl Shl<u128> for u16

type Output = u16

pub fn shl(self, other: u128) -> u16

impl Shl<i32> for isize

type Output = isize

pub fn shl(self, other: i32) -> isize

impl<'a> Shl<u32> for &'a u16

type Output = <u16 as Shl<u32>>::Output

pub fn shl(self, other: u32) -> <u16 as Shl<u32>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ i32

type Output = <i32 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <i32 as Shl<usize>>::Output

impl<'_> Shl<&'_ u8> for i16

type Output = <i16 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <i16 as Shl<u8>>::Output

impl<'a> Shl<u64> for &'a usize

type Output = <usize as Shl<u64>>::Output

pub fn shl(self, other: u64) -> <usize as Shl<u64>>::Output

impl<'_> Shl<&'_ i32> for u128

type Output = <u128 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <u128 as Shl<i32>>::Output

impl<'_> Shl<&'_ u64> for i8

type Output = <i8 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <i8 as Shl<u64>>::Output

impl<'a> Shl<i32> for &'a i32

type Output = <i32 as Shl<i32>>::Output

pub fn shl(self, other: i32) -> <i32 as Shl<i32>>::Output

impl<'_, '_> Shl<&'_ i32> for &'_ usize

type Output = <usize as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <usize as Shl<i32>>::Output

impl<'a> Shl<u64> for &'a isize

type Output = <isize as Shl<u64>>::Output

pub fn shl(self, other: u64) -> <isize as Shl<u64>>::Output

impl<'a> Shl<u128> for &'a i16

type Output = <i16 as Shl<u128>>::Output

pub fn shl(self, other: u128) -> <i16 as Shl<u128>>::Output

impl<'_, '_> Shl<&'_ i8> for &'_ isize

type Output = <isize as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <isize as Shl<i8>>::Output

impl<'_> Shl<&'_ i16> for isize

type Output = <isize as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <isize as Shl<i16>>::Output

impl<'a> Shl<u64> for &'a u64

type Output = <u64 as Shl<u64>>::Output

pub fn shl(self, other: u64) -> <u64 as Shl<u64>>::Output

impl Shl<usize> for u16

type Output = u16

pub fn shl(self, other: usize) -> u16

impl Shl<i32> for i32

type Output = i32

pub fn shl(self, other: i32) -> i32

impl<'a> Shl<i64> for &'a u64

type Output = <u64 as Shl<i64>>::Output

pub fn shl(self, other: i64) -> <u64 as Shl<i64>>::Output

impl<'_, '_> Shl<&'_ i8> for &'_ i8

type Output = <i8 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <i8 as Shl<i8>>::Output

impl<'_, '_> Shl<&'_ isize> for &'_ i128

type Output = <i128 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <i128 as Shl<isize>>::Output

impl<'_> Shl<&'_ u32> for i64

type Output = <i64 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <i64 as Shl<u32>>::Output

impl<'_> Shl<&'_ i8> for u8

type Output = <u8 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <u8 as Shl<i8>>::Output

impl<'_, '_> Shl<&'_ i8> for &'_ i16

type Output = <i16 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <i16 as Shl<i8>>::Output

impl<'_, '_> Shl<&'_ i64> for &'_ u8

type Output = <u8 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <u8 as Shl<i64>>::Output

impl<'_, '_> Shl<&'_ isize> for &'_ u32

type Output = <u32 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <u32 as Shl<isize>>::Output

impl Shl<u8> for i32

type Output = i32

pub fn shl(self, other: u8) -> i32

impl Shl<i16> for isize

type Output = isize

pub fn shl(self, other: i16) -> isize

impl Shl<usize> for usize

type Output = usize

pub fn shl(self, other: usize) -> usize

impl<'_, '_> Shl<&'_ i32> for &'_ i16

type Output = <i16 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <i16 as Shl<i32>>::Output

impl<'a> Shl<u8> for &'a u128

type Output = <u128 as Shl<u8>>::Output

pub fn shl(self, other: u8) -> <u128 as Shl<u8>>::Output

impl<'_, '_> Shl<&'_ u64> for &'_ u8

type Output = <u8 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <u8 as Shl<u64>>::Output

impl Shl<i128> for u32

type Output = u32

pub fn shl(self, other: i128) -> u32

impl<'_, '_> Shl<&'_ i8> for &'_ i64

type Output = <i64 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <i64 as Shl<i8>>::Output

impl<'a> Shl<u16> for &'a i8

type Output = <i8 as Shl<u16>>::Output

pub fn shl(self, other: u16) -> <i8 as Shl<u16>>::Output

impl Shl<i128> for isize

type Output = isize

pub fn shl(self, other: i128) -> isize

impl Shl<i64> for u64

type Output = u64

pub fn shl(self, other: i64) -> u64

impl<'a> Shl<u32> for &'a usize

type Output = <usize as Shl<u32>>::Output

pub fn shl(self, other: u32) -> <usize as Shl<u32>>::Output

impl<'_> Shl<&'_ i128> for u32

type Output = <u32 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <u32 as Shl<i128>>::Output

impl<'_, '_> Shl<&'_ i8> for &'_ i32

type Output = <i32 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <i32 as Shl<i8>>::Output

impl<'_, '_> Shl<&'_ u16> for &'_ i64

type Output = <i64 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <i64 as Shl<u16>>::Output

impl Shl<u16> for i32

type Output = i32

pub fn shl(self, other: u16) -> i32

impl Shl<isize> for isize

type Output = isize

pub fn shl(self, other: isize) -> isize

impl<'_> Shl<&'_ u32> for isize

type Output = <isize as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <isize as Shl<u32>>::Output

impl<'_> Shl<&'_ i64> for i32

type Output = <i32 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <i32 as Shl<i64>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ i8

type Output = <i8 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <i8 as Shl<usize>>::Output

impl<'_, '_> Shl<&'_ i16> for &'_ i32

type Output = <i32 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <i32 as Shl<i16>>::Output

impl<'a> Shl<i128> for &'a i32

type Output = <i32 as Shl<i128>>::Output

pub fn shl(self, other: i128) -> <i32 as Shl<i128>>::Output

impl<'_> Shl<&'_ u128> for i32

type Output = <i32 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <i32 as Shl<u128>>::Output

impl<'_> Shl<&'_ u32> for u8

type Output = <u8 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <u8 as Shl<u32>>::Output

impl Shl<i16> for u64

type Output = u64

pub fn shl(self, other: i16) -> u64

impl<'_, '_> Shl<&'_ i8> for &'_ usize

type Output = <usize as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <usize as Shl<i8>>::Output

impl<'_, '_> Shl<&'_ u64> for &'_ u64

type Output = <u64 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <u64 as Shl<u64>>::Output

impl Shl<u128> for u8

type Output = u8

pub fn shl(self, other: u128) -> u8

impl<'_, '_> Shl<&'_ isize> for &'_ u128

type Output = <u128 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <u128 as Shl<isize>>::Output

impl Shl<isize> for i8

type Output = i8

pub fn shl(self, other: isize) -> i8

impl Shl<u8> for i16

type Output = i16

pub fn shl(self, other: u8) -> i16

impl Shl<i64> for isize

type Output = isize

pub fn shl(self, other: i64) -> isize

impl<'_, '_> Shl<&'_ u16> for &'_ usize

type Output = <usize as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <usize as Shl<u16>>::Output

impl Shl<u64> for u8

type Output = u8

pub fn shl(self, other: u64) -> u8

impl<'_, '_> Shl<&'_ u128> for &'_ i64

type Output = <i64 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <i64 as Shl<u128>>::Output

impl<'_, '_> Shl<&'_ i32> for &'_ i64

type Output = <i64 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <i64 as Shl<i32>>::Output

impl Shl<usize> for i64

type Output = i64

pub fn shl(self, other: usize) -> i64

impl Shl<i8> for i32

type Output = i32

pub fn shl(self, other: i8) -> i32

impl<'a> Shl<usize> for &'a i128

type Output = <i128 as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <i128 as Shl<usize>>::Output

impl<'a> Shl<isize> for &'a usize

type Output = <usize as Shl<isize>>::Output

pub fn shl(self, other: isize) -> <usize as Shl<isize>>::Output

impl<'_> Shl<&'_ u8> for u64

type Output = <u64 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <u64 as Shl<u8>>::Output

impl<'a> Shl<i8> for &'a i64

type Output = <i64 as Shl<i8>>::Output

pub fn shl(self, other: i8) -> <i64 as Shl<i8>>::Output

impl<'a> Shl<i16> for &'a u16

type Output = <u16 as Shl<i16>>::Output

pub fn shl(self, other: i16) -> <u16 as Shl<i16>>::Output

impl<'_> Shl<&'_ i32> for i64

type Output = <i64 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <i64 as Shl<i32>>::Output

impl<'a> Shl<u128> for &'a u8

type Output = <u8 as Shl<u128>>::Output

pub fn shl(self, other: u128) -> <u8 as Shl<u128>>::Output

impl<'_> Shl<&'_ i8> for u16

type Output = <u16 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <u16 as Shl<i8>>::Output

impl Shl<u128> for usize

type Output = usize

pub fn shl(self, other: u128) -> usize

impl<'_, '_> Shl<&'_ usize> for &'_ usize

type Output = <usize as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <usize as Shl<usize>>::Output

impl<'_> Shl<&'_ isize> for usize

type Output = <usize as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <usize as Shl<isize>>::Output

impl Shl<i64> for u128

type Output = u128

pub fn shl(self, other: i64) -> u128

impl<'_, '_> Shl<&'_ i16> for &'_ i8

type Output = <i8 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <i8 as Shl<i16>>::Output

impl<'a> Shl<i64> for &'a i64

type Output = <i64 as Shl<i64>>::Output

pub fn shl(self, other: i64) -> <i64 as Shl<i64>>::Output

impl<'_, '_> Shl<&'_ u128> for &'_ i128

type Output = <i128 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <i128 as Shl<u128>>::Output

impl<'_> Shl<&'_ u128> for u32

type Output = <u32 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <u32 as Shl<u128>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ u16

type Output = <u16 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <u16 as Shl<usize>>::Output

impl<'_, '_> Shl<&'_ i16> for &'_ u16

type Output = <u16 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <u16 as Shl<i16>>::Output

impl Shl<i32> for u16

type Output = u16

pub fn shl(self, other: i32) -> u16

impl<'_, '_> Shl<&'_ u8> for &'_ i16

type Output = <i16 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <i16 as Shl<u8>>::Output

impl Shl<i128> for u8

type Output = u8

pub fn shl(self, other: i128) -> u8

impl<'_, '_> Shl<&'_ i128> for &'_ i128

type Output = <i128 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <i128 as Shl<i128>>::Output

impl<'_> Shl<&'_ usize> for u32

type Output = <u32 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <u32 as Shl<usize>>::Output

impl<'_, '_> Shl<&'_ u128> for &'_ i8

type Output = <i8 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <i8 as Shl<u128>>::Output

impl<'_, '_> Shl<&'_ u8> for &'_ isize

type Output = <isize as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <isize as Shl<u8>>::Output

impl<'_, '_> Shl<&'_ i128> for &'_ i32

type Output = <i32 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <i32 as Shl<i128>>::Output

impl<'_> Shl<&'_ i8> for i128

type Output = <i128 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <i128 as Shl<i8>>::Output

impl<'_> Shl<&'_ u8> for u16

type Output = <u16 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <u16 as Shl<u8>>::Output

impl<'_, '_> Shl<&'_ i64> for &'_ i128

type Output = <i128 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <i128 as Shl<i64>>::Output

impl<'_> Shl<&'_ u16> for u32

type Output = <u32 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <u32 as Shl<u16>>::Output

impl<'a> Shl<u32> for &'a isize

type Output = <isize as Shl<u32>>::Output

pub fn shl(self, other: u32) -> <isize as Shl<u32>>::Output

impl<'_, '_> Shl<&'_ isize> for &'_ isize

type Output = <isize as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <isize as Shl<isize>>::Output

impl<'a> Shl<u128> for &'a u32

type Output = <u32 as Shl<u128>>::Output

pub fn shl(self, other: u128) -> <u32 as Shl<u128>>::Output

impl Shl<u8> for u8

type Output = u8

pub fn shl(self, other: u8) -> u8

impl<'a> Shl<i16> for &'a u8

type Output = <u8 as Shl<i16>>::Output

pub fn shl(self, other: i16) -> <u8 as Shl<i16>>::Output

impl<'a> Shl<u64> for &'a u8

type Output = <u8 as Shl<u64>>::Output

pub fn shl(self, other: u64) -> <u8 as Shl<u64>>::Output

impl<'_> Shl<&'_ u64> for u32

type Output = <u32 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <u32 as Shl<u64>>::Output

impl<'_> Shl<&'_ isize> for u8

type Output = <u8 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <u8 as Shl<isize>>::Output

impl<'_> Shl<&'_ i8> for i32

type Output = <i32 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <i32 as Shl<i8>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ isize

type Output = <isize as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <isize as Shl<usize>>::Output

impl<'a> Shl<isize> for &'a i64

type Output = <i64 as Shl<isize>>::Output

pub fn shl(self, other: isize) -> <i64 as Shl<isize>>::Output

impl Shl<u128> for u128

type Output = u128

pub fn shl(self, other: u128) -> u128

impl<'_, '_> Shl<&'_ u32> for &'_ i64

type Output = <i64 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <i64 as Shl<u32>>::Output

impl<'_, '_> Shl<&'_ i32> for &'_ i128

type Output = <i128 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <i128 as Shl<i32>>::Output

impl<'a> Shl<u32> for &'a u8

type Output = <u8 as Shl<u32>>::Output

pub fn shl(self, other: u32) -> <u8 as Shl<u32>>::Output

impl Shl<i64> for u8

type Output = u8

pub fn shl(self, other: i64) -> u8

impl<'a> Shl<usize> for &'a i8

type Output = <i8 as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <i8 as Shl<usize>>::Output

impl<'a> Shl<i8> for &'a i32

type Output = <i32 as Shl<i8>>::Output

pub fn shl(self, other: i8) -> <i32 as Shl<i8>>::Output

impl<'a> Shl<u64> for &'a i64

type Output = <i64 as Shl<u64>>::Output

pub fn shl(self, other: u64) -> <i64 as Shl<u64>>::Output

impl<'a> Shl<i128> for &'a u16

type Output = <u16 as Shl<i128>>::Output

pub fn shl(self, other: i128) -> <u16 as Shl<i128>>::Output

impl<'a> Shl<u32> for &'a i64

type Output = <i64 as Shl<u32>>::Output

pub fn shl(self, other: u32) -> <i64 as Shl<u32>>::Output

impl<'_, '_> Shl<&'_ isize> for &'_ u16

type Output = <u16 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <u16 as Shl<isize>>::Output

impl<'a> Shl<i64> for &'a i8

type Output = <i8 as Shl<i64>>::Output

pub fn shl(self, other: i64) -> <i8 as Shl<i64>>::Output

impl<'_, '_> Shl<&'_ i64> for &'_ i8

type Output = <i8 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <i8 as Shl<i64>>::Output

impl<'a> Shl<i64> for &'a isize

type Output = <isize as Shl<i64>>::Output

pub fn shl(self, other: i64) -> <isize as Shl<i64>>::Output

impl<'_, '_> Shl<&'_ u128> for &'_ u32

type Output = <u32 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <u32 as Shl<u128>>::Output

impl<'_, '_> Shl<&'_ i32> for &'_ u16

type Output = <u16 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <u16 as Shl<i32>>::Output

impl<'a> Shl<u32> for &'a i8

type Output = <i8 as Shl<u32>>::Output

pub fn shl(self, other: u32) -> <i8 as Shl<u32>>::Output

impl Shl<u16> for usize

type Output = usize

pub fn shl(self, other: u16) -> usize

impl<'a> Shl<usize> for &'a u16

type Output = <u16 as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <u16 as Shl<usize>>::Output

impl<'a> Shl<u64> for &'a u16

type Output = <u16 as Shl<u64>>::Output

pub fn shl(self, other: u64) -> <u16 as Shl<u64>>::Output

impl Shl<i32> for i128

type Output = i128

pub fn shl(self, other: i32) -> i128

impl Shl<u128> for i64

type Output = i64

pub fn shl(self, other: u128) -> i64

impl<'_> Shl<&'_ u64> for i16

type Output = <i16 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <i16 as Shl<u64>>::Output

impl<'a> Shl<i64> for &'a u8

type Output = <u8 as Shl<i64>>::Output

pub fn shl(self, other: i64) -> <u8 as Shl<i64>>::Output

impl<'_> Shl<&'_ i32> for usize

type Output = <usize as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <usize as Shl<i32>>::Output

impl Shl<u32> for u64

type Output = u64

pub fn shl(self, other: u32) -> u64

impl Shl<i32> for u64

type Output = u64

pub fn shl(self, other: i32) -> u64

impl<'_> Shl<&'_ u128> for u16

type Output = <u16 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <u16 as Shl<u128>>::Output

impl<'a> Shl<u16> for &'a usize

type Output = <usize as Shl<u16>>::Output

pub fn shl(self, other: u16) -> <usize as Shl<u16>>::Output

impl<'_> Shl<&'_ u128> for u8

type Output = <u8 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <u8 as Shl<u128>>::Output

impl<'_, '_> Shl<&'_ i32> for &'_ i32

type Output = <i32 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <i32 as Shl<i32>>::Output

impl<'_> Shl<&'_ i8> for usize

type Output = <usize as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <usize as Shl<i8>>::Output

impl<'_> Shl<&'_ i128> for u16

type Output = <u16 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <u16 as Shl<i128>>::Output

impl Shl<usize> for u8

type Output = u8

pub fn shl(self, other: usize) -> u8

impl<'_, '_> Shl<&'_ i16> for &'_ i128

type Output = <i128 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <i128 as Shl<i16>>::Output

impl<'_> Shl<&'_ i8> for u128

type Output = <u128 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <u128 as Shl<i8>>::Output

impl Shl<i16> for u8

type Output = u8

pub fn shl(self, other: i16) -> u8

impl Shl<usize> for i32

type Output = i32

pub fn shl(self, other: usize) -> i32

impl<'_> Shl<&'_ i32> for i8

type Output = <i8 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <i8 as Shl<i32>>::Output

impl Shl<u8> for u16

type Output = u16

pub fn shl(self, other: u8) -> u16

impl<'_, '_> Shl<&'_ i64> for &'_ i32

type Output = <i32 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <i32 as Shl<i64>>::Output

impl Shl<i64> for i64

type Output = i64

pub fn shl(self, other: i64) -> i64

impl<'_> Shl<&'_ i128> for i32

type Output = <i32 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <i32 as Shl<i128>>::Output

impl<'_, '_> Shl<&'_ i64> for &'_ u16

type Output = <u16 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <u16 as Shl<i64>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ u8

type Output = <u8 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <u8 as Shl<usize>>::Output

impl<'a> Shl<usize> for &'a u64

type Output = <u64 as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <u64 as Shl<usize>>::Output

impl Shl<u16> for i16

type Output = i16

pub fn shl(self, other: u16) -> i16

impl<'a> Shl<i8> for &'a u128

type Output = <u128 as Shl<i8>>::Output

pub fn shl(self, other: i8) -> <u128 as Shl<i8>>::Output

impl Shl<isize> for u8

type Output = u8

pub fn shl(self, other: isize) -> u8

impl<'a> Shl<u64> for &'a u32

type Output = <u32 as Shl<u64>>::Output

pub fn shl(self, other: u64) -> <u32 as Shl<u64>>::Output

impl<'_> Shl<&'_ u64> for u8

type Output = <u8 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <u8 as Shl<u64>>::Output

impl<'a> Shl<u32> for &'a i128

type Output = <i128 as Shl<u32>>::Output

pub fn shl(self, other: u32) -> <i128 as Shl<u32>>::Output

impl Shl<i64> for i8

type Output = i8

pub fn shl(self, other: i64) -> i8

impl<'_> Shl<&'_ u16> for i16

type Output = <i16 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <i16 as Shl<u16>>::Output

impl<'a> Shl<u16> for &'a i16

type Output = <i16 as Shl<u16>>::Output

pub fn shl(self, other: u16) -> <i16 as Shl<u16>>::Output

impl Shl<u16> for u8

type Output = u8

pub fn shl(self, other: u16) -> u8

impl Shl<i64> for i128

type Output = i128

pub fn shl(self, other: i64) -> i128

impl Shl<i32> for u8

type Output = u8

pub fn shl(self, other: i32) -> u8

impl<'_> Shl<&'_ u8> for usize

type Output = <usize as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <usize as Shl<u8>>::Output

impl<'_, '_> Shl<&'_ i16> for &'_ u32

type Output = <u32 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <u32 as Shl<i16>>::Output

impl<'a> Shl<i8> for &'a usize

type Output = <usize as Shl<i8>>::Output

pub fn shl(self, other: i8) -> <usize as Shl<i8>>::Output

impl<'_> Shl<&'_ u8> for u128

type Output = <u128 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <u128 as Shl<u8>>::Output

impl<'_, '_> Shl<&'_ i64> for &'_ i64

type Output = <i64 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <i64 as Shl<i64>>::Output

impl<'a> Shl<i32> for &'a u128

type Output = <u128 as Shl<i32>>::Output

pub fn shl(self, other: i32) -> <u128 as Shl<i32>>::Output

impl<'a> Shl<isize> for &'a u64

type Output = <u64 as Shl<isize>>::Output

pub fn shl(self, other: isize) -> <u64 as Shl<isize>>::Output

impl<'_> Shl<&'_ u16> for u64

type Output = <u64 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <u64 as Shl<u16>>::Output

impl<'_> Shl<&'_ usize> for u128

type Output = <u128 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <u128 as Shl<usize>>::Output

impl<'_, '_> Shl<&'_ isize> for &'_ i64

type Output = <i64 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <i64 as Shl<isize>>::Output

impl<'_, '_> Shl<&'_ u32> for &'_ u16

type Output = <u16 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <u16 as Shl<u32>>::Output

impl<'_> Shl<&'_ u16> for isize

type Output = <isize as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <isize as Shl<u16>>::Output

impl Shl<i8> for i64

type Output = i64

pub fn shl(self, other: i8) -> i64

impl<'_, '_> Shl<&'_ u32> for &'_ i16

type Output = <i16 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <i16 as Shl<u32>>::Output

impl Shl<usize> for i16

type Output = i16

pub fn shl(self, other: usize) -> i16

impl Shl<u8> for u64

type Output = u64

pub fn shl(self, other: u8) -> u64

impl<'_, '_> Shl<&'_ i64> for &'_ i16

type Output = <i16 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <i16 as Shl<i64>>::Output

impl<'_, '_> Shl<&'_ u16> for &'_ isize

type Output = <isize as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <isize as Shl<u16>>::Output

impl Shl<u64> for i8

type Output = i8

pub fn shl(self, other: u64) -> i8

impl Shl<isize> for i64

type Output = i64

pub fn shl(self, other: isize) -> i64

impl<'_> Shl<&'_ u64> for u128

type Output = <u128 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <u128 as Shl<u64>>::Output

impl<'a> Shl<i128> for &'a u8

type Output = <u8 as Shl<i128>>::Output

pub fn shl(self, other: i128) -> <u8 as Shl<i128>>::Output

impl<'_> Shl<&'_ u8> for isize

type Output = <isize as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <isize as Shl<u8>>::Output

impl<'a> Shl<i64> for &'a i128

type Output = <i128 as Shl<i64>>::Output

pub fn shl(self, other: i64) -> <i128 as Shl<i64>>::Output

impl Shl<i16> for i8

type Output = i8

pub fn shl(self, other: i16) -> i8

impl<'_, '_> Shl<&'_ u64> for &'_ i8

type Output = <i8 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <i8 as Shl<u64>>::Output

impl<'_> Shl<&'_ u64> for u64

type Output = <u64 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <u64 as Shl<u64>>::Output

impl Shl<u8> for usize

type Output = usize

pub fn shl(self, other: u8) -> usize

impl Shl<i128> for usize

type Output = usize

pub fn shl(self, other: i128) -> usize

impl<'a> Shl<u16> for &'a i32

type Output = <i32 as Shl<u16>>::Output

pub fn shl(self, other: u16) -> <i32 as Shl<u16>>::Output

impl<'_, '_> Shl<&'_ i32> for &'_ i8

type Output = <i8 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <i8 as Shl<i32>>::Output

impl<'_> Shl<&'_ u64> for u16

type Output = <u16 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <u16 as Shl<u64>>::Output

impl Shl<u8> for isize

type Output = isize

pub fn shl(self, other: u8) -> isize

impl<'_, '_> Shl<&'_ i16> for &'_ isize

type Output = <isize as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <isize as Shl<i16>>::Output

impl<'_, '_> Shl<&'_ i32> for &'_ u8

type Output = <u8 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <u8 as Shl<i32>>::Output

impl<'a> Shl<i64> for &'a u16

type Output = <u16 as Shl<i64>>::Output

pub fn shl(self, other: i64) -> <u16 as Shl<i64>>::Output

impl Shl<i8> for u32

type Output = u32

pub fn shl(self, other: i8) -> u32

impl Shl<i32> for i8

type Output = i8

pub fn shl(self, other: i32) -> i8

impl<'a> Shl<usize> for &'a u8

type Output = <u8 as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <u8 as Shl<usize>>::Output

impl<'_, '_> Shl<&'_ u8> for &'_ u8

type Output = <u8 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <u8 as Shl<u8>>::Output

impl Shl<isize> for i128

type Output = i128

pub fn shl(self, other: isize) -> i128

impl Shl<i32> for i16

type Output = i16

pub fn shl(self, other: i32) -> i16

impl<'_, '_> Shl<&'_ i128> for &'_ i16

type Output = <i16 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <i16 as Shl<i128>>::Output

impl<'_> Shl<&'_ u64> for i64

type Output = <i64 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <i64 as Shl<u64>>::Output

impl<'_> Shl<&'_ i16> for u32

type Output = <u32 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <u32 as Shl<i16>>::Output

impl Shl<u16> for u64

type Output = u64

pub fn shl(self, other: u16) -> u64

impl<'_> Shl<&'_ i16> for i64

type Output = <i64 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <i64 as Shl<i16>>::Output

impl<'_> Shl<&'_ i64> for i128

type Output = <i128 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <i128 as Shl<i64>>::Output

impl<'_> Shl<&'_ u16> for i8

type Output = <i8 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <i8 as Shl<u16>>::Output

impl<'_> Shl<&'_ i16> for i16

type Output = <i16 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <i16 as Shl<i16>>::Output

impl<'_> Shl<&'_ isize> for i128

type Output = <i128 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <i128 as Shl<isize>>::Output

impl<'_, '_> Shl<&'_ i8> for &'_ u8

type Output = <u8 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <u8 as Shl<i8>>::Output

impl<'_> Shl<&'_ u32> for i128

type Output = <i128 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <i128 as Shl<u32>>::Output

impl<'_> Shl<&'_ i16> for u8

type Output = <u8 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <u8 as Shl<i16>>::Output

impl<'_> Shl<&'_ usize> for i64

type Output = <i64 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <i64 as Shl<usize>>::Output

impl<'a> Shl<u64> for &'a u128

type Output = <u128 as Shl<u64>>::Output

pub fn shl(self, other: u64) -> <u128 as Shl<u64>>::Output

impl<'_, '_> Shl<&'_ u128> for &'_ u128

type Output = <u128 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <u128 as Shl<u128>>::Output

impl Shl<u32> for i64

type Output = i64

pub fn shl(self, other: u32) -> i64

impl<'a> Shl<u16> for &'a u32

type Output = <u32 as Shl<u16>>::Output

pub fn shl(self, other: u16) -> <u32 as Shl<u16>>::Output

impl Shl<u64> for u128

type Output = u128

pub fn shl(self, other: u64) -> u128

impl<'_> Shl<&'_ u128> for i8

type Output = <i8 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <i8 as Shl<u128>>::Output

impl<'a> Shl<i128> for &'a isize

type Output = <isize as Shl<i128>>::Output

pub fn shl(self, other: i128) -> <isize as Shl<i128>>::Output

impl<'a> Shl<u8> for &'a usize

type Output = <usize as Shl<u8>>::Output

pub fn shl(self, other: u8) -> <usize as Shl<u8>>::Output

impl<'_, '_> Shl<&'_ i8> for &'_ i128

type Output = <i128 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <i128 as Shl<i8>>::Output

impl<'_> Shl<&'_ u16> for i64

type Output = <i64 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <i64 as Shl<u16>>::Output

impl<'a> Shl<u128> for &'a usize

type Output = <usize as Shl<u128>>::Output

pub fn shl(self, other: u128) -> <usize as Shl<u128>>::Output

impl Shl<usize> for u64

type Output = u64

pub fn shl(self, other: usize) -> u64

impl<'a> Shl<u128> for &'a u16

type Output = <u16 as Shl<u128>>::Output

pub fn shl(self, other: u128) -> <u16 as Shl<u128>>::Output

impl Shl<u32> for i8

type Output = i8

pub fn shl(self, other: u32) -> i8

impl<'_> Shl<&'_ u16> for u16

type Output = <u16 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <u16 as Shl<u16>>::Output

impl<'a> Shl<i16> for &'a i64

type Output = <i64 as Shl<i16>>::Output

pub fn shl(self, other: i16) -> <i64 as Shl<i16>>::Output

impl<'_> Shl<&'_ u128> for usize

type Output = <usize as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <usize as Shl<u128>>::Output

impl<'_> Shl<&'_ u16> for u8

type Output = <u8 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <u8 as Shl<u16>>::Output

impl<'_> Shl<&'_ i128> for i16

type Output = <i16 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <i16 as Shl<i128>>::Output

impl Shl<i8> for u8

type Output = u8

pub fn shl(self, other: i8) -> u8

impl<'_> Shl<&'_ u8> for i64

type Output = <i64 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <i64 as Shl<u8>>::Output

impl<'_> Shl<&'_ usize> for u16

type Output = <u16 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <u16 as Shl<usize>>::Output

impl<'a> Shl<i8> for &'a u64

type Output = <u64 as Shl<i8>>::Output

pub fn shl(self, other: i8) -> <u64 as Shl<i8>>::Output

impl<'a> Shl<i16> for &'a usize

type Output = <usize as Shl<i16>>::Output

pub fn shl(self, other: i16) -> <usize as Shl<i16>>::Output

impl<'_, '_> Shl<&'_ u8> for &'_ i8

type Output = <i8 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <i8 as Shl<u8>>::Output

impl Shl<i64> for u32

type Output = u32

pub fn shl(self, other: i64) -> u32

impl<'_, '_> Shl<&'_ u128> for &'_ isize

type Output = <isize as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <isize as Shl<u128>>::Output

impl<'_> Shl<&'_ i32> for u64

type Output = <u64 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <u64 as Shl<i32>>::Output

impl Shl<i128> for u128

type Output = u128

pub fn shl(self, other: i128) -> u128

impl<'a> Shl<isize> for &'a i128

type Output = <i128 as Shl<isize>>::Output

pub fn shl(self, other: isize) -> <i128 as Shl<isize>>::Output

impl<'a> Shl<u16> for &'a u128

type Output = <u128 as Shl<u16>>::Output

pub fn shl(self, other: u16) -> <u128 as Shl<u16>>::Output

impl<'_> Shl<&'_ usize> for i32

type Output = <i32 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <i32 as Shl<usize>>::Output

impl Shl<i32> for usize

type Output = usize

pub fn shl(self, other: i32) -> usize

impl<'a> Shl<u8> for &'a i16

type Output = <i16 as Shl<u8>>::Output

pub fn shl(self, other: u8) -> <i16 as Shl<u8>>::Output

impl<'_> Shl<&'_ i64> for i64

type Output = <i64 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <i64 as Shl<i64>>::Output

impl Shl<u16> for u128

type Output = u128

pub fn shl(self, other: u16) -> u128

impl<'_, '_> Shl<&'_ u32> for &'_ i32

type Output = <i32 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <i32 as Shl<u32>>::Output

impl<'_> Shl<&'_ i32> for i32

type Output = <i32 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <i32 as Shl<i32>>::Output

impl Shl<u32> for usize

type Output = usize

pub fn shl(self, other: u32) -> usize

impl<'_> Shl<&'_ i8> for isize

type Output = <isize as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <isize as Shl<i8>>::Output

impl<'a> Shl<u16> for &'a isize

type Output = <isize as Shl<u16>>::Output

pub fn shl(self, other: u16) -> <isize as Shl<u16>>::Output

impl<'_, '_> Shl<&'_ i128> for &'_ u32

type Output = <u32 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <u32 as Shl<i128>>::Output

impl<'a> Shl<usize> for &'a usize

type Output = <usize as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <usize as Shl<usize>>::Output

impl Shl<i32> for u32

type Output = u32

pub fn shl(self, other: i32) -> u32

impl<'_, '_> Shl<&'_ usize> for &'_ u32

type Output = <u32 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <u32 as Shl<usize>>::Output

impl<'_> Shl<&'_ isize> for u128

type Output = <u128 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <u128 as Shl<isize>>::Output

impl<'_, '_> Shl<&'_ u8> for &'_ u16

type Output = <u16 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <u16 as Shl<u8>>::Output

impl Shl<u16> for i128

type Output = i128

pub fn shl(self, other: u16) -> i128

impl Shl<isize> for u32

type Output = u32

pub fn shl(self, other: isize) -> u32

impl<'a> Shl<u16> for &'a i128

type Output = <i128 as Shl<u16>>::Output

pub fn shl(self, other: u16) -> <i128 as Shl<u16>>::Output

impl<'_, '_> Shl<&'_ u64> for &'_ usize

type Output = <usize as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <usize as Shl<u64>>::Output

impl<'_> Shl<&'_ u128> for u64

type Output = <u64 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <u64 as Shl<u128>>::Output

impl<'_> Shl<&'_ i64> for u32

type Output = <u32 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <u32 as Shl<i64>>::Output

impl<'_, '_> Shl<&'_ u32> for &'_ usize

type Output = <usize as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <usize as Shl<u32>>::Output

impl<'a> Shl<i64> for &'a u32

type Output = <u32 as Shl<i64>>::Output

pub fn shl(self, other: i64) -> <u32 as Shl<i64>>::Output

impl<'_, '_> Shl<&'_ u8> for &'_ u32

type Output = <u32 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <u32 as Shl<u8>>::Output

impl<'a> Shl<u128> for &'a i32

type Output = <i32 as Shl<u128>>::Output

pub fn shl(self, other: u128) -> <i32 as Shl<u128>>::Output

impl<'_> Shl<&'_ u8> for i32

type Output = <i32 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <i32 as Shl<u8>>::Output

impl Shl<i128> for i64

type Output = i64

pub fn shl(self, other: i128) -> i64

impl<'a> Shl<u8> for &'a isize

type Output = <isize as Shl<u8>>::Output

pub fn shl(self, other: u8) -> <isize as Shl<u8>>::Output

impl Shl<i64> for u16

type Output = u16

pub fn shl(self, other: i64) -> u16

impl<'_> Shl<&'_ u32> for u128

type Output = <u128 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <u128 as Shl<u32>>::Output

impl<'a> Shl<i32> for &'a usize

type Output = <usize as Shl<i32>>::Output

pub fn shl(self, other: i32) -> <usize as Shl<i32>>::Output

impl<'_, '_> Shl<&'_ i32> for &'_ u64

type Output = <u64 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <u64 as Shl<i32>>::Output

impl<'_, '_> Shl<&'_ i128> for &'_ u16

type Output = <u16 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <u16 as Shl<i128>>::Output

impl<'a> Shl<isize> for &'a u16

type Output = <u16 as Shl<isize>>::Output

pub fn shl(self, other: isize) -> <u16 as Shl<isize>>::Output

impl<'_> Shl<&'_ u128> for isize

type Output = <isize as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <isize as Shl<u128>>::Output

impl<'_> Shl<&'_ i8> for i16

type Output = <i16 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <i16 as Shl<i8>>::Output

impl<'_, '_> Shl<&'_ u128> for &'_ u8

type Output = <u8 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <u8 as Shl<u128>>::Output

impl Shl<u8> for i64

type Output = i64

pub fn shl(self, other: u8) -> i64

impl<'a> Shl<isize> for &'a u32

type Output = <u32 as Shl<isize>>::Output

pub fn shl(self, other: isize) -> <u32 as Shl<isize>>::Output

impl Shl<u8> for u32

type Output = u32

pub fn shl(self, other: u8) -> u32

impl<'a> Shl<usize> for &'a i16

type Output = <i16 as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <i16 as Shl<usize>>::Output

impl<'_> Shl<&'_ i32> for u16

type Output = <u16 as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <u16 as Shl<i32>>::Output

impl Shl<usize> for i8

type Output = i8

pub fn shl(self, other: usize) -> i8

impl<'_, '_> Shl<&'_ u16> for &'_ i8

type Output = <i8 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <i8 as Shl<u16>>::Output

impl<'_> Shl<&'_ i64> for i8

type Output = <i8 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <i8 as Shl<i64>>::Output

impl<'a> Shl<u16> for &'a u16

type Output = <u16 as Shl<u16>>::Output

pub fn shl(self, other: u16) -> <u16 as Shl<u16>>::Output

impl<'_> Shl<&'_ isize> for isize

type Output = <isize as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <isize as Shl<isize>>::Output

impl<'a> Shl<u8> for &'a u32

type Output = <u32 as Shl<u8>>::Output

pub fn shl(self, other: u8) -> <u32 as Shl<u8>>::Output

impl<'a> Shl<u64> for &'a i32

type Output = <i32 as Shl<u64>>::Output

pub fn shl(self, other: u64) -> <i32 as Shl<u64>>::Output

impl<'_> Shl<&'_ isize> for u64

type Output = <u64 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <u64 as Shl<isize>>::Output

impl<'a> Shl<u32> for &'a i32

type Output = <i32 as Shl<u32>>::Output

pub fn shl(self, other: u32) -> <i32 as Shl<u32>>::Output

impl<'_> Shl<&'_ i128> for isize

type Output = <isize as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <isize as Shl<i128>>::Output

impl Shl<u64> for i32

type Output = i32

pub fn shl(self, other: u64) -> i32

impl<'_> Shl<&'_ u32> for usize

type Output = <usize as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <usize as Shl<u32>>::Output

impl<'_, '_> Shl<&'_ isize> for &'_ u64

type Output = <u64 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <u64 as Shl<isize>>::Output

impl<'_> Shl<&'_ isize> for i32

type Output = <i32 as Shl<isize>>::Output

pub fn shl(self, other: &isize) -> <i32 as Shl<isize>>::Output

impl Shl<usize> for u32

type Output = u32

pub fn shl(self, other: usize) -> u32

impl<'_, '_> Shl<&'_ u16> for &'_ u32

type Output = <u32 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <u32 as Shl<u16>>::Output

impl<'_> Shl<&'_ u32> for u32

type Output = <u32 as Shl<u32>>::Output

pub fn shl(self, other: &u32) -> <u32 as Shl<u32>>::Output

impl Shl<i128> for u64

type Output = u64

pub fn shl(self, other: i128) -> u64

impl<'_> Shl<&'_ i32> for isize

type Output = <isize as Shl<i32>>::Output

pub fn shl(self, other: &i32) -> <isize as Shl<i32>>::Output

impl<'_> Shl<&'_ i16> for u64

type Output = <u64 as Shl<i16>>::Output

pub fn shl(self, other: &i16) -> <u64 as Shl<i16>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ i16

type Output = <i16 as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <i16 as Shl<usize>>::Output

impl<'a> Shl<i32> for &'a i128

type Output = <i128 as Shl<i32>>::Output

pub fn shl(self, other: i32) -> <i128 as Shl<i32>>::Output

impl<'_, '_> Shl<&'_ i64> for &'_ u32

type Output = <u32 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <u32 as Shl<i64>>::Output

impl Shl<i32> for u128

type Output = u128

pub fn shl(self, other: i32) -> u128

impl<'_, '_> Shl<&'_ i128> for &'_ i8

type Output = <i8 as Shl<i128>>::Output

pub fn shl(self, other: &i128) -> <i8 as Shl<i128>>::Output

impl<'a> Shl<i8> for &'a isize

type Output = <isize as Shl<i8>>::Output

pub fn shl(self, other: i8) -> <isize as Shl<i8>>::Output

impl<'a> Shl<i8> for &'a u8

type Output = <u8 as Shl<i8>>::Output

pub fn shl(self, other: i8) -> <u8 as Shl<i8>>::Output

impl<'_, '_> Shl<&'_ i64> for &'_ u64

type Output = <u64 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <u64 as Shl<i64>>::Output

impl Shl<i32> for i64

type Output = i64

pub fn shl(self, other: i32) -> i64

impl Shl<isize> for usize

type Output = usize

pub fn shl(self, other: isize) -> usize

impl<'_, '_> Shl<&'_ u8> for &'_ i64

type Output = <i64 as Shl<u8>>::Output

pub fn shl(self, other: &u8) -> <i64 as Shl<u8>>::Output

impl<'_, '_> Shl<&'_ i64> for &'_ u128

type Output = <u128 as Shl<i64>>::Output

pub fn shl(self, other: &i64) -> <u128 as Shl<i64>>::Output

impl Shl<i128> for u16

type Output = u16

pub fn shl(self, other: i128) -> u16

impl<'_, '_> Shl<&'_ u64> for &'_ i16

type Output = <i16 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <i16 as Shl<u64>>::Output

impl<'_> Shl<&'_ u64> for i32

type Output = <i32 as Shl<u64>>::Output

pub fn shl(self, other: &u64) -> <i32 as Shl<u64>>::Output

impl<'_> Shl<&'_ u128> for u128

type Output = <u128 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <u128 as Shl<u128>>::Output

impl<'_, '_> Shl<&'_ u16> for &'_ u64

type Output = <u64 as Shl<u16>>::Output

pub fn shl(self, other: &u16) -> <u64 as Shl<u16>>::Output

impl<'a> Shl<i16> for &'a i32

type Output = <i32 as Shl<i16>>::Output

pub fn shl(self, other: i16) -> <i32 as Shl<i16>>::Output

impl<'_> Shl<&'_ i8> for i8

type Output = <i8 as Shl<i8>>::Output

pub fn shl(self, other: &i8) -> <i8 as Shl<i8>>::Output

impl<'_, '_> Shl<&'_ u128> for &'_ u64

type Output = <u64 as Shl<u128>>::Output

pub fn shl(self, other: &u128) -> <u64 as Shl<u128>>::Output

impl Shl<i8> for usize

type Output = usize

pub fn shl(self, other: i8) -> usize

impl<'a, S, D> Shl<&'a ArrayBase<S, D>> for i8 where
    S: Data<Elem = i8>,
    D: Dimension, 

type Output = ArrayBase<OwnedRepr<i8>, D>

pub fn shl(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i8>, D>

impl<'a, S, D> Shl<&'a ArrayBase<S, D>> for u32 where
    S: Data<Elem = u32>,
    D: Dimension, 

type Output = ArrayBase<OwnedRepr<u32>, D>

pub fn shl(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u32>, D>

impl<'a, S, D> Shl<&'a ArrayBase<S, D>> for i128 where
    S: Data<Elem = i128>,
    D: Dimension, 

type Output = ArrayBase<OwnedRepr<i128>, D>

pub fn shl(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i128>, D>

impl<S, D> Shl<ArrayBase<S, D>> for i16 where
    S: DataOwned<Elem = i16> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn shl(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Shl<&'a ArrayBase<S, D>> for u16 where
    S: Data<Elem = u16>,
    D: Dimension, 

type Output = ArrayBase<OwnedRepr<u16>, D>

pub fn shl(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u16>, D>

impl<'a, S, D> Shl<&'a ArrayBase<S, D>> for i32 where
    S: Data<Elem = i32>,
    D: Dimension, 

type Output = ArrayBase<OwnedRepr<i32>, D>

pub fn shl(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i32>, D>

impl<S, D> Shl<ArrayBase<S, D>> for u8 where
    S: DataOwned<Elem = u8> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn shl(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Shl<ArrayBase<S, D>> for i32 where
    S: DataOwned<Elem = i32> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn shl(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Shl<&'a ArrayBase<S, D>> for i16 where
    S: Data<Elem = i16>,
    D: Dimension, 

type Output = ArrayBase<OwnedRepr<i16>, D>

pub fn shl(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i16>, D>

impl<'a, S, D> Shl<&'a ArrayBase<S, D>> for u128 where
    S: Data<Elem = u128>,
    D: Dimension, 

type Output = ArrayBase<OwnedRepr<u128>, D>

pub fn shl(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u128>, D>

impl<S, D> Shl<ArrayBase<S, D>> for i8 where
    S: DataOwned<Elem = i8> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn shl(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Shl<ArrayBase<S, D>> for u128 where
    S: DataOwned<Elem = u128> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn shl(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Shl<&'a ArrayBase<S, D>> for u64 where
    S: Data<Elem = u64>,
    D: Dimension, 

type Output = ArrayBase<OwnedRepr<u64>, D>

pub fn shl(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u64>, D>

impl<S, D> Shl<ArrayBase<S, D>> for i64 where
    S: DataOwned<Elem = i64> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn shl(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Shl<ArrayBase<S, D>> for u32 where
    S: DataOwned<Elem = u32> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn shl(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Shl<ArrayBase<S, D>> for i128 where
    S: DataOwned<Elem = i128> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn shl(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<S, D> Shl<ArrayBase<S, D>> for u16 where
    S: DataOwned<Elem = u16> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn shl(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

impl<'a, S, D> Shl<&'a ArrayBase<S, D>> for u8 where
    S: Data<Elem = u8>,
    D: Dimension, 

type Output = ArrayBase<OwnedRepr<u8>, D>

pub fn shl(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<u8>, D>

impl<'a, S, D> Shl<&'a ArrayBase<S, D>> for i64 where
    S: Data<Elem = i64>,
    D: Dimension, 

type Output = ArrayBase<OwnedRepr<i64>, D>

pub fn shl(self, rhs: &ArrayBase<S, D>) -> ArrayBase<OwnedRepr<i64>, D>

impl<S, D> Shl<ArrayBase<S, D>> for u64 where
    S: DataOwned<Elem = u64> + DataMut,
    D: Dimension, 

type Output = ArrayBase<S, D>

pub fn shl(self, rhs: ArrayBase<S, D>) -> ArrayBase<S, D>

Loading content...

Implementors

impl Shl<usize> for Wrapping<i8>

type Output = Wrapping<i8>

pub fn shl(self, other: usize) -> Wrapping<i8>

impl Shl<usize> for Wrapping<i16>

type Output = Wrapping<i16>

pub fn shl(self, other: usize) -> Wrapping<i16>

impl Shl<usize> for Wrapping<i32>

type Output = Wrapping<i32>

pub fn shl(self, other: usize) -> Wrapping<i32>

impl Shl<usize> for Wrapping<i64>

type Output = Wrapping<i64>

pub fn shl(self, other: usize) -> Wrapping<i64>

impl Shl<usize> for Wrapping<i128>

type Output = Wrapping<i128>

pub fn shl(self, other: usize) -> Wrapping<i128>

impl Shl<usize> for Wrapping<isize>

type Output = Wrapping<isize>

pub fn shl(self, other: usize) -> Wrapping<isize>

impl Shl<usize> for Wrapping<u8>

type Output = Wrapping<u8>

pub fn shl(self, other: usize) -> Wrapping<u8>

impl Shl<usize> for Wrapping<u16>

type Output = Wrapping<u16>

pub fn shl(self, other: usize) -> Wrapping<u16>

impl Shl<usize> for Wrapping<u32>

type Output = Wrapping<u32>

pub fn shl(self, other: usize) -> Wrapping<u32>

impl Shl<usize> for Wrapping<u64>

type Output = Wrapping<u64>

pub fn shl(self, other: usize) -> Wrapping<u64>

impl Shl<usize> for Wrapping<u128>

type Output = Wrapping<u128>

pub fn shl(self, other: usize) -> Wrapping<u128>

impl Shl<usize> for Wrapping<usize>

type Output = Wrapping<usize>

pub fn shl(self, other: usize) -> Wrapping<usize>

impl<'_> Shl<&'_ usize> for Wrapping<i8>

type Output = <Wrapping<i8> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<i8> as Shl<usize>>::Output

impl<'_> Shl<&'_ usize> for Wrapping<i16>

type Output = <Wrapping<i16> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<i16> as Shl<usize>>::Output

impl<'_> Shl<&'_ usize> for Wrapping<i32>

type Output = <Wrapping<i32> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<i32> as Shl<usize>>::Output

impl<'_> Shl<&'_ usize> for Wrapping<i64>

type Output = <Wrapping<i64> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<i64> as Shl<usize>>::Output

impl<'_> Shl<&'_ usize> for Wrapping<i128>

type Output = <Wrapping<i128> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<i128> as Shl<usize>>::Output

impl<'_> Shl<&'_ usize> for Wrapping<isize>

type Output = <Wrapping<isize> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<isize> as Shl<usize>>::Output

impl<'_> Shl<&'_ usize> for Wrapping<u8>

type Output = <Wrapping<u8> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<u8> as Shl<usize>>::Output

impl<'_> Shl<&'_ usize> for Wrapping<u16>

type Output = <Wrapping<u16> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<u16> as Shl<usize>>::Output

impl<'_> Shl<&'_ usize> for Wrapping<u32>

type Output = <Wrapping<u32> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<u32> as Shl<usize>>::Output

impl<'_> Shl<&'_ usize> for Wrapping<u64>

type Output = <Wrapping<u64> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<u64> as Shl<usize>>::Output

impl<'_> Shl<&'_ usize> for Wrapping<u128>

type Output = <Wrapping<u128> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<u128> as Shl<usize>>::Output

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

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

pub fn shl(self, other: &usize) -> <Wrapping<usize> as Shl<usize>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ Wrapping<i8>

type Output = <Wrapping<i8> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<i8> as Shl<usize>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ Wrapping<i16>

type Output = <Wrapping<i16> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<i16> as Shl<usize>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ Wrapping<i32>

type Output = <Wrapping<i32> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<i32> as Shl<usize>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ Wrapping<i64>

type Output = <Wrapping<i64> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<i64> as Shl<usize>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ Wrapping<i128>

type Output = <Wrapping<i128> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<i128> as Shl<usize>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ Wrapping<isize>

type Output = <Wrapping<isize> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<isize> as Shl<usize>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ Wrapping<u8>

type Output = <Wrapping<u8> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<u8> as Shl<usize>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ Wrapping<u16>

type Output = <Wrapping<u16> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<u16> as Shl<usize>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ Wrapping<u32>

type Output = <Wrapping<u32> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<u32> as Shl<usize>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ Wrapping<u64>

type Output = <Wrapping<u64> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<u64> as Shl<usize>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ Wrapping<u128>

type Output = <Wrapping<u128> as Shl<usize>>::Output

pub fn shl(self, other: &usize) -> <Wrapping<u128> as Shl<usize>>::Output

impl<'_, '_> Shl<&'_ usize> for &'_ Wrapping<usize>

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

pub fn shl(self, other: &usize) -> <Wrapping<usize> as Shl<usize>>::Output

impl<'a> Shl<usize> for &'a Wrapping<i8>

type Output = <Wrapping<i8> as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <Wrapping<i8> as Shl<usize>>::Output

impl<'a> Shl<usize> for &'a Wrapping<i16>

type Output = <Wrapping<i16> as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <Wrapping<i16> as Shl<usize>>::Output

impl<'a> Shl<usize> for &'a Wrapping<i32>

type Output = <Wrapping<i32> as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <Wrapping<i32> as Shl<usize>>::Output

impl<'a> Shl<usize> for &'a Wrapping<i64>

type Output = <Wrapping<i64> as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <Wrapping<i64> as Shl<usize>>::Output

impl<'a> Shl<usize> for &'a Wrapping<i128>

type Output = <Wrapping<i128> as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <Wrapping<i128> as Shl<usize>>::Output

impl<'a> Shl<usize> for &'a Wrapping<isize>

type Output = <Wrapping<isize> as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <Wrapping<isize> as Shl<usize>>::Output

impl<'a> Shl<usize> for &'a Wrapping<u8>

type Output = <Wrapping<u8> as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <Wrapping<u8> as Shl<usize>>::Output

impl<'a> Shl<usize> for &'a Wrapping<u16>

type Output = <Wrapping<u16> as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <Wrapping<u16> as Shl<usize>>::Output

impl<'a> Shl<usize> for &'a Wrapping<u32>

type Output = <Wrapping<u32> as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <Wrapping<u32> as Shl<usize>>::Output

impl<'a> Shl<usize> for &'a Wrapping<u64>

type Output = <Wrapping<u64> as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <Wrapping<u64> as Shl<usize>>::Output

impl<'a> Shl<usize> for &'a Wrapping<u128>

type Output = <Wrapping<u128> as Shl<usize>>::Output

pub fn shl(self, other: usize) -> <Wrapping<u128> as Shl<usize>>::Output

impl<'a> Shl<usize> for &'a Wrapping<usize>

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

pub fn shl(self, other: usize) -> <Wrapping<usize> as Shl<usize>>::Output

impl<'a, A, B, S, S2, D, E> Shl<&'a ArrayBase<S2, E>> for &'a ArrayBase<S, D> where
    S: Data<Elem = A>,
    E: Dimension,
    A: Clone + Shl<B, Output = A>,
    B: Clone,
    D: Dimension,
    S2: Data<Elem = B>, 

Perform elementwise left shift between references self and rhs, and return the result as a new Array.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<OwnedRepr<A>, D>

pub fn shl(self, rhs: &'a ArrayBase<S2, E>) -> ArrayBase<OwnedRepr<A>, D>

impl<'a, A, B, S, S2, D, E> Shl<&'a ArrayBase<S2, E>> for ArrayBase<S, D> where
    S: DataOwned<Elem = A> + DataMut,
    E: Dimension,
    A: Clone + Shl<B, Output = A>,
    B: Clone,
    D: Dimension,
    S2: Data<Elem = B>, 

Perform elementwise left shift between self and reference rhs, and return the result (based on self).

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

pub fn shl(self, rhs: &ArrayBase<S2, E>) -> ArrayBase<S, D>

impl<'a, A, S, D, B> Shl<B> for &'a ArrayBase<S, D> where
    S: Data<Elem = A>,
    A: Clone + Shl<B, Output = A>,
    B: ScalarOperand,
    D: Dimension, 

Perform elementwise left shift between the reference self and the scalar x, and return the result as a new Array.

type Output = ArrayBase<OwnedRepr<A>, D>

pub fn shl(self, x: B) -> ArrayBase<OwnedRepr<A>, D>

impl<A, B, S, S2, D, E> Shl<ArrayBase<S2, E>> for ArrayBase<S, D> where
    S: DataOwned<Elem = A> + DataMut,
    E: Dimension,
    A: Clone + Shl<B, Output = A>,
    B: Clone,
    D: Dimension,
    S2: Data<Elem = B>, 

Perform elementwise left shift between self and rhs, and return the result (based on self).

self must be an Array or ArcArray.

If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

type Output = ArrayBase<S, D>

pub fn shl(self, rhs: ArrayBase<S2, E>) -> ArrayBase<S, D>

impl<A, S, D, B> Shl<B> for ArrayBase<S, D> where
    S: DataOwned<Elem = A> + DataMut,
    A: Clone + Shl<B, Output = A>,
    B: ScalarOperand,
    D: Dimension, 

Perform elementwise left shift between self and the scalar x, and return the result (based on self).

self must be an Array or ArcArray.

type Output = ArrayBase<S, D>

pub fn shl(self, x: B) -> ArrayBase<S, D>

Loading content...