Enum Nullable 

pub enum Nullable<T: NullStorable> {
    Value(T),
    Null,
}

Nullable Scalar

Variants

Value(T)

Value which is not Null

Null

Null

Implementations

impl<T: NullStorable> Nullable<T>

/////////////////////////////////////////////////////////////////////////////

pub fn new(value: T) -> Self

Create new Nullable<T> from T.

Float NAN is automatically replaced to Null.

Examples

use std::f64;
use nullvec::prelude::*;

let n = Nullable::new(1);
assert_eq!(&n + 1, Nullable::new(2));
assert_eq!(&n + Nullable::Null, Nullable::Null);

let n = Nullable::new(f64::NAN);
assert_eq!(n, Nullable::Null);

Trait Implementations

impl<'a, 'b> Add<&'a Nullable<f32>> for &'b NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<f32>) -> NullVec<f32>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<f32>> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<f32>) -> Nullable<f32>

Performs the + operation.

impl<'a> Add<&'a Nullable<f32>> for NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<f32>) -> NullVec<f32>

Performs the + operation.

impl<'a> Add<&'a Nullable<f32>> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<f32>) -> Nullable<f32>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<f64>> for &'b NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<f64>) -> NullVec<f64>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<f64>> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<f64>) -> Nullable<f64>

Performs the + operation.

impl<'a> Add<&'a Nullable<f64>> for NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<f64>) -> NullVec<f64>

Performs the + operation.

impl<'a> Add<&'a Nullable<f64>> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<f64>) -> Nullable<f64>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<i16>> for &'b NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<i16>) -> NullVec<i16>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<i16>> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<i16>) -> Nullable<i16>

Performs the + operation.

impl<'a> Add<&'a Nullable<i16>> for NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<i16>) -> NullVec<i16>

Performs the + operation.

impl<'a> Add<&'a Nullable<i16>> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<i16>) -> Nullable<i16>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<i32>> for &'b NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<i32>) -> NullVec<i32>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<i32>> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<i32>) -> Nullable<i32>

Performs the + operation.

impl<'a> Add<&'a Nullable<i32>> for NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<i32>) -> NullVec<i32>

Performs the + operation.

impl<'a> Add<&'a Nullable<i32>> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<i32>) -> Nullable<i32>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<i64>> for &'b NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<i64>) -> NullVec<i64>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<i64>> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<i64>) -> Nullable<i64>

Performs the + operation.

impl<'a> Add<&'a Nullable<i64>> for NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<i64>) -> NullVec<i64>

Performs the + operation.

impl<'a> Add<&'a Nullable<i64>> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<i64>) -> Nullable<i64>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<i8>> for &'b NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<i8>) -> NullVec<i8>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<i8>> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<i8>) -> Nullable<i8>

Performs the + operation.

impl<'a> Add<&'a Nullable<i8>> for NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<i8>) -> NullVec<i8>

Performs the + operation.

impl<'a> Add<&'a Nullable<i8>> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<i8>) -> Nullable<i8>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<isize>> for &'b NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<isize>) -> NullVec<isize>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<isize>> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<isize>) -> Nullable<isize>

Performs the + operation.

impl<'a> Add<&'a Nullable<isize>> for NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<isize>) -> NullVec<isize>

Performs the + operation.

impl<'a> Add<&'a Nullable<isize>> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<isize>) -> Nullable<isize>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<u16>> for &'b NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<u16>) -> NullVec<u16>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<u16>> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<u16>) -> Nullable<u16>

Performs the + operation.

impl<'a> Add<&'a Nullable<u16>> for NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<u16>) -> NullVec<u16>

Performs the + operation.

impl<'a> Add<&'a Nullable<u16>> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<u16>) -> Nullable<u16>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<u32>> for &'b NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<u32>) -> NullVec<u32>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<u32>> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<u32>) -> Nullable<u32>

Performs the + operation.

impl<'a> Add<&'a Nullable<u32>> for NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<u32>) -> NullVec<u32>

Performs the + operation.

impl<'a> Add<&'a Nullable<u32>> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<u32>) -> Nullable<u32>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<u64>> for &'b NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<u64>) -> NullVec<u64>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<u64>> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<u64>) -> Nullable<u64>

Performs the + operation.

impl<'a> Add<&'a Nullable<u64>> for NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<u64>) -> NullVec<u64>

Performs the + operation.

impl<'a> Add<&'a Nullable<u64>> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<u64>) -> Nullable<u64>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<u8>> for &'b NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<u8>) -> NullVec<u8>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<u8>> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<u8>) -> Nullable<u8>

Performs the + operation.

impl<'a> Add<&'a Nullable<u8>> for NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<u8>) -> NullVec<u8>

Performs the + operation.

impl<'a> Add<&'a Nullable<u8>> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<u8>) -> Nullable<u8>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<usize>> for &'b NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<usize>) -> NullVec<usize>

Performs the + operation.

impl<'a, 'b> Add<&'a Nullable<usize>> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<usize>) -> Nullable<usize>

Performs the + operation.

impl<'a> Add<&'a Nullable<usize>> for NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<usize>) -> NullVec<usize>

Performs the + operation.

impl<'a> Add<&'a Nullable<usize>> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the + operator.

fn add(self, other: &'a Nullable<usize>) -> Nullable<usize>

Performs the + operation.

impl<'a, 'b> Add<&'a f32> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the + operator.

fn add(self, other: &'a f32) -> Nullable<f32>

Performs the + operation.

impl<'a> Add<&'a f32> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the + operator.

fn add(self, other: &'a f32) -> Nullable<f32>

Performs the + operation.

impl<'a, 'b> Add<&'a f64> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the + operator.

fn add(self, other: &'a f64) -> Nullable<f64>

Performs the + operation.

impl<'a> Add<&'a f64> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the + operator.

fn add(self, other: &'a f64) -> Nullable<f64>

Performs the + operation.

impl<'a, 'b> Add<&'a i16> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the + operator.

fn add(self, other: &'a i16) -> Nullable<i16>

Performs the + operation.

impl<'a> Add<&'a i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the + operator.

fn add(self, other: &'a i16) -> Nullable<i16>

Performs the + operation.

impl<'a, 'b> Add<&'a i32> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the + operator.

fn add(self, other: &'a i32) -> Nullable<i32>

Performs the + operation.

impl<'a> Add<&'a i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the + operator.

fn add(self, other: &'a i32) -> Nullable<i32>

Performs the + operation.

impl<'a, 'b> Add<&'a i64> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the + operator.

fn add(self, other: &'a i64) -> Nullable<i64>

Performs the + operation.

impl<'a> Add<&'a i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the + operator.

fn add(self, other: &'a i64) -> Nullable<i64>

Performs the + operation.

impl<'a, 'b> Add<&'a i8> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the + operator.

fn add(self, other: &'a i8) -> Nullable<i8>

Performs the + operation.

impl<'a> Add<&'a i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the + operator.

fn add(self, other: &'a i8) -> Nullable<i8>

Performs the + operation.

impl<'a, 'b> Add<&'a isize> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the + operator.

fn add(self, other: &'a isize) -> Nullable<isize>

Performs the + operation.

impl<'a> Add<&'a isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the + operator.

fn add(self, other: &'a isize) -> Nullable<isize>

Performs the + operation.

impl<'a, 'b> Add<&'a u16> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the + operator.

fn add(self, other: &'a u16) -> Nullable<u16>

Performs the + operation.

impl<'a> Add<&'a u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the + operator.

fn add(self, other: &'a u16) -> Nullable<u16>

Performs the + operation.

impl<'a, 'b> Add<&'a u32> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the + operator.

fn add(self, other: &'a u32) -> Nullable<u32>

Performs the + operation.

impl<'a> Add<&'a u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the + operator.

fn add(self, other: &'a u32) -> Nullable<u32>

Performs the + operation.

impl<'a, 'b> Add<&'a u64> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the + operator.

fn add(self, other: &'a u64) -> Nullable<u64>

Performs the + operation.

impl<'a> Add<&'a u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the + operator.

fn add(self, other: &'a u64) -> Nullable<u64>

Performs the + operation.

impl<'a, 'b> Add<&'a u8> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the + operator.

fn add(self, other: &'a u8) -> Nullable<u8>

Performs the + operation.

impl<'a> Add<&'a u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the + operator.

fn add(self, other: &'a u8) -> Nullable<u8>

Performs the + operation.

impl<'a, 'b> Add<&'a usize> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the + operator.

fn add(self, other: &'a usize) -> Nullable<usize>

Performs the + operation.

impl<'a> Add<&'a usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the + operator.

fn add(self, other: &'a usize) -> Nullable<usize>

Performs the + operation.

impl<'b> Add<Nullable<f32>> for &'b NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the + operator.

fn add(self, other: Nullable<f32>) -> NullVec<f32>

Performs the + operation.

impl<'b> Add<Nullable<f32>> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the + operator.

fn add(self, other: Nullable<f32>) -> Nullable<f32>

Performs the + operation.

impl Add<Nullable<f32>> for NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the + operator.

fn add(self, other: Nullable<f32>) -> NullVec<f32>

Performs the + operation.

impl<'b> Add<Nullable<f64>> for &'b NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the + operator.

fn add(self, other: Nullable<f64>) -> NullVec<f64>

Performs the + operation.

impl<'b> Add<Nullable<f64>> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the + operator.

fn add(self, other: Nullable<f64>) -> Nullable<f64>

Performs the + operation.

impl Add<Nullable<f64>> for NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the + operator.

fn add(self, other: Nullable<f64>) -> NullVec<f64>

Performs the + operation.

impl<'b> Add<Nullable<i16>> for &'b NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the + operator.

fn add(self, other: Nullable<i16>) -> NullVec<i16>

Performs the + operation.

impl<'b> Add<Nullable<i16>> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the + operator.

fn add(self, other: Nullable<i16>) -> Nullable<i16>

Performs the + operation.

impl Add<Nullable<i16>> for NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the + operator.

fn add(self, other: Nullable<i16>) -> NullVec<i16>

Performs the + operation.

impl<'b> Add<Nullable<i32>> for &'b NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the + operator.

fn add(self, other: Nullable<i32>) -> NullVec<i32>

Performs the + operation.

impl<'b> Add<Nullable<i32>> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the + operator.

fn add(self, other: Nullable<i32>) -> Nullable<i32>

Performs the + operation.

impl Add<Nullable<i32>> for NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the + operator.

fn add(self, other: Nullable<i32>) -> NullVec<i32>

Performs the + operation.

impl<'b> Add<Nullable<i64>> for &'b NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the + operator.

fn add(self, other: Nullable<i64>) -> NullVec<i64>

Performs the + operation.

impl<'b> Add<Nullable<i64>> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the + operator.

fn add(self, other: Nullable<i64>) -> Nullable<i64>

Performs the + operation.

impl Add<Nullable<i64>> for NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the + operator.

fn add(self, other: Nullable<i64>) -> NullVec<i64>

Performs the + operation.

impl<'b> Add<Nullable<i8>> for &'b NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the + operator.

fn add(self, other: Nullable<i8>) -> NullVec<i8>

Performs the + operation.

impl<'b> Add<Nullable<i8>> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the + operator.

fn add(self, other: Nullable<i8>) -> Nullable<i8>

Performs the + operation.

impl Add<Nullable<i8>> for NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the + operator.

fn add(self, other: Nullable<i8>) -> NullVec<i8>

Performs the + operation.

impl<'b> Add<Nullable<isize>> for &'b NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the + operator.

fn add(self, other: Nullable<isize>) -> NullVec<isize>

Performs the + operation.

impl<'b> Add<Nullable<isize>> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the + operator.

fn add(self, other: Nullable<isize>) -> Nullable<isize>

Performs the + operation.

impl Add<Nullable<isize>> for NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the + operator.

fn add(self, other: Nullable<isize>) -> NullVec<isize>

Performs the + operation.

impl<'b> Add<Nullable<u16>> for &'b NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the + operator.

fn add(self, other: Nullable<u16>) -> NullVec<u16>

Performs the + operation.

impl<'b> Add<Nullable<u16>> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the + operator.

fn add(self, other: Nullable<u16>) -> Nullable<u16>

Performs the + operation.

impl Add<Nullable<u16>> for NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the + operator.

fn add(self, other: Nullable<u16>) -> NullVec<u16>

Performs the + operation.

impl<'b> Add<Nullable<u32>> for &'b NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the + operator.

fn add(self, other: Nullable<u32>) -> NullVec<u32>

Performs the + operation.

impl<'b> Add<Nullable<u32>> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the + operator.

fn add(self, other: Nullable<u32>) -> Nullable<u32>

Performs the + operation.

impl Add<Nullable<u32>> for NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the + operator.

fn add(self, other: Nullable<u32>) -> NullVec<u32>

Performs the + operation.

impl<'b> Add<Nullable<u64>> for &'b NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the + operator.

fn add(self, other: Nullable<u64>) -> NullVec<u64>

Performs the + operation.

impl<'b> Add<Nullable<u64>> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the + operator.

fn add(self, other: Nullable<u64>) -> Nullable<u64>

Performs the + operation.

impl Add<Nullable<u64>> for NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the + operator.

fn add(self, other: Nullable<u64>) -> NullVec<u64>

Performs the + operation.

impl<'b> Add<Nullable<u8>> for &'b NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the + operator.

fn add(self, other: Nullable<u8>) -> NullVec<u8>

Performs the + operation.

impl<'b> Add<Nullable<u8>> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the + operator.

fn add(self, other: Nullable<u8>) -> Nullable<u8>

Performs the + operation.

impl Add<Nullable<u8>> for NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the + operator.

fn add(self, other: Nullable<u8>) -> NullVec<u8>

Performs the + operation.

impl<'b> Add<Nullable<usize>> for &'b NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the + operator.

fn add(self, other: Nullable<usize>) -> NullVec<usize>

Performs the + operation.

impl<'b> Add<Nullable<usize>> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the + operator.

fn add(self, other: Nullable<usize>) -> Nullable<usize>

Performs the + operation.

impl Add<Nullable<usize>> for NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the + operator.

fn add(self, other: Nullable<usize>) -> NullVec<usize>

Performs the + operation.

impl<'b> Add<f32> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the + operator.

fn add(self, other: f32) -> Nullable<f32>

Performs the + operation.

impl Add<f32> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the + operator.

fn add(self, other: f32) -> Nullable<f32>

Performs the + operation.

impl<'b> Add<f64> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the + operator.

fn add(self, other: f64) -> Nullable<f64>

Performs the + operation.

impl Add<f64> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the + operator.

fn add(self, other: f64) -> Nullable<f64>

Performs the + operation.

impl<'b> Add<i16> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the + operator.

fn add(self, other: i16) -> Nullable<i16>

Performs the + operation.

impl Add<i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the + operator.

fn add(self, other: i16) -> Nullable<i16>

Performs the + operation.

impl<'b> Add<i32> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the + operator.

fn add(self, other: i32) -> Nullable<i32>

Performs the + operation.

impl Add<i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the + operator.

fn add(self, other: i32) -> Nullable<i32>

Performs the + operation.

impl<'b> Add<i64> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the + operator.

fn add(self, other: i64) -> Nullable<i64>

Performs the + operation.

impl Add<i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the + operator.

fn add(self, other: i64) -> Nullable<i64>

Performs the + operation.

impl<'b> Add<i8> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the + operator.

fn add(self, other: i8) -> Nullable<i8>

Performs the + operation.

impl Add<i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the + operator.

fn add(self, other: i8) -> Nullable<i8>

Performs the + operation.

impl<'b> Add<isize> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the + operator.

fn add(self, other: isize) -> Nullable<isize>

Performs the + operation.

impl Add<isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the + operator.

fn add(self, other: isize) -> Nullable<isize>

Performs the + operation.

impl<'b> Add<u16> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the + operator.

fn add(self, other: u16) -> Nullable<u16>

Performs the + operation.

impl Add<u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the + operator.

fn add(self, other: u16) -> Nullable<u16>

Performs the + operation.

impl<'b> Add<u32> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the + operator.

fn add(self, other: u32) -> Nullable<u32>

Performs the + operation.

impl Add<u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the + operator.

fn add(self, other: u32) -> Nullable<u32>

Performs the + operation.

impl<'b> Add<u64> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the + operator.

fn add(self, other: u64) -> Nullable<u64>

Performs the + operation.

impl Add<u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the + operator.

fn add(self, other: u64) -> Nullable<u64>

Performs the + operation.

impl<'b> Add<u8> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the + operator.

fn add(self, other: u8) -> Nullable<u8>

Performs the + operation.

impl Add<u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the + operator.

fn add(self, other: u8) -> Nullable<u8>

Performs the + operation.

impl<'b> Add<usize> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the + operator.

fn add(self, other: usize) -> Nullable<usize>

Performs the + operation.

impl Add<usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the + operator.

fn add(self, other: usize) -> Nullable<usize>

Performs the + operation.

impl Add for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the + operator.

fn add(self, other: Nullable<f32>) -> Nullable<f32>

Performs the + operation.

impl Add for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the + operator.

fn add(self, other: Nullable<f64>) -> Nullable<f64>

Performs the + operation.

impl Add for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the + operator.

fn add(self, other: Nullable<i16>) -> Nullable<i16>

Performs the + operation.

impl Add for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the + operator.

fn add(self, other: Nullable<i32>) -> Nullable<i32>

Performs the + operation.

impl Add for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the + operator.

fn add(self, other: Nullable<i64>) -> Nullable<i64>

Performs the + operation.

impl Add for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the + operator.

fn add(self, other: Nullable<i8>) -> Nullable<i8>

Performs the + operation.

impl Add for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the + operator.

fn add(self, other: Nullable<isize>) -> Nullable<isize>

Performs the + operation.

impl Add for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the + operator.

fn add(self, other: Nullable<u16>) -> Nullable<u16>

Performs the + operation.

impl Add for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the + operator.

fn add(self, other: Nullable<u32>) -> Nullable<u32>

Performs the + operation.

impl Add for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the + operator.

fn add(self, other: Nullable<u64>) -> Nullable<u64>

Performs the + operation.

impl Add for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the + operator.

fn add(self, other: Nullable<u8>) -> Nullable<u8>

Performs the + operation.

impl Add for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the + operator.

fn add(self, other: Nullable<usize>) -> Nullable<usize>

Performs the + operation.

impl<'a, 'b> BitAnd<&'a Nullable<bool>> for &'b NullVec<bool>

type Output = NullVec<bool>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<bool>) -> NullVec<bool>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<bool>> for &'b Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<bool>) -> Nullable<bool>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<bool>> for NullVec<bool>

type Output = NullVec<bool>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<bool>) -> NullVec<bool>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<bool>> for Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<bool>) -> Nullable<bool>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<i16>> for &'b NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<i16>) -> NullVec<i16>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<i16>> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<i16>) -> Nullable<i16>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<i16>> for NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<i16>) -> NullVec<i16>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<i16>> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<i16>) -> Nullable<i16>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<i32>> for &'b NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<i32>) -> NullVec<i32>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<i32>> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<i32>) -> Nullable<i32>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<i32>> for NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<i32>) -> NullVec<i32>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<i32>> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<i32>) -> Nullable<i32>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<i64>> for &'b NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<i64>) -> NullVec<i64>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<i64>> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<i64>) -> Nullable<i64>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<i64>> for NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<i64>) -> NullVec<i64>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<i64>> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<i64>) -> Nullable<i64>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<i8>> for &'b NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<i8>) -> NullVec<i8>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<i8>> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<i8>) -> Nullable<i8>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<i8>> for NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<i8>) -> NullVec<i8>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<i8>> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<i8>) -> Nullable<i8>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<isize>> for &'b NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<isize>) -> NullVec<isize>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<isize>> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<isize>) -> Nullable<isize>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<isize>> for NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<isize>) -> NullVec<isize>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<isize>> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<isize>) -> Nullable<isize>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<u16>> for &'b NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<u16>) -> NullVec<u16>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<u16>> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<u16>) -> Nullable<u16>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<u16>> for NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<u16>) -> NullVec<u16>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<u16>> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<u16>) -> Nullable<u16>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<u32>> for &'b NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<u32>) -> NullVec<u32>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<u32>> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<u32>) -> Nullable<u32>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<u32>> for NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<u32>) -> NullVec<u32>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<u32>> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<u32>) -> Nullable<u32>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<u64>> for &'b NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<u64>) -> NullVec<u64>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<u64>> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<u64>) -> Nullable<u64>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<u64>> for NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<u64>) -> NullVec<u64>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<u64>> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<u64>) -> Nullable<u64>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<u8>> for &'b NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<u8>) -> NullVec<u8>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<u8>> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<u8>) -> Nullable<u8>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<u8>> for NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<u8>) -> NullVec<u8>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<u8>> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<u8>) -> Nullable<u8>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<usize>> for &'b NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<usize>) -> NullVec<usize>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a Nullable<usize>> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<usize>) -> Nullable<usize>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<usize>> for NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<usize>) -> NullVec<usize>

Performs the & operation.

impl<'a> BitAnd<&'a Nullable<usize>> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Nullable<usize>) -> Nullable<usize>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a bool> for &'b Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the & operator.

fn bitand(self, other: &'a bool) -> Nullable<bool>

Performs the & operation.

impl<'a> BitAnd<&'a bool> for Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the & operator.

fn bitand(self, other: &'a bool) -> Nullable<bool>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a i16> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the & operator.

fn bitand(self, other: &'a i16) -> Nullable<i16>

Performs the & operation.

impl<'a> BitAnd<&'a i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the & operator.

fn bitand(self, other: &'a i16) -> Nullable<i16>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a i32> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the & operator.

fn bitand(self, other: &'a i32) -> Nullable<i32>

Performs the & operation.

impl<'a> BitAnd<&'a i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the & operator.

fn bitand(self, other: &'a i32) -> Nullable<i32>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a i64> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the & operator.

fn bitand(self, other: &'a i64) -> Nullable<i64>

Performs the & operation.

impl<'a> BitAnd<&'a i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the & operator.

fn bitand(self, other: &'a i64) -> Nullable<i64>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a i8> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the & operator.

fn bitand(self, other: &'a i8) -> Nullable<i8>

Performs the & operation.

impl<'a> BitAnd<&'a i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the & operator.

fn bitand(self, other: &'a i8) -> Nullable<i8>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a isize> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the & operator.

fn bitand(self, other: &'a isize) -> Nullable<isize>

Performs the & operation.

impl<'a> BitAnd<&'a isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the & operator.

fn bitand(self, other: &'a isize) -> Nullable<isize>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a u16> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the & operator.

fn bitand(self, other: &'a u16) -> Nullable<u16>

Performs the & operation.

impl<'a> BitAnd<&'a u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the & operator.

fn bitand(self, other: &'a u16) -> Nullable<u16>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a u32> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the & operator.

fn bitand(self, other: &'a u32) -> Nullable<u32>

Performs the & operation.

impl<'a> BitAnd<&'a u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the & operator.

fn bitand(self, other: &'a u32) -> Nullable<u32>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a u64> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the & operator.

fn bitand(self, other: &'a u64) -> Nullable<u64>

Performs the & operation.

impl<'a> BitAnd<&'a u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the & operator.

fn bitand(self, other: &'a u64) -> Nullable<u64>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a u8> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the & operator.

fn bitand(self, other: &'a u8) -> Nullable<u8>

Performs the & operation.

impl<'a> BitAnd<&'a u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the & operator.

fn bitand(self, other: &'a u8) -> Nullable<u8>

Performs the & operation.

impl<'a, 'b> BitAnd<&'a usize> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the & operator.

fn bitand(self, other: &'a usize) -> Nullable<usize>

Performs the & operation.

impl<'a> BitAnd<&'a usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the & operator.

fn bitand(self, other: &'a usize) -> Nullable<usize>

Performs the & operation.

impl<'b> BitAnd<Nullable<bool>> for &'b NullVec<bool>

type Output = NullVec<bool>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<bool>) -> NullVec<bool>

Performs the & operation.

impl<'b> BitAnd<Nullable<bool>> for &'b Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<bool>) -> Nullable<bool>

Performs the & operation.

impl BitAnd<Nullable<bool>> for NullVec<bool>

type Output = NullVec<bool>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<bool>) -> NullVec<bool>

Performs the & operation.

impl<'b> BitAnd<Nullable<i16>> for &'b NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<i16>) -> NullVec<i16>

Performs the & operation.

impl<'b> BitAnd<Nullable<i16>> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<i16>) -> Nullable<i16>

Performs the & operation.

impl BitAnd<Nullable<i16>> for NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<i16>) -> NullVec<i16>

Performs the & operation.

impl<'b> BitAnd<Nullable<i32>> for &'b NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<i32>) -> NullVec<i32>

Performs the & operation.

impl<'b> BitAnd<Nullable<i32>> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<i32>) -> Nullable<i32>

Performs the & operation.

impl BitAnd<Nullable<i32>> for NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<i32>) -> NullVec<i32>

Performs the & operation.

impl<'b> BitAnd<Nullable<i64>> for &'b NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<i64>) -> NullVec<i64>

Performs the & operation.

impl<'b> BitAnd<Nullable<i64>> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<i64>) -> Nullable<i64>

Performs the & operation.

impl BitAnd<Nullable<i64>> for NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<i64>) -> NullVec<i64>

Performs the & operation.

impl<'b> BitAnd<Nullable<i8>> for &'b NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<i8>) -> NullVec<i8>

Performs the & operation.

impl<'b> BitAnd<Nullable<i8>> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<i8>) -> Nullable<i8>

Performs the & operation.

impl BitAnd<Nullable<i8>> for NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<i8>) -> NullVec<i8>

Performs the & operation.

impl<'b> BitAnd<Nullable<isize>> for &'b NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<isize>) -> NullVec<isize>

Performs the & operation.

impl<'b> BitAnd<Nullable<isize>> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<isize>) -> Nullable<isize>

Performs the & operation.

impl BitAnd<Nullable<isize>> for NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<isize>) -> NullVec<isize>

Performs the & operation.

impl<'b> BitAnd<Nullable<u16>> for &'b NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<u16>) -> NullVec<u16>

Performs the & operation.

impl<'b> BitAnd<Nullable<u16>> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<u16>) -> Nullable<u16>

Performs the & operation.

impl BitAnd<Nullable<u16>> for NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<u16>) -> NullVec<u16>

Performs the & operation.

impl<'b> BitAnd<Nullable<u32>> for &'b NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<u32>) -> NullVec<u32>

Performs the & operation.

impl<'b> BitAnd<Nullable<u32>> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<u32>) -> Nullable<u32>

Performs the & operation.

impl BitAnd<Nullable<u32>> for NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<u32>) -> NullVec<u32>

Performs the & operation.

impl<'b> BitAnd<Nullable<u64>> for &'b NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<u64>) -> NullVec<u64>

Performs the & operation.

impl<'b> BitAnd<Nullable<u64>> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<u64>) -> Nullable<u64>

Performs the & operation.

impl BitAnd<Nullable<u64>> for NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<u64>) -> NullVec<u64>

Performs the & operation.

impl<'b> BitAnd<Nullable<u8>> for &'b NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<u8>) -> NullVec<u8>

Performs the & operation.

impl<'b> BitAnd<Nullable<u8>> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<u8>) -> Nullable<u8>

Performs the & operation.

impl BitAnd<Nullable<u8>> for NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<u8>) -> NullVec<u8>

Performs the & operation.

impl<'b> BitAnd<Nullable<usize>> for &'b NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<usize>) -> NullVec<usize>

Performs the & operation.

impl<'b> BitAnd<Nullable<usize>> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<usize>) -> Nullable<usize>

Performs the & operation.

impl BitAnd<Nullable<usize>> for NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<usize>) -> NullVec<usize>

Performs the & operation.

impl<'b> BitAnd<bool> for &'b Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the & operator.

fn bitand(self, other: bool) -> Nullable<bool>

Performs the & operation.

impl BitAnd<bool> for Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the & operator.

fn bitand(self, other: bool) -> Nullable<bool>

Performs the & operation.

impl<'b> BitAnd<i16> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the & operator.

fn bitand(self, other: i16) -> Nullable<i16>

Performs the & operation.

impl BitAnd<i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the & operator.

fn bitand(self, other: i16) -> Nullable<i16>

Performs the & operation.

impl<'b> BitAnd<i32> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the & operator.

fn bitand(self, other: i32) -> Nullable<i32>

Performs the & operation.

impl BitAnd<i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the & operator.

fn bitand(self, other: i32) -> Nullable<i32>

Performs the & operation.

impl<'b> BitAnd<i64> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the & operator.

fn bitand(self, other: i64) -> Nullable<i64>

Performs the & operation.

impl BitAnd<i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the & operator.

fn bitand(self, other: i64) -> Nullable<i64>

Performs the & operation.

impl<'b> BitAnd<i8> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the & operator.

fn bitand(self, other: i8) -> Nullable<i8>

Performs the & operation.

impl BitAnd<i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the & operator.

fn bitand(self, other: i8) -> Nullable<i8>

Performs the & operation.

impl<'b> BitAnd<isize> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the & operator.

fn bitand(self, other: isize) -> Nullable<isize>

Performs the & operation.

impl BitAnd<isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the & operator.

fn bitand(self, other: isize) -> Nullable<isize>

Performs the & operation.

impl<'b> BitAnd<u16> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the & operator.

fn bitand(self, other: u16) -> Nullable<u16>

Performs the & operation.

impl BitAnd<u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the & operator.

fn bitand(self, other: u16) -> Nullable<u16>

Performs the & operation.

impl<'b> BitAnd<u32> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the & operator.

fn bitand(self, other: u32) -> Nullable<u32>

Performs the & operation.

impl BitAnd<u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the & operator.

fn bitand(self, other: u32) -> Nullable<u32>

Performs the & operation.

impl<'b> BitAnd<u64> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the & operator.

fn bitand(self, other: u64) -> Nullable<u64>

Performs the & operation.

impl BitAnd<u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the & operator.

fn bitand(self, other: u64) -> Nullable<u64>

Performs the & operation.

impl<'b> BitAnd<u8> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the & operator.

fn bitand(self, other: u8) -> Nullable<u8>

Performs the & operation.

impl BitAnd<u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the & operator.

fn bitand(self, other: u8) -> Nullable<u8>

Performs the & operation.

impl<'b> BitAnd<usize> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the & operator.

fn bitand(self, other: usize) -> Nullable<usize>

Performs the & operation.

impl BitAnd<usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the & operator.

fn bitand(self, other: usize) -> Nullable<usize>

Performs the & operation.

impl BitAnd for Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<bool>) -> Nullable<bool>

Performs the & operation.

impl BitAnd for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<i16>) -> Nullable<i16>

Performs the & operation.

impl BitAnd for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<i32>) -> Nullable<i32>

Performs the & operation.

impl BitAnd for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<i64>) -> Nullable<i64>

Performs the & operation.

impl BitAnd for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<i8>) -> Nullable<i8>

Performs the & operation.

impl BitAnd for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<isize>) -> Nullable<isize>

Performs the & operation.

impl BitAnd for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<u16>) -> Nullable<u16>

Performs the & operation.

impl BitAnd for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<u32>) -> Nullable<u32>

Performs the & operation.

impl BitAnd for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<u64>) -> Nullable<u64>

Performs the & operation.

impl BitAnd for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<u8>) -> Nullable<u8>

Performs the & operation.

impl BitAnd for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the & operator.

fn bitand(self, other: Nullable<usize>) -> Nullable<usize>

Performs the & operation.

impl<'a, 'b> BitOr<&'a Nullable<bool>> for &'b NullVec<bool>

type Output = NullVec<bool>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<bool>) -> NullVec<bool>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<bool>> for &'b Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<bool>) -> Nullable<bool>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<bool>> for NullVec<bool>

type Output = NullVec<bool>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<bool>) -> NullVec<bool>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<bool>> for Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<bool>) -> Nullable<bool>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<i16>> for &'b NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<i16>) -> NullVec<i16>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<i16>> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<i16>) -> Nullable<i16>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<i16>> for NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<i16>) -> NullVec<i16>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<i16>> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<i16>) -> Nullable<i16>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<i32>> for &'b NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<i32>) -> NullVec<i32>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<i32>> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<i32>) -> Nullable<i32>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<i32>> for NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<i32>) -> NullVec<i32>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<i32>> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<i32>) -> Nullable<i32>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<i64>> for &'b NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<i64>) -> NullVec<i64>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<i64>> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<i64>) -> Nullable<i64>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<i64>> for NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<i64>) -> NullVec<i64>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<i64>> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<i64>) -> Nullable<i64>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<i8>> for &'b NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<i8>) -> NullVec<i8>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<i8>> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<i8>) -> Nullable<i8>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<i8>> for NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<i8>) -> NullVec<i8>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<i8>> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<i8>) -> Nullable<i8>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<isize>> for &'b NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<isize>) -> NullVec<isize>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<isize>> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<isize>) -> Nullable<isize>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<isize>> for NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<isize>) -> NullVec<isize>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<isize>> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<isize>) -> Nullable<isize>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<u16>> for &'b NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<u16>) -> NullVec<u16>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<u16>> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<u16>) -> Nullable<u16>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<u16>> for NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<u16>) -> NullVec<u16>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<u16>> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<u16>) -> Nullable<u16>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<u32>> for &'b NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<u32>) -> NullVec<u32>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<u32>> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<u32>) -> Nullable<u32>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<u32>> for NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<u32>) -> NullVec<u32>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<u32>> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<u32>) -> Nullable<u32>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<u64>> for &'b NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<u64>) -> NullVec<u64>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<u64>> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<u64>) -> Nullable<u64>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<u64>> for NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<u64>) -> NullVec<u64>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<u64>> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<u64>) -> Nullable<u64>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<u8>> for &'b NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<u8>) -> NullVec<u8>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<u8>> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<u8>) -> Nullable<u8>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<u8>> for NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<u8>) -> NullVec<u8>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<u8>> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<u8>) -> Nullable<u8>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<usize>> for &'b NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<usize>) -> NullVec<usize>

Performs the | operation.

impl<'a, 'b> BitOr<&'a Nullable<usize>> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<usize>) -> Nullable<usize>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<usize>> for NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<usize>) -> NullVec<usize>

Performs the | operation.

impl<'a> BitOr<&'a Nullable<usize>> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Nullable<usize>) -> Nullable<usize>

Performs the | operation.

impl<'a, 'b> BitOr<&'a bool> for &'b Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the | operator.

fn bitor(self, other: &'a bool) -> Nullable<bool>

Performs the | operation.

impl<'a> BitOr<&'a bool> for Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the | operator.

fn bitor(self, other: &'a bool) -> Nullable<bool>

Performs the | operation.

impl<'a, 'b> BitOr<&'a i16> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the | operator.

fn bitor(self, other: &'a i16) -> Nullable<i16>

Performs the | operation.

impl<'a> BitOr<&'a i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the | operator.

fn bitor(self, other: &'a i16) -> Nullable<i16>

Performs the | operation.

impl<'a, 'b> BitOr<&'a i32> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the | operator.

fn bitor(self, other: &'a i32) -> Nullable<i32>

Performs the | operation.

impl<'a> BitOr<&'a i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the | operator.

fn bitor(self, other: &'a i32) -> Nullable<i32>

Performs the | operation.

impl<'a, 'b> BitOr<&'a i64> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the | operator.

fn bitor(self, other: &'a i64) -> Nullable<i64>

Performs the | operation.

impl<'a> BitOr<&'a i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the | operator.

fn bitor(self, other: &'a i64) -> Nullable<i64>

Performs the | operation.

impl<'a, 'b> BitOr<&'a i8> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the | operator.

fn bitor(self, other: &'a i8) -> Nullable<i8>

Performs the | operation.

impl<'a> BitOr<&'a i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the | operator.

fn bitor(self, other: &'a i8) -> Nullable<i8>

Performs the | operation.

impl<'a, 'b> BitOr<&'a isize> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the | operator.

fn bitor(self, other: &'a isize) -> Nullable<isize>

Performs the | operation.

impl<'a> BitOr<&'a isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the | operator.

fn bitor(self, other: &'a isize) -> Nullable<isize>

Performs the | operation.

impl<'a, 'b> BitOr<&'a u16> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the | operator.

fn bitor(self, other: &'a u16) -> Nullable<u16>

Performs the | operation.

impl<'a> BitOr<&'a u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the | operator.

fn bitor(self, other: &'a u16) -> Nullable<u16>

Performs the | operation.

impl<'a, 'b> BitOr<&'a u32> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the | operator.

fn bitor(self, other: &'a u32) -> Nullable<u32>

Performs the | operation.

impl<'a> BitOr<&'a u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the | operator.

fn bitor(self, other: &'a u32) -> Nullable<u32>

Performs the | operation.

impl<'a, 'b> BitOr<&'a u64> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the | operator.

fn bitor(self, other: &'a u64) -> Nullable<u64>

Performs the | operation.

impl<'a> BitOr<&'a u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the | operator.

fn bitor(self, other: &'a u64) -> Nullable<u64>

Performs the | operation.

impl<'a, 'b> BitOr<&'a u8> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the | operator.

fn bitor(self, other: &'a u8) -> Nullable<u8>

Performs the | operation.

impl<'a> BitOr<&'a u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the | operator.

fn bitor(self, other: &'a u8) -> Nullable<u8>

Performs the | operation.

impl<'a, 'b> BitOr<&'a usize> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the | operator.

fn bitor(self, other: &'a usize) -> Nullable<usize>

Performs the | operation.

impl<'a> BitOr<&'a usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the | operator.

fn bitor(self, other: &'a usize) -> Nullable<usize>

Performs the | operation.

impl<'b> BitOr<Nullable<bool>> for &'b NullVec<bool>

type Output = NullVec<bool>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<bool>) -> NullVec<bool>

Performs the | operation.

impl<'b> BitOr<Nullable<bool>> for &'b Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<bool>) -> Nullable<bool>

Performs the | operation.

impl BitOr<Nullable<bool>> for NullVec<bool>

type Output = NullVec<bool>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<bool>) -> NullVec<bool>

Performs the | operation.

impl<'b> BitOr<Nullable<i16>> for &'b NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<i16>) -> NullVec<i16>

Performs the | operation.

impl<'b> BitOr<Nullable<i16>> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<i16>) -> Nullable<i16>

Performs the | operation.

impl BitOr<Nullable<i16>> for NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<i16>) -> NullVec<i16>

Performs the | operation.

impl<'b> BitOr<Nullable<i32>> for &'b NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<i32>) -> NullVec<i32>

Performs the | operation.

impl<'b> BitOr<Nullable<i32>> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<i32>) -> Nullable<i32>

Performs the | operation.

impl BitOr<Nullable<i32>> for NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<i32>) -> NullVec<i32>

Performs the | operation.

impl<'b> BitOr<Nullable<i64>> for &'b NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<i64>) -> NullVec<i64>

Performs the | operation.

impl<'b> BitOr<Nullable<i64>> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<i64>) -> Nullable<i64>

Performs the | operation.

impl BitOr<Nullable<i64>> for NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<i64>) -> NullVec<i64>

Performs the | operation.

impl<'b> BitOr<Nullable<i8>> for &'b NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<i8>) -> NullVec<i8>

Performs the | operation.

impl<'b> BitOr<Nullable<i8>> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<i8>) -> Nullable<i8>

Performs the | operation.

impl BitOr<Nullable<i8>> for NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<i8>) -> NullVec<i8>

Performs the | operation.

impl<'b> BitOr<Nullable<isize>> for &'b NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<isize>) -> NullVec<isize>

Performs the | operation.

impl<'b> BitOr<Nullable<isize>> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<isize>) -> Nullable<isize>

Performs the | operation.

impl BitOr<Nullable<isize>> for NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<isize>) -> NullVec<isize>

Performs the | operation.

impl<'b> BitOr<Nullable<u16>> for &'b NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<u16>) -> NullVec<u16>

Performs the | operation.

impl<'b> BitOr<Nullable<u16>> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<u16>) -> Nullable<u16>

Performs the | operation.

impl BitOr<Nullable<u16>> for NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<u16>) -> NullVec<u16>

Performs the | operation.

impl<'b> BitOr<Nullable<u32>> for &'b NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<u32>) -> NullVec<u32>

Performs the | operation.

impl<'b> BitOr<Nullable<u32>> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<u32>) -> Nullable<u32>

Performs the | operation.

impl BitOr<Nullable<u32>> for NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<u32>) -> NullVec<u32>

Performs the | operation.

impl<'b> BitOr<Nullable<u64>> for &'b NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<u64>) -> NullVec<u64>

Performs the | operation.

impl<'b> BitOr<Nullable<u64>> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<u64>) -> Nullable<u64>

Performs the | operation.

impl BitOr<Nullable<u64>> for NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<u64>) -> NullVec<u64>

Performs the | operation.

impl<'b> BitOr<Nullable<u8>> for &'b NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<u8>) -> NullVec<u8>

Performs the | operation.

impl<'b> BitOr<Nullable<u8>> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<u8>) -> Nullable<u8>

Performs the | operation.

impl BitOr<Nullable<u8>> for NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<u8>) -> NullVec<u8>

Performs the | operation.

impl<'b> BitOr<Nullable<usize>> for &'b NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<usize>) -> NullVec<usize>

Performs the | operation.

impl<'b> BitOr<Nullable<usize>> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<usize>) -> Nullable<usize>

Performs the | operation.

impl BitOr<Nullable<usize>> for NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<usize>) -> NullVec<usize>

Performs the | operation.

impl<'b> BitOr<bool> for &'b Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the | operator.

fn bitor(self, other: bool) -> Nullable<bool>

Performs the | operation.

impl BitOr<bool> for Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the | operator.

fn bitor(self, other: bool) -> Nullable<bool>

Performs the | operation.

impl<'b> BitOr<i16> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the | operator.

fn bitor(self, other: i16) -> Nullable<i16>

Performs the | operation.

impl BitOr<i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the | operator.

fn bitor(self, other: i16) -> Nullable<i16>

Performs the | operation.

impl<'b> BitOr<i32> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the | operator.

fn bitor(self, other: i32) -> Nullable<i32>

Performs the | operation.

impl BitOr<i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the | operator.

fn bitor(self, other: i32) -> Nullable<i32>

Performs the | operation.

impl<'b> BitOr<i64> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the | operator.

fn bitor(self, other: i64) -> Nullable<i64>

Performs the | operation.

impl BitOr<i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the | operator.

fn bitor(self, other: i64) -> Nullable<i64>

Performs the | operation.

impl<'b> BitOr<i8> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the | operator.

fn bitor(self, other: i8) -> Nullable<i8>

Performs the | operation.

impl BitOr<i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the | operator.

fn bitor(self, other: i8) -> Nullable<i8>

Performs the | operation.

impl<'b> BitOr<isize> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the | operator.

fn bitor(self, other: isize) -> Nullable<isize>

Performs the | operation.

impl BitOr<isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the | operator.

fn bitor(self, other: isize) -> Nullable<isize>

Performs the | operation.

impl<'b> BitOr<u16> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the | operator.

fn bitor(self, other: u16) -> Nullable<u16>

Performs the | operation.

impl BitOr<u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the | operator.

fn bitor(self, other: u16) -> Nullable<u16>

Performs the | operation.

impl<'b> BitOr<u32> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the | operator.

fn bitor(self, other: u32) -> Nullable<u32>

Performs the | operation.

impl BitOr<u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the | operator.

fn bitor(self, other: u32) -> Nullable<u32>

Performs the | operation.

impl<'b> BitOr<u64> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the | operator.

fn bitor(self, other: u64) -> Nullable<u64>

Performs the | operation.

impl BitOr<u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the | operator.

fn bitor(self, other: u64) -> Nullable<u64>

Performs the | operation.

impl<'b> BitOr<u8> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the | operator.

fn bitor(self, other: u8) -> Nullable<u8>

Performs the | operation.

impl BitOr<u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the | operator.

fn bitor(self, other: u8) -> Nullable<u8>

Performs the | operation.

impl<'b> BitOr<usize> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the | operator.

fn bitor(self, other: usize) -> Nullable<usize>

Performs the | operation.

impl BitOr<usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the | operator.

fn bitor(self, other: usize) -> Nullable<usize>

Performs the | operation.

impl BitOr for Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<bool>) -> Nullable<bool>

Performs the | operation.

impl BitOr for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<i16>) -> Nullable<i16>

Performs the | operation.

impl BitOr for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<i32>) -> Nullable<i32>

Performs the | operation.

impl BitOr for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<i64>) -> Nullable<i64>

Performs the | operation.

impl BitOr for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<i8>) -> Nullable<i8>

Performs the | operation.

impl BitOr for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<isize>) -> Nullable<isize>

Performs the | operation.

impl BitOr for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<u16>) -> Nullable<u16>

Performs the | operation.

impl BitOr for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<u32>) -> Nullable<u32>

Performs the | operation.

impl BitOr for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<u64>) -> Nullable<u64>

Performs the | operation.

impl BitOr for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<u8>) -> Nullable<u8>

Performs the | operation.

impl BitOr for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the | operator.

fn bitor(self, other: Nullable<usize>) -> Nullable<usize>

Performs the | operation.

impl<'a, 'b> BitXor<&'a Nullable<bool>> for &'b NullVec<bool>

type Output = NullVec<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<bool>) -> NullVec<bool>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<bool>> for &'b Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<bool>) -> Nullable<bool>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<bool>> for NullVec<bool>

type Output = NullVec<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<bool>) -> NullVec<bool>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<bool>> for Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<bool>) -> Nullable<bool>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<i16>> for &'b NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<i16>) -> NullVec<i16>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<i16>> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<i16>) -> Nullable<i16>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<i16>> for NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<i16>) -> NullVec<i16>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<i16>> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<i16>) -> Nullable<i16>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<i32>> for &'b NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<i32>) -> NullVec<i32>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<i32>> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<i32>) -> Nullable<i32>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<i32>> for NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<i32>) -> NullVec<i32>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<i32>> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<i32>) -> Nullable<i32>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<i64>> for &'b NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<i64>) -> NullVec<i64>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<i64>> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<i64>) -> Nullable<i64>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<i64>> for NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<i64>) -> NullVec<i64>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<i64>> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<i64>) -> Nullable<i64>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<i8>> for &'b NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<i8>) -> NullVec<i8>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<i8>> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<i8>) -> Nullable<i8>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<i8>> for NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<i8>) -> NullVec<i8>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<i8>> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<i8>) -> Nullable<i8>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<isize>> for &'b NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<isize>) -> NullVec<isize>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<isize>> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<isize>) -> Nullable<isize>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<isize>> for NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<isize>) -> NullVec<isize>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<isize>> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<isize>) -> Nullable<isize>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<u16>> for &'b NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<u16>) -> NullVec<u16>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<u16>> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<u16>) -> Nullable<u16>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<u16>> for NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<u16>) -> NullVec<u16>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<u16>> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<u16>) -> Nullable<u16>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<u32>> for &'b NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<u32>) -> NullVec<u32>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<u32>> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<u32>) -> Nullable<u32>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<u32>> for NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<u32>) -> NullVec<u32>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<u32>> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<u32>) -> Nullable<u32>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<u64>> for &'b NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<u64>) -> NullVec<u64>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<u64>> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<u64>) -> Nullable<u64>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<u64>> for NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<u64>) -> NullVec<u64>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<u64>> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<u64>) -> Nullable<u64>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<u8>> for &'b NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<u8>) -> NullVec<u8>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<u8>> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<u8>) -> Nullable<u8>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<u8>> for NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<u8>) -> NullVec<u8>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<u8>> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<u8>) -> Nullable<u8>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<usize>> for &'b NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<usize>) -> NullVec<usize>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a Nullable<usize>> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<usize>) -> Nullable<usize>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<usize>> for NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<usize>) -> NullVec<usize>

Performs the ^ operation.

impl<'a> BitXor<&'a Nullable<usize>> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Nullable<usize>) -> Nullable<usize>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a bool> for &'b Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a bool) -> Nullable<bool>

Performs the ^ operation.

impl<'a> BitXor<&'a bool> for Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a bool) -> Nullable<bool>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a i16> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a i16) -> Nullable<i16>

Performs the ^ operation.

impl<'a> BitXor<&'a i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a i16) -> Nullable<i16>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a i32> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a i32) -> Nullable<i32>

Performs the ^ operation.

impl<'a> BitXor<&'a i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a i32) -> Nullable<i32>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a i64> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a i64) -> Nullable<i64>

Performs the ^ operation.

impl<'a> BitXor<&'a i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a i64) -> Nullable<i64>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a i8> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a i8) -> Nullable<i8>

Performs the ^ operation.

impl<'a> BitXor<&'a i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a i8) -> Nullable<i8>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a isize> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a isize) -> Nullable<isize>

Performs the ^ operation.

impl<'a> BitXor<&'a isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a isize) -> Nullable<isize>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a u16> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a u16) -> Nullable<u16>

Performs the ^ operation.

impl<'a> BitXor<&'a u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a u16) -> Nullable<u16>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a u32> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a u32) -> Nullable<u32>

Performs the ^ operation.

impl<'a> BitXor<&'a u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a u32) -> Nullable<u32>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a u64> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a u64) -> Nullable<u64>

Performs the ^ operation.

impl<'a> BitXor<&'a u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a u64) -> Nullable<u64>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a u8> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a u8) -> Nullable<u8>

Performs the ^ operation.

impl<'a> BitXor<&'a u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a u8) -> Nullable<u8>

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a usize> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a usize) -> Nullable<usize>

Performs the ^ operation.

impl<'a> BitXor<&'a usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a usize) -> Nullable<usize>

Performs the ^ operation.

impl<'b> BitXor<Nullable<bool>> for &'b NullVec<bool>

type Output = NullVec<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<bool>) -> NullVec<bool>

Performs the ^ operation.

impl<'b> BitXor<Nullable<bool>> for &'b Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<bool>) -> Nullable<bool>

Performs the ^ operation.

impl BitXor<Nullable<bool>> for NullVec<bool>

type Output = NullVec<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<bool>) -> NullVec<bool>

Performs the ^ operation.

impl<'b> BitXor<Nullable<i16>> for &'b NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<i16>) -> NullVec<i16>

Performs the ^ operation.

impl<'b> BitXor<Nullable<i16>> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<i16>) -> Nullable<i16>

Performs the ^ operation.

impl BitXor<Nullable<i16>> for NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<i16>) -> NullVec<i16>

Performs the ^ operation.

impl<'b> BitXor<Nullable<i32>> for &'b NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<i32>) -> NullVec<i32>

Performs the ^ operation.

impl<'b> BitXor<Nullable<i32>> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<i32>) -> Nullable<i32>

Performs the ^ operation.

impl BitXor<Nullable<i32>> for NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<i32>) -> NullVec<i32>

Performs the ^ operation.

impl<'b> BitXor<Nullable<i64>> for &'b NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<i64>) -> NullVec<i64>

Performs the ^ operation.

impl<'b> BitXor<Nullable<i64>> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<i64>) -> Nullable<i64>

Performs the ^ operation.

impl BitXor<Nullable<i64>> for NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<i64>) -> NullVec<i64>

Performs the ^ operation.

impl<'b> BitXor<Nullable<i8>> for &'b NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<i8>) -> NullVec<i8>

Performs the ^ operation.

impl<'b> BitXor<Nullable<i8>> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<i8>) -> Nullable<i8>

Performs the ^ operation.

impl BitXor<Nullable<i8>> for NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<i8>) -> NullVec<i8>

Performs the ^ operation.

impl<'b> BitXor<Nullable<isize>> for &'b NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<isize>) -> NullVec<isize>

Performs the ^ operation.

impl<'b> BitXor<Nullable<isize>> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<isize>) -> Nullable<isize>

Performs the ^ operation.

impl BitXor<Nullable<isize>> for NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<isize>) -> NullVec<isize>

Performs the ^ operation.

impl<'b> BitXor<Nullable<u16>> for &'b NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<u16>) -> NullVec<u16>

Performs the ^ operation.

impl<'b> BitXor<Nullable<u16>> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<u16>) -> Nullable<u16>

Performs the ^ operation.

impl BitXor<Nullable<u16>> for NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<u16>) -> NullVec<u16>

Performs the ^ operation.

impl<'b> BitXor<Nullable<u32>> for &'b NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<u32>) -> NullVec<u32>

Performs the ^ operation.

impl<'b> BitXor<Nullable<u32>> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<u32>) -> Nullable<u32>

Performs the ^ operation.

impl BitXor<Nullable<u32>> for NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<u32>) -> NullVec<u32>

Performs the ^ operation.

impl<'b> BitXor<Nullable<u64>> for &'b NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<u64>) -> NullVec<u64>

Performs the ^ operation.

impl<'b> BitXor<Nullable<u64>> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<u64>) -> Nullable<u64>

Performs the ^ operation.

impl BitXor<Nullable<u64>> for NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<u64>) -> NullVec<u64>

Performs the ^ operation.

impl<'b> BitXor<Nullable<u8>> for &'b NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<u8>) -> NullVec<u8>

Performs the ^ operation.

impl<'b> BitXor<Nullable<u8>> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<u8>) -> Nullable<u8>

Performs the ^ operation.

impl BitXor<Nullable<u8>> for NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<u8>) -> NullVec<u8>

Performs the ^ operation.

impl<'b> BitXor<Nullable<usize>> for &'b NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<usize>) -> NullVec<usize>

Performs the ^ operation.

impl<'b> BitXor<Nullable<usize>> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<usize>) -> Nullable<usize>

Performs the ^ operation.

impl BitXor<Nullable<usize>> for NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<usize>) -> NullVec<usize>

Performs the ^ operation.

impl<'b> BitXor<bool> for &'b Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, other: bool) -> Nullable<bool>

Performs the ^ operation.

impl BitXor<bool> for Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, other: bool) -> Nullable<bool>

Performs the ^ operation.

impl<'b> BitXor<i16> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: i16) -> Nullable<i16>

Performs the ^ operation.

impl BitXor<i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: i16) -> Nullable<i16>

Performs the ^ operation.

impl<'b> BitXor<i32> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: i32) -> Nullable<i32>

Performs the ^ operation.

impl BitXor<i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: i32) -> Nullable<i32>

Performs the ^ operation.

impl<'b> BitXor<i64> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: i64) -> Nullable<i64>

Performs the ^ operation.

impl BitXor<i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: i64) -> Nullable<i64>

Performs the ^ operation.

impl<'b> BitXor<i8> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: i8) -> Nullable<i8>

Performs the ^ operation.

impl BitXor<i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: i8) -> Nullable<i8>

Performs the ^ operation.

impl<'b> BitXor<isize> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: isize) -> Nullable<isize>

Performs the ^ operation.

impl BitXor<isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: isize) -> Nullable<isize>

Performs the ^ operation.

impl<'b> BitXor<u16> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: u16) -> Nullable<u16>

Performs the ^ operation.

impl BitXor<u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: u16) -> Nullable<u16>

Performs the ^ operation.

impl<'b> BitXor<u32> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: u32) -> Nullable<u32>

Performs the ^ operation.

impl BitXor<u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: u32) -> Nullable<u32>

Performs the ^ operation.

impl<'b> BitXor<u64> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: u64) -> Nullable<u64>

Performs the ^ operation.

impl BitXor<u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: u64) -> Nullable<u64>

Performs the ^ operation.

impl<'b> BitXor<u8> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: u8) -> Nullable<u8>

Performs the ^ operation.

impl BitXor<u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: u8) -> Nullable<u8>

Performs the ^ operation.

impl<'b> BitXor<usize> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: usize) -> Nullable<usize>

Performs the ^ operation.

impl BitXor<usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: usize) -> Nullable<usize>

Performs the ^ operation.

impl BitXor for Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<bool>) -> Nullable<bool>

Performs the ^ operation.

impl BitXor for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<i16>) -> Nullable<i16>

Performs the ^ operation.

impl BitXor for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<i32>) -> Nullable<i32>

Performs the ^ operation.

impl BitXor for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<i64>) -> Nullable<i64>

Performs the ^ operation.

impl BitXor for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<i8>) -> Nullable<i8>

Performs the ^ operation.

impl BitXor for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<isize>) -> Nullable<isize>

Performs the ^ operation.

impl BitXor for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<u16>) -> Nullable<u16>

Performs the ^ operation.

impl BitXor for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<u32>) -> Nullable<u32>

Performs the ^ operation.

impl BitXor for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<u64>) -> Nullable<u64>

Performs the ^ operation.

impl BitXor for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<u8>) -> Nullable<u8>

Performs the ^ operation.

impl BitXor for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Nullable<usize>) -> Nullable<usize>

Performs the ^ operation.

impl<T: Clone + NullStorable> Clone for Nullable<T>

fn clone(&self) -> Nullable<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + NullStorable> Debug for Nullable<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, 'b> Div<&'a Nullable<f32>> for &'b NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<f32>) -> NullVec<f32>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<f32>> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<f32>) -> Nullable<f32>

Performs the / operation.

impl<'a> Div<&'a Nullable<f32>> for NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<f32>) -> NullVec<f32>

Performs the / operation.

impl<'a> Div<&'a Nullable<f32>> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<f32>) -> Nullable<f32>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<f64>> for &'b NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<f64>) -> NullVec<f64>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<f64>> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<f64>) -> Nullable<f64>

Performs the / operation.

impl<'a> Div<&'a Nullable<f64>> for NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<f64>) -> NullVec<f64>

Performs the / operation.

impl<'a> Div<&'a Nullable<f64>> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<f64>) -> Nullable<f64>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<i16>> for &'b NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<i16>) -> NullVec<i16>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<i16>> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<i16>) -> Nullable<i16>

Performs the / operation.

impl<'a> Div<&'a Nullable<i16>> for NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<i16>) -> NullVec<i16>

Performs the / operation.

impl<'a> Div<&'a Nullable<i16>> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<i16>) -> Nullable<i16>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<i32>> for &'b NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<i32>) -> NullVec<i32>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<i32>> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<i32>) -> Nullable<i32>

Performs the / operation.

impl<'a> Div<&'a Nullable<i32>> for NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<i32>) -> NullVec<i32>

Performs the / operation.

impl<'a> Div<&'a Nullable<i32>> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<i32>) -> Nullable<i32>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<i64>> for &'b NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<i64>) -> NullVec<i64>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<i64>> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<i64>) -> Nullable<i64>

Performs the / operation.

impl<'a> Div<&'a Nullable<i64>> for NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<i64>) -> NullVec<i64>

Performs the / operation.

impl<'a> Div<&'a Nullable<i64>> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<i64>) -> Nullable<i64>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<i8>> for &'b NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<i8>) -> NullVec<i8>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<i8>> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<i8>) -> Nullable<i8>

Performs the / operation.

impl<'a> Div<&'a Nullable<i8>> for NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<i8>) -> NullVec<i8>

Performs the / operation.

impl<'a> Div<&'a Nullable<i8>> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<i8>) -> Nullable<i8>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<isize>> for &'b NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<isize>) -> NullVec<isize>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<isize>> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<isize>) -> Nullable<isize>

Performs the / operation.

impl<'a> Div<&'a Nullable<isize>> for NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<isize>) -> NullVec<isize>

Performs the / operation.

impl<'a> Div<&'a Nullable<isize>> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<isize>) -> Nullable<isize>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<u16>> for &'b NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<u16>) -> NullVec<u16>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<u16>> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<u16>) -> Nullable<u16>

Performs the / operation.

impl<'a> Div<&'a Nullable<u16>> for NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<u16>) -> NullVec<u16>

Performs the / operation.

impl<'a> Div<&'a Nullable<u16>> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<u16>) -> Nullable<u16>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<u32>> for &'b NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<u32>) -> NullVec<u32>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<u32>> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<u32>) -> Nullable<u32>

Performs the / operation.

impl<'a> Div<&'a Nullable<u32>> for NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<u32>) -> NullVec<u32>

Performs the / operation.

impl<'a> Div<&'a Nullable<u32>> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<u32>) -> Nullable<u32>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<u64>> for &'b NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<u64>) -> NullVec<u64>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<u64>> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<u64>) -> Nullable<u64>

Performs the / operation.

impl<'a> Div<&'a Nullable<u64>> for NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<u64>) -> NullVec<u64>

Performs the / operation.

impl<'a> Div<&'a Nullable<u64>> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<u64>) -> Nullable<u64>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<u8>> for &'b NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<u8>) -> NullVec<u8>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<u8>> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<u8>) -> Nullable<u8>

Performs the / operation.

impl<'a> Div<&'a Nullable<u8>> for NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<u8>) -> NullVec<u8>

Performs the / operation.

impl<'a> Div<&'a Nullable<u8>> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<u8>) -> Nullable<u8>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<usize>> for &'b NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<usize>) -> NullVec<usize>

Performs the / operation.

impl<'a, 'b> Div<&'a Nullable<usize>> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<usize>) -> Nullable<usize>

Performs the / operation.

impl<'a> Div<&'a Nullable<usize>> for NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<usize>) -> NullVec<usize>

Performs the / operation.

impl<'a> Div<&'a Nullable<usize>> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the / operator.

fn div(self, other: &'a Nullable<usize>) -> Nullable<usize>

Performs the / operation.

impl<'a, 'b> Div<&'a f32> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the / operator.

fn div(self, other: &'a f32) -> Nullable<f32>

Performs the / operation.

impl<'a> Div<&'a f32> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the / operator.

fn div(self, other: &'a f32) -> Nullable<f32>

Performs the / operation.

impl<'a, 'b> Div<&'a f64> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the / operator.

fn div(self, other: &'a f64) -> Nullable<f64>

Performs the / operation.

impl<'a> Div<&'a f64> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the / operator.

fn div(self, other: &'a f64) -> Nullable<f64>

Performs the / operation.

impl<'a, 'b> Div<&'a i16> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the / operator.

fn div(self, other: &'a i16) -> Nullable<i16>

Performs the / operation.

impl<'a> Div<&'a i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the / operator.

fn div(self, other: &'a i16) -> Nullable<i16>

Performs the / operation.

impl<'a, 'b> Div<&'a i32> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the / operator.

fn div(self, other: &'a i32) -> Nullable<i32>

Performs the / operation.

impl<'a> Div<&'a i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the / operator.

fn div(self, other: &'a i32) -> Nullable<i32>

Performs the / operation.

impl<'a, 'b> Div<&'a i64> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the / operator.

fn div(self, other: &'a i64) -> Nullable<i64>

Performs the / operation.

impl<'a> Div<&'a i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the / operator.

fn div(self, other: &'a i64) -> Nullable<i64>

Performs the / operation.

impl<'a, 'b> Div<&'a i8> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the / operator.

fn div(self, other: &'a i8) -> Nullable<i8>

Performs the / operation.

impl<'a> Div<&'a i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the / operator.

fn div(self, other: &'a i8) -> Nullable<i8>

Performs the / operation.

impl<'a, 'b> Div<&'a isize> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the / operator.

fn div(self, other: &'a isize) -> Nullable<isize>

Performs the / operation.

impl<'a> Div<&'a isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the / operator.

fn div(self, other: &'a isize) -> Nullable<isize>

Performs the / operation.

impl<'a, 'b> Div<&'a u16> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the / operator.

fn div(self, other: &'a u16) -> Nullable<u16>

Performs the / operation.

impl<'a> Div<&'a u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the / operator.

fn div(self, other: &'a u16) -> Nullable<u16>

Performs the / operation.

impl<'a, 'b> Div<&'a u32> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the / operator.

fn div(self, other: &'a u32) -> Nullable<u32>

Performs the / operation.

impl<'a> Div<&'a u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the / operator.

fn div(self, other: &'a u32) -> Nullable<u32>

Performs the / operation.

impl<'a, 'b> Div<&'a u64> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the / operator.

fn div(self, other: &'a u64) -> Nullable<u64>

Performs the / operation.

impl<'a> Div<&'a u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the / operator.

fn div(self, other: &'a u64) -> Nullable<u64>

Performs the / operation.

impl<'a, 'b> Div<&'a u8> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the / operator.

fn div(self, other: &'a u8) -> Nullable<u8>

Performs the / operation.

impl<'a> Div<&'a u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the / operator.

fn div(self, other: &'a u8) -> Nullable<u8>

Performs the / operation.

impl<'a, 'b> Div<&'a usize> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the / operator.

fn div(self, other: &'a usize) -> Nullable<usize>

Performs the / operation.

impl<'a> Div<&'a usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the / operator.

fn div(self, other: &'a usize) -> Nullable<usize>

Performs the / operation.

impl<'b> Div<Nullable<f32>> for &'b NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the / operator.

fn div(self, other: Nullable<f32>) -> NullVec<f32>

Performs the / operation.

impl<'b> Div<Nullable<f32>> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the / operator.

fn div(self, other: Nullable<f32>) -> Nullable<f32>

Performs the / operation.

impl Div<Nullable<f32>> for NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the / operator.

fn div(self, other: Nullable<f32>) -> NullVec<f32>

Performs the / operation.

impl<'b> Div<Nullable<f64>> for &'b NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the / operator.

fn div(self, other: Nullable<f64>) -> NullVec<f64>

Performs the / operation.

impl<'b> Div<Nullable<f64>> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the / operator.

fn div(self, other: Nullable<f64>) -> Nullable<f64>

Performs the / operation.

impl Div<Nullable<f64>> for NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the / operator.

fn div(self, other: Nullable<f64>) -> NullVec<f64>

Performs the / operation.

impl<'b> Div<Nullable<i16>> for &'b NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the / operator.

fn div(self, other: Nullable<i16>) -> NullVec<i16>

Performs the / operation.

impl<'b> Div<Nullable<i16>> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the / operator.

fn div(self, other: Nullable<i16>) -> Nullable<i16>

Performs the / operation.

impl Div<Nullable<i16>> for NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the / operator.

fn div(self, other: Nullable<i16>) -> NullVec<i16>

Performs the / operation.

impl<'b> Div<Nullable<i32>> for &'b NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the / operator.

fn div(self, other: Nullable<i32>) -> NullVec<i32>

Performs the / operation.

impl<'b> Div<Nullable<i32>> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the / operator.

fn div(self, other: Nullable<i32>) -> Nullable<i32>

Performs the / operation.

impl Div<Nullable<i32>> for NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the / operator.

fn div(self, other: Nullable<i32>) -> NullVec<i32>

Performs the / operation.

impl<'b> Div<Nullable<i64>> for &'b NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the / operator.

fn div(self, other: Nullable<i64>) -> NullVec<i64>

Performs the / operation.

impl<'b> Div<Nullable<i64>> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the / operator.

fn div(self, other: Nullable<i64>) -> Nullable<i64>

Performs the / operation.

impl Div<Nullable<i64>> for NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the / operator.

fn div(self, other: Nullable<i64>) -> NullVec<i64>

Performs the / operation.

impl<'b> Div<Nullable<i8>> for &'b NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the / operator.

fn div(self, other: Nullable<i8>) -> NullVec<i8>

Performs the / operation.

impl<'b> Div<Nullable<i8>> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the / operator.

fn div(self, other: Nullable<i8>) -> Nullable<i8>

Performs the / operation.

impl Div<Nullable<i8>> for NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the / operator.

fn div(self, other: Nullable<i8>) -> NullVec<i8>

Performs the / operation.

impl<'b> Div<Nullable<isize>> for &'b NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the / operator.

fn div(self, other: Nullable<isize>) -> NullVec<isize>

Performs the / operation.

impl<'b> Div<Nullable<isize>> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the / operator.

fn div(self, other: Nullable<isize>) -> Nullable<isize>

Performs the / operation.

impl Div<Nullable<isize>> for NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the / operator.

fn div(self, other: Nullable<isize>) -> NullVec<isize>

Performs the / operation.

impl<'b> Div<Nullable<u16>> for &'b NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the / operator.

fn div(self, other: Nullable<u16>) -> NullVec<u16>

Performs the / operation.

impl<'b> Div<Nullable<u16>> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the / operator.

fn div(self, other: Nullable<u16>) -> Nullable<u16>

Performs the / operation.

impl Div<Nullable<u16>> for NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the / operator.

fn div(self, other: Nullable<u16>) -> NullVec<u16>

Performs the / operation.

impl<'b> Div<Nullable<u32>> for &'b NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the / operator.

fn div(self, other: Nullable<u32>) -> NullVec<u32>

Performs the / operation.

impl<'b> Div<Nullable<u32>> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the / operator.

fn div(self, other: Nullable<u32>) -> Nullable<u32>

Performs the / operation.

impl Div<Nullable<u32>> for NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the / operator.

fn div(self, other: Nullable<u32>) -> NullVec<u32>

Performs the / operation.

impl<'b> Div<Nullable<u64>> for &'b NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the / operator.

fn div(self, other: Nullable<u64>) -> NullVec<u64>

Performs the / operation.

impl<'b> Div<Nullable<u64>> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the / operator.

fn div(self, other: Nullable<u64>) -> Nullable<u64>

Performs the / operation.

impl Div<Nullable<u64>> for NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the / operator.

fn div(self, other: Nullable<u64>) -> NullVec<u64>

Performs the / operation.

impl<'b> Div<Nullable<u8>> for &'b NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the / operator.

fn div(self, other: Nullable<u8>) -> NullVec<u8>

Performs the / operation.

impl<'b> Div<Nullable<u8>> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the / operator.

fn div(self, other: Nullable<u8>) -> Nullable<u8>

Performs the / operation.

impl Div<Nullable<u8>> for NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the / operator.

fn div(self, other: Nullable<u8>) -> NullVec<u8>

Performs the / operation.

impl<'b> Div<Nullable<usize>> for &'b NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the / operator.

fn div(self, other: Nullable<usize>) -> NullVec<usize>

Performs the / operation.

impl<'b> Div<Nullable<usize>> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the / operator.

fn div(self, other: Nullable<usize>) -> Nullable<usize>

Performs the / operation.

impl Div<Nullable<usize>> for NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the / operator.

fn div(self, other: Nullable<usize>) -> NullVec<usize>

Performs the / operation.

impl<'b> Div<f32> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the / operator.

fn div(self, other: f32) -> Nullable<f32>

Performs the / operation.

impl Div<f32> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the / operator.

fn div(self, other: f32) -> Nullable<f32>

Performs the / operation.

impl<'b> Div<f64> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the / operator.

fn div(self, other: f64) -> Nullable<f64>

Performs the / operation.

impl Div<f64> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the / operator.

fn div(self, other: f64) -> Nullable<f64>

Performs the / operation.

impl<'b> Div<i16> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the / operator.

fn div(self, other: i16) -> Nullable<i16>

Performs the / operation.

impl Div<i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the / operator.

fn div(self, other: i16) -> Nullable<i16>

Performs the / operation.

impl<'b> Div<i32> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the / operator.

fn div(self, other: i32) -> Nullable<i32>

Performs the / operation.

impl Div<i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the / operator.

fn div(self, other: i32) -> Nullable<i32>

Performs the / operation.

impl<'b> Div<i64> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the / operator.

fn div(self, other: i64) -> Nullable<i64>

Performs the / operation.

impl Div<i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the / operator.

fn div(self, other: i64) -> Nullable<i64>

Performs the / operation.

impl<'b> Div<i8> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the / operator.

fn div(self, other: i8) -> Nullable<i8>

Performs the / operation.

impl Div<i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the / operator.

fn div(self, other: i8) -> Nullable<i8>

Performs the / operation.

impl<'b> Div<isize> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the / operator.

fn div(self, other: isize) -> Nullable<isize>

Performs the / operation.

impl Div<isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the / operator.

fn div(self, other: isize) -> Nullable<isize>

Performs the / operation.

impl<'b> Div<u16> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the / operator.

fn div(self, other: u16) -> Nullable<u16>

Performs the / operation.

impl Div<u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the / operator.

fn div(self, other: u16) -> Nullable<u16>

Performs the / operation.

impl<'b> Div<u32> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the / operator.

fn div(self, other: u32) -> Nullable<u32>

Performs the / operation.

impl Div<u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the / operator.

fn div(self, other: u32) -> Nullable<u32>

Performs the / operation.

impl<'b> Div<u64> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the / operator.

fn div(self, other: u64) -> Nullable<u64>

Performs the / operation.

impl Div<u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the / operator.

fn div(self, other: u64) -> Nullable<u64>

Performs the / operation.

impl<'b> Div<u8> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the / operator.

fn div(self, other: u8) -> Nullable<u8>

Performs the / operation.

impl Div<u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the / operator.

fn div(self, other: u8) -> Nullable<u8>

Performs the / operation.

impl<'b> Div<usize> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the / operator.

fn div(self, other: usize) -> Nullable<usize>

Performs the / operation.

impl Div<usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the / operator.

fn div(self, other: usize) -> Nullable<usize>

Performs the / operation.

impl Div for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the / operator.

fn div(self, other: Nullable<f32>) -> Nullable<f32>

Performs the / operation.

impl Div for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the / operator.

fn div(self, other: Nullable<f64>) -> Nullable<f64>

Performs the / operation.

impl Div for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the / operator.

fn div(self, other: Nullable<i16>) -> Nullable<i16>

Performs the / operation.

impl Div for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the / operator.

fn div(self, other: Nullable<i32>) -> Nullable<i32>

Performs the / operation.

impl Div for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the / operator.

fn div(self, other: Nullable<i64>) -> Nullable<i64>

Performs the / operation.

impl Div for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the / operator.

fn div(self, other: Nullable<i8>) -> Nullable<i8>

Performs the / operation.

impl Div for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the / operator.

fn div(self, other: Nullable<isize>) -> Nullable<isize>

Performs the / operation.

impl Div for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the / operator.

fn div(self, other: Nullable<u16>) -> Nullable<u16>

Performs the / operation.

impl Div for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the / operator.

fn div(self, other: Nullable<u32>) -> Nullable<u32>

Performs the / operation.

impl Div for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the / operator.

fn div(self, other: Nullable<u64>) -> Nullable<u64>

Performs the / operation.

impl Div for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the / operator.

fn div(self, other: Nullable<u8>) -> Nullable<u8>

Performs the / operation.

impl Div for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the / operator.

fn div(self, other: Nullable<usize>) -> Nullable<usize>

Performs the / operation.

impl From<Nullable<String>> for Scalar

fn from(value: Nullable<String>) -> Self

Converts to this type from the input type.

impl From<Nullable<String>> for String

fn from(value: Nullable<String>) -> String

Converts to this type from the input type.

impl From<Nullable<bool>> for Scalar

fn from(value: Nullable<bool>) -> Self

Converts to this type from the input type.

impl From<Nullable<bool>> for bool

fn from(value: Nullable<bool>) -> bool

Converts to this type from the input type.

impl From<Nullable<f32>> for Scalar

fn from(value: Nullable<f32>) -> Self

Converts to this type from the input type.

impl From<Nullable<f32>> for f32

fn from(value: Nullable<f32>) -> f32

Converts to this type from the input type.

impl From<Nullable<f64>> for Scalar

fn from(value: Nullable<f64>) -> Self

Converts to this type from the input type.

impl From<Nullable<f64>> for f64

fn from(value: Nullable<f64>) -> f64

Converts to this type from the input type.

impl From<Nullable<i16>> for Scalar

fn from(value: Nullable<i16>) -> Self

Converts to this type from the input type.

impl From<Nullable<i16>> for i16

fn from(value: Nullable<i16>) -> i16

Converts to this type from the input type.

impl From<Nullable<i32>> for Scalar

fn from(value: Nullable<i32>) -> Self

Converts to this type from the input type.

impl From<Nullable<i32>> for i32

fn from(value: Nullable<i32>) -> i32

Converts to this type from the input type.

impl From<Nullable<i64>> for Scalar

fn from(value: Nullable<i64>) -> Self

Converts to this type from the input type.

impl From<Nullable<i64>> for i64

fn from(value: Nullable<i64>) -> i64

Converts to this type from the input type.

impl From<Nullable<i8>> for Scalar

fn from(value: Nullable<i8>) -> Self

Converts to this type from the input type.

impl From<Nullable<i8>> for i8

fn from(value: Nullable<i8>) -> i8

Converts to this type from the input type.

impl From<Nullable<isize>> for Scalar

fn from(value: Nullable<isize>) -> Self

Converts to this type from the input type.

impl From<Nullable<isize>> for isize

fn from(value: Nullable<isize>) -> isize

Converts to this type from the input type.

impl From<Nullable<u16>> for Scalar

fn from(value: Nullable<u16>) -> Self

Converts to this type from the input type.

impl From<Nullable<u16>> for u16

fn from(value: Nullable<u16>) -> u16

Converts to this type from the input type.

impl From<Nullable<u32>> for Scalar

fn from(value: Nullable<u32>) -> Self

Converts to this type from the input type.

impl From<Nullable<u32>> for u32

fn from(value: Nullable<u32>) -> u32

Converts to this type from the input type.

impl From<Nullable<u64>> for Scalar

fn from(value: Nullable<u64>) -> Self

Converts to this type from the input type.

impl From<Nullable<u64>> for u64

fn from(value: Nullable<u64>) -> u64

Converts to this type from the input type.

impl From<Nullable<u8>> for Scalar

fn from(value: Nullable<u8>) -> Self

Converts to this type from the input type.

impl From<Nullable<u8>> for u8

fn from(value: Nullable<u8>) -> u8

Converts to this type from the input type.

impl From<Nullable<usize>> for Scalar

fn from(value: Nullable<usize>) -> Self

Converts to this type from the input type.

impl From<Nullable<usize>> for usize

fn from(value: Nullable<usize>) -> usize

Converts to this type from the input type.

impl From<Scalar> for Nullable<String>

fn from(value: Scalar) -> Self

Converts to this type from the input type.

impl From<Scalar> for Nullable<bool>

fn from(value: Scalar) -> Self

Converts to this type from the input type.

impl From<Scalar> for Nullable<f32>

fn from(value: Scalar) -> Self

Converts to this type from the input type.

impl From<Scalar> for Nullable<f64>

fn from(value: Scalar) -> Self

Converts to this type from the input type.

impl From<Scalar> for Nullable<i16>

fn from(value: Scalar) -> Self

Converts to this type from the input type.

impl From<Scalar> for Nullable<i32>

fn from(value: Scalar) -> Self

Converts to this type from the input type.

impl From<Scalar> for Nullable<i64>

fn from(value: Scalar) -> Self

Converts to this type from the input type.

impl From<Scalar> for Nullable<i8>

fn from(value: Scalar) -> Self

Converts to this type from the input type.

impl From<Scalar> for Nullable<isize>

fn from(value: Scalar) -> Self

Converts to this type from the input type.

impl From<Scalar> for Nullable<u16>

fn from(value: Scalar) -> Self

Converts to this type from the input type.

impl From<Scalar> for Nullable<u32>

fn from(value: Scalar) -> Self

Converts to this type from the input type.

impl From<Scalar> for Nullable<u64>

fn from(value: Scalar) -> Self

Converts to this type from the input type.

impl From<Scalar> for Nullable<u8>

fn from(value: Scalar) -> Self

Converts to this type from the input type.

impl From<Scalar> for Nullable<usize>

fn from(value: Scalar) -> Self

Converts to this type from the input type.

impl<T: NullStorable> From<T> for Nullable<T>

///////////////////////////////////////////////////////////////////////////// Basic conversion /////////////////////////////////////////////////////////////////////////////

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: NullStorable> FromIterator<Nullable<T>> for NullVec<T>

fn from_iter<I>(iter: I) -> Self

where I: IntoIterator<Item = Nullable<T>>,

Creates a value from an iterator.

impl<'a, 'b> Mul<&'a Nullable<f32>> for &'b NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<f32>) -> NullVec<f32>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<f32>> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<f32>) -> Nullable<f32>

Performs the * operation.

impl<'a> Mul<&'a Nullable<f32>> for NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<f32>) -> NullVec<f32>

Performs the * operation.

impl<'a> Mul<&'a Nullable<f32>> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<f32>) -> Nullable<f32>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<f64>> for &'b NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<f64>) -> NullVec<f64>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<f64>> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<f64>) -> Nullable<f64>

Performs the * operation.

impl<'a> Mul<&'a Nullable<f64>> for NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<f64>) -> NullVec<f64>

Performs the * operation.

impl<'a> Mul<&'a Nullable<f64>> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<f64>) -> Nullable<f64>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<i16>> for &'b NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<i16>) -> NullVec<i16>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<i16>> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<i16>) -> Nullable<i16>

Performs the * operation.

impl<'a> Mul<&'a Nullable<i16>> for NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<i16>) -> NullVec<i16>

Performs the * operation.

impl<'a> Mul<&'a Nullable<i16>> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<i16>) -> Nullable<i16>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<i32>> for &'b NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<i32>) -> NullVec<i32>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<i32>> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<i32>) -> Nullable<i32>

Performs the * operation.

impl<'a> Mul<&'a Nullable<i32>> for NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<i32>) -> NullVec<i32>

Performs the * operation.

impl<'a> Mul<&'a Nullable<i32>> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<i32>) -> Nullable<i32>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<i64>> for &'b NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<i64>) -> NullVec<i64>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<i64>> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<i64>) -> Nullable<i64>

Performs the * operation.

impl<'a> Mul<&'a Nullable<i64>> for NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<i64>) -> NullVec<i64>

Performs the * operation.

impl<'a> Mul<&'a Nullable<i64>> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<i64>) -> Nullable<i64>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<i8>> for &'b NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<i8>) -> NullVec<i8>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<i8>> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<i8>) -> Nullable<i8>

Performs the * operation.

impl<'a> Mul<&'a Nullable<i8>> for NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<i8>) -> NullVec<i8>

Performs the * operation.

impl<'a> Mul<&'a Nullable<i8>> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<i8>) -> Nullable<i8>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<isize>> for &'b NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<isize>) -> NullVec<isize>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<isize>> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<isize>) -> Nullable<isize>

Performs the * operation.

impl<'a> Mul<&'a Nullable<isize>> for NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<isize>) -> NullVec<isize>

Performs the * operation.

impl<'a> Mul<&'a Nullable<isize>> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<isize>) -> Nullable<isize>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<u16>> for &'b NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<u16>) -> NullVec<u16>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<u16>> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<u16>) -> Nullable<u16>

Performs the * operation.

impl<'a> Mul<&'a Nullable<u16>> for NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<u16>) -> NullVec<u16>

Performs the * operation.

impl<'a> Mul<&'a Nullable<u16>> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<u16>) -> Nullable<u16>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<u32>> for &'b NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<u32>) -> NullVec<u32>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<u32>> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<u32>) -> Nullable<u32>

Performs the * operation.

impl<'a> Mul<&'a Nullable<u32>> for NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<u32>) -> NullVec<u32>

Performs the * operation.

impl<'a> Mul<&'a Nullable<u32>> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<u32>) -> Nullable<u32>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<u64>> for &'b NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<u64>) -> NullVec<u64>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<u64>> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<u64>) -> Nullable<u64>

Performs the * operation.

impl<'a> Mul<&'a Nullable<u64>> for NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<u64>) -> NullVec<u64>

Performs the * operation.

impl<'a> Mul<&'a Nullable<u64>> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<u64>) -> Nullable<u64>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<u8>> for &'b NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<u8>) -> NullVec<u8>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<u8>> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<u8>) -> Nullable<u8>

Performs the * operation.

impl<'a> Mul<&'a Nullable<u8>> for NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<u8>) -> NullVec<u8>

Performs the * operation.

impl<'a> Mul<&'a Nullable<u8>> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<u8>) -> Nullable<u8>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<usize>> for &'b NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<usize>) -> NullVec<usize>

Performs the * operation.

impl<'a, 'b> Mul<&'a Nullable<usize>> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<usize>) -> Nullable<usize>

Performs the * operation.

impl<'a> Mul<&'a Nullable<usize>> for NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<usize>) -> NullVec<usize>

Performs the * operation.

impl<'a> Mul<&'a Nullable<usize>> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the * operator.

fn mul(self, other: &'a Nullable<usize>) -> Nullable<usize>

Performs the * operation.

impl<'a, 'b> Mul<&'a f32> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the * operator.

fn mul(self, other: &'a f32) -> Nullable<f32>

Performs the * operation.

impl<'a> Mul<&'a f32> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the * operator.

fn mul(self, other: &'a f32) -> Nullable<f32>

Performs the * operation.

impl<'a, 'b> Mul<&'a f64> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the * operator.

fn mul(self, other: &'a f64) -> Nullable<f64>

Performs the * operation.

impl<'a> Mul<&'a f64> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the * operator.

fn mul(self, other: &'a f64) -> Nullable<f64>

Performs the * operation.

impl<'a, 'b> Mul<&'a i16> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the * operator.

fn mul(self, other: &'a i16) -> Nullable<i16>

Performs the * operation.

impl<'a> Mul<&'a i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the * operator.

fn mul(self, other: &'a i16) -> Nullable<i16>

Performs the * operation.

impl<'a, 'b> Mul<&'a i32> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the * operator.

fn mul(self, other: &'a i32) -> Nullable<i32>

Performs the * operation.

impl<'a> Mul<&'a i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the * operator.

fn mul(self, other: &'a i32) -> Nullable<i32>

Performs the * operation.

impl<'a, 'b> Mul<&'a i64> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the * operator.

fn mul(self, other: &'a i64) -> Nullable<i64>

Performs the * operation.

impl<'a> Mul<&'a i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the * operator.

fn mul(self, other: &'a i64) -> Nullable<i64>

Performs the * operation.

impl<'a, 'b> Mul<&'a i8> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the * operator.

fn mul(self, other: &'a i8) -> Nullable<i8>

Performs the * operation.

impl<'a> Mul<&'a i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the * operator.

fn mul(self, other: &'a i8) -> Nullable<i8>

Performs the * operation.

impl<'a, 'b> Mul<&'a isize> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the * operator.

fn mul(self, other: &'a isize) -> Nullable<isize>

Performs the * operation.

impl<'a> Mul<&'a isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the * operator.

fn mul(self, other: &'a isize) -> Nullable<isize>

Performs the * operation.

impl<'a, 'b> Mul<&'a u16> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the * operator.

fn mul(self, other: &'a u16) -> Nullable<u16>

Performs the * operation.

impl<'a> Mul<&'a u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the * operator.

fn mul(self, other: &'a u16) -> Nullable<u16>

Performs the * operation.

impl<'a, 'b> Mul<&'a u32> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the * operator.

fn mul(self, other: &'a u32) -> Nullable<u32>

Performs the * operation.

impl<'a> Mul<&'a u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the * operator.

fn mul(self, other: &'a u32) -> Nullable<u32>

Performs the * operation.

impl<'a, 'b> Mul<&'a u64> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the * operator.

fn mul(self, other: &'a u64) -> Nullable<u64>

Performs the * operation.

impl<'a> Mul<&'a u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the * operator.

fn mul(self, other: &'a u64) -> Nullable<u64>

Performs the * operation.

impl<'a, 'b> Mul<&'a u8> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the * operator.

fn mul(self, other: &'a u8) -> Nullable<u8>

Performs the * operation.

impl<'a> Mul<&'a u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the * operator.

fn mul(self, other: &'a u8) -> Nullable<u8>

Performs the * operation.

impl<'a, 'b> Mul<&'a usize> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the * operator.

fn mul(self, other: &'a usize) -> Nullable<usize>

Performs the * operation.

impl<'a> Mul<&'a usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the * operator.

fn mul(self, other: &'a usize) -> Nullable<usize>

Performs the * operation.

impl<'b> Mul<Nullable<f32>> for &'b NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<f32>) -> NullVec<f32>

Performs the * operation.

impl<'b> Mul<Nullable<f32>> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<f32>) -> Nullable<f32>

Performs the * operation.

impl Mul<Nullable<f32>> for NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<f32>) -> NullVec<f32>

Performs the * operation.

impl<'b> Mul<Nullable<f64>> for &'b NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<f64>) -> NullVec<f64>

Performs the * operation.

impl<'b> Mul<Nullable<f64>> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<f64>) -> Nullable<f64>

Performs the * operation.

impl Mul<Nullable<f64>> for NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<f64>) -> NullVec<f64>

Performs the * operation.

impl<'b> Mul<Nullable<i16>> for &'b NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<i16>) -> NullVec<i16>

Performs the * operation.

impl<'b> Mul<Nullable<i16>> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<i16>) -> Nullable<i16>

Performs the * operation.

impl Mul<Nullable<i16>> for NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<i16>) -> NullVec<i16>

Performs the * operation.

impl<'b> Mul<Nullable<i32>> for &'b NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<i32>) -> NullVec<i32>

Performs the * operation.

impl<'b> Mul<Nullable<i32>> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<i32>) -> Nullable<i32>

Performs the * operation.

impl Mul<Nullable<i32>> for NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<i32>) -> NullVec<i32>

Performs the * operation.

impl<'b> Mul<Nullable<i64>> for &'b NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<i64>) -> NullVec<i64>

Performs the * operation.

impl<'b> Mul<Nullable<i64>> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<i64>) -> Nullable<i64>

Performs the * operation.

impl Mul<Nullable<i64>> for NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<i64>) -> NullVec<i64>

Performs the * operation.

impl<'b> Mul<Nullable<i8>> for &'b NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<i8>) -> NullVec<i8>

Performs the * operation.

impl<'b> Mul<Nullable<i8>> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<i8>) -> Nullable<i8>

Performs the * operation.

impl Mul<Nullable<i8>> for NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<i8>) -> NullVec<i8>

Performs the * operation.

impl<'b> Mul<Nullable<isize>> for &'b NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<isize>) -> NullVec<isize>

Performs the * operation.

impl<'b> Mul<Nullable<isize>> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<isize>) -> Nullable<isize>

Performs the * operation.

impl Mul<Nullable<isize>> for NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<isize>) -> NullVec<isize>

Performs the * operation.

impl<'b> Mul<Nullable<u16>> for &'b NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<u16>) -> NullVec<u16>

Performs the * operation.

impl<'b> Mul<Nullable<u16>> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<u16>) -> Nullable<u16>

Performs the * operation.

impl Mul<Nullable<u16>> for NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<u16>) -> NullVec<u16>

Performs the * operation.

impl<'b> Mul<Nullable<u32>> for &'b NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<u32>) -> NullVec<u32>

Performs the * operation.

impl<'b> Mul<Nullable<u32>> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<u32>) -> Nullable<u32>

Performs the * operation.

impl Mul<Nullable<u32>> for NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<u32>) -> NullVec<u32>

Performs the * operation.

impl<'b> Mul<Nullable<u64>> for &'b NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<u64>) -> NullVec<u64>

Performs the * operation.

impl<'b> Mul<Nullable<u64>> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<u64>) -> Nullable<u64>

Performs the * operation.

impl Mul<Nullable<u64>> for NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<u64>) -> NullVec<u64>

Performs the * operation.

impl<'b> Mul<Nullable<u8>> for &'b NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<u8>) -> NullVec<u8>

Performs the * operation.

impl<'b> Mul<Nullable<u8>> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<u8>) -> Nullable<u8>

Performs the * operation.

impl Mul<Nullable<u8>> for NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<u8>) -> NullVec<u8>

Performs the * operation.

impl<'b> Mul<Nullable<usize>> for &'b NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<usize>) -> NullVec<usize>

Performs the * operation.

impl<'b> Mul<Nullable<usize>> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<usize>) -> Nullable<usize>

Performs the * operation.

impl Mul<Nullable<usize>> for NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<usize>) -> NullVec<usize>

Performs the * operation.

impl<'b> Mul<f32> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the * operator.

fn mul(self, other: f32) -> Nullable<f32>

Performs the * operation.

impl Mul<f32> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the * operator.

fn mul(self, other: f32) -> Nullable<f32>

Performs the * operation.

impl<'b> Mul<f64> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the * operator.

fn mul(self, other: f64) -> Nullable<f64>

Performs the * operation.

impl Mul<f64> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the * operator.

fn mul(self, other: f64) -> Nullable<f64>

Performs the * operation.

impl<'b> Mul<i16> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the * operator.

fn mul(self, other: i16) -> Nullable<i16>

Performs the * operation.

impl Mul<i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the * operator.

fn mul(self, other: i16) -> Nullable<i16>

Performs the * operation.

impl<'b> Mul<i32> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the * operator.

fn mul(self, other: i32) -> Nullable<i32>

Performs the * operation.

impl Mul<i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the * operator.

fn mul(self, other: i32) -> Nullable<i32>

Performs the * operation.

impl<'b> Mul<i64> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the * operator.

fn mul(self, other: i64) -> Nullable<i64>

Performs the * operation.

impl Mul<i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the * operator.

fn mul(self, other: i64) -> Nullable<i64>

Performs the * operation.

impl<'b> Mul<i8> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the * operator.

fn mul(self, other: i8) -> Nullable<i8>

Performs the * operation.

impl Mul<i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the * operator.

fn mul(self, other: i8) -> Nullable<i8>

Performs the * operation.

impl<'b> Mul<isize> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the * operator.

fn mul(self, other: isize) -> Nullable<isize>

Performs the * operation.

impl Mul<isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the * operator.

fn mul(self, other: isize) -> Nullable<isize>

Performs the * operation.

impl<'b> Mul<u16> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the * operator.

fn mul(self, other: u16) -> Nullable<u16>

Performs the * operation.

impl Mul<u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the * operator.

fn mul(self, other: u16) -> Nullable<u16>

Performs the * operation.

impl<'b> Mul<u32> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the * operator.

fn mul(self, other: u32) -> Nullable<u32>

Performs the * operation.

impl Mul<u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the * operator.

fn mul(self, other: u32) -> Nullable<u32>

Performs the * operation.

impl<'b> Mul<u64> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the * operator.

fn mul(self, other: u64) -> Nullable<u64>

Performs the * operation.

impl Mul<u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the * operator.

fn mul(self, other: u64) -> Nullable<u64>

Performs the * operation.

impl<'b> Mul<u8> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the * operator.

fn mul(self, other: u8) -> Nullable<u8>

Performs the * operation.

impl Mul<u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the * operator.

fn mul(self, other: u8) -> Nullable<u8>

Performs the * operation.

impl<'b> Mul<usize> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the * operator.

fn mul(self, other: usize) -> Nullable<usize>

Performs the * operation.

impl Mul<usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the * operator.

fn mul(self, other: usize) -> Nullable<usize>

Performs the * operation.

impl Mul for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<f32>) -> Nullable<f32>

Performs the * operation.

impl Mul for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<f64>) -> Nullable<f64>

Performs the * operation.

impl Mul for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<i16>) -> Nullable<i16>

Performs the * operation.

impl Mul for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<i32>) -> Nullable<i32>

Performs the * operation.

impl Mul for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<i64>) -> Nullable<i64>

Performs the * operation.

impl Mul for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<i8>) -> Nullable<i8>

Performs the * operation.

impl Mul for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<isize>) -> Nullable<isize>

Performs the * operation.

impl Mul for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<u16>) -> Nullable<u16>

Performs the * operation.

impl Mul for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<u32>) -> Nullable<u32>

Performs the * operation.

impl Mul for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<u64>) -> Nullable<u64>

Performs the * operation.

impl Mul for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<u8>) -> Nullable<u8>

Performs the * operation.

impl Mul for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the * operator.

fn mul(self, other: Nullable<usize>) -> Nullable<usize>

Performs the * operation.

impl<T: PartialEq + NullStorable> PartialEq for Nullable<T>

fn eq(&self, other: &Nullable<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b> Rem<&'a Nullable<f32>> for &'b NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<f32>) -> NullVec<f32>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<f32>> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<f32>) -> Nullable<f32>

Performs the % operation.

impl<'a> Rem<&'a Nullable<f32>> for NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<f32>) -> NullVec<f32>

Performs the % operation.

impl<'a> Rem<&'a Nullable<f32>> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<f32>) -> Nullable<f32>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<f64>> for &'b NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<f64>) -> NullVec<f64>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<f64>> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<f64>) -> Nullable<f64>

Performs the % operation.

impl<'a> Rem<&'a Nullable<f64>> for NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<f64>) -> NullVec<f64>

Performs the % operation.

impl<'a> Rem<&'a Nullable<f64>> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<f64>) -> Nullable<f64>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<i16>> for &'b NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<i16>) -> NullVec<i16>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<i16>> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<i16>) -> Nullable<i16>

Performs the % operation.

impl<'a> Rem<&'a Nullable<i16>> for NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<i16>) -> NullVec<i16>

Performs the % operation.

impl<'a> Rem<&'a Nullable<i16>> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<i16>) -> Nullable<i16>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<i32>> for &'b NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<i32>) -> NullVec<i32>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<i32>> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<i32>) -> Nullable<i32>

Performs the % operation.

impl<'a> Rem<&'a Nullable<i32>> for NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<i32>) -> NullVec<i32>

Performs the % operation.

impl<'a> Rem<&'a Nullable<i32>> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<i32>) -> Nullable<i32>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<i64>> for &'b NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<i64>) -> NullVec<i64>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<i64>> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<i64>) -> Nullable<i64>

Performs the % operation.

impl<'a> Rem<&'a Nullable<i64>> for NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<i64>) -> NullVec<i64>

Performs the % operation.

impl<'a> Rem<&'a Nullable<i64>> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<i64>) -> Nullable<i64>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<i8>> for &'b NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<i8>) -> NullVec<i8>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<i8>> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<i8>) -> Nullable<i8>

Performs the % operation.

impl<'a> Rem<&'a Nullable<i8>> for NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<i8>) -> NullVec<i8>

Performs the % operation.

impl<'a> Rem<&'a Nullable<i8>> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<i8>) -> Nullable<i8>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<isize>> for &'b NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<isize>) -> NullVec<isize>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<isize>> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<isize>) -> Nullable<isize>

Performs the % operation.

impl<'a> Rem<&'a Nullable<isize>> for NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<isize>) -> NullVec<isize>

Performs the % operation.

impl<'a> Rem<&'a Nullable<isize>> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<isize>) -> Nullable<isize>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<u16>> for &'b NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<u16>) -> NullVec<u16>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<u16>> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<u16>) -> Nullable<u16>

Performs the % operation.

impl<'a> Rem<&'a Nullable<u16>> for NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<u16>) -> NullVec<u16>

Performs the % operation.

impl<'a> Rem<&'a Nullable<u16>> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<u16>) -> Nullable<u16>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<u32>> for &'b NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<u32>) -> NullVec<u32>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<u32>> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<u32>) -> Nullable<u32>

Performs the % operation.

impl<'a> Rem<&'a Nullable<u32>> for NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<u32>) -> NullVec<u32>

Performs the % operation.

impl<'a> Rem<&'a Nullable<u32>> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<u32>) -> Nullable<u32>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<u64>> for &'b NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<u64>) -> NullVec<u64>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<u64>> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<u64>) -> Nullable<u64>

Performs the % operation.

impl<'a> Rem<&'a Nullable<u64>> for NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<u64>) -> NullVec<u64>

Performs the % operation.

impl<'a> Rem<&'a Nullable<u64>> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<u64>) -> Nullable<u64>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<u8>> for &'b NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<u8>) -> NullVec<u8>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<u8>> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<u8>) -> Nullable<u8>

Performs the % operation.

impl<'a> Rem<&'a Nullable<u8>> for NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<u8>) -> NullVec<u8>

Performs the % operation.

impl<'a> Rem<&'a Nullable<u8>> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<u8>) -> Nullable<u8>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<usize>> for &'b NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<usize>) -> NullVec<usize>

Performs the % operation.

impl<'a, 'b> Rem<&'a Nullable<usize>> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<usize>) -> Nullable<usize>

Performs the % operation.

impl<'a> Rem<&'a Nullable<usize>> for NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<usize>) -> NullVec<usize>

Performs the % operation.

impl<'a> Rem<&'a Nullable<usize>> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the % operator.

fn rem(self, other: &'a Nullable<usize>) -> Nullable<usize>

Performs the % operation.

impl<'a, 'b> Rem<&'a f32> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the % operator.

fn rem(self, other: &'a f32) -> Nullable<f32>

Performs the % operation.

impl<'a> Rem<&'a f32> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the % operator.

fn rem(self, other: &'a f32) -> Nullable<f32>

Performs the % operation.

impl<'a, 'b> Rem<&'a f64> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the % operator.

fn rem(self, other: &'a f64) -> Nullable<f64>

Performs the % operation.

impl<'a> Rem<&'a f64> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the % operator.

fn rem(self, other: &'a f64) -> Nullable<f64>

Performs the % operation.

impl<'a, 'b> Rem<&'a i16> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the % operator.

fn rem(self, other: &'a i16) -> Nullable<i16>

Performs the % operation.

impl<'a> Rem<&'a i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the % operator.

fn rem(self, other: &'a i16) -> Nullable<i16>

Performs the % operation.

impl<'a, 'b> Rem<&'a i32> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the % operator.

fn rem(self, other: &'a i32) -> Nullable<i32>

Performs the % operation.

impl<'a> Rem<&'a i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the % operator.

fn rem(self, other: &'a i32) -> Nullable<i32>

Performs the % operation.

impl<'a, 'b> Rem<&'a i64> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the % operator.

fn rem(self, other: &'a i64) -> Nullable<i64>

Performs the % operation.

impl<'a> Rem<&'a i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the % operator.

fn rem(self, other: &'a i64) -> Nullable<i64>

Performs the % operation.

impl<'a, 'b> Rem<&'a i8> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the % operator.

fn rem(self, other: &'a i8) -> Nullable<i8>

Performs the % operation.

impl<'a> Rem<&'a i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the % operator.

fn rem(self, other: &'a i8) -> Nullable<i8>

Performs the % operation.

impl<'a, 'b> Rem<&'a isize> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the % operator.

fn rem(self, other: &'a isize) -> Nullable<isize>

Performs the % operation.

impl<'a> Rem<&'a isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the % operator.

fn rem(self, other: &'a isize) -> Nullable<isize>

Performs the % operation.

impl<'a, 'b> Rem<&'a u16> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the % operator.

fn rem(self, other: &'a u16) -> Nullable<u16>

Performs the % operation.

impl<'a> Rem<&'a u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the % operator.

fn rem(self, other: &'a u16) -> Nullable<u16>

Performs the % operation.

impl<'a, 'b> Rem<&'a u32> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the % operator.

fn rem(self, other: &'a u32) -> Nullable<u32>

Performs the % operation.

impl<'a> Rem<&'a u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the % operator.

fn rem(self, other: &'a u32) -> Nullable<u32>

Performs the % operation.

impl<'a, 'b> Rem<&'a u64> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the % operator.

fn rem(self, other: &'a u64) -> Nullable<u64>

Performs the % operation.

impl<'a> Rem<&'a u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the % operator.

fn rem(self, other: &'a u64) -> Nullable<u64>

Performs the % operation.

impl<'a, 'b> Rem<&'a u8> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the % operator.

fn rem(self, other: &'a u8) -> Nullable<u8>

Performs the % operation.

impl<'a> Rem<&'a u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the % operator.

fn rem(self, other: &'a u8) -> Nullable<u8>

Performs the % operation.

impl<'a, 'b> Rem<&'a usize> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the % operator.

fn rem(self, other: &'a usize) -> Nullable<usize>

Performs the % operation.

impl<'a> Rem<&'a usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the % operator.

fn rem(self, other: &'a usize) -> Nullable<usize>

Performs the % operation.

impl<'b> Rem<Nullable<f32>> for &'b NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<f32>) -> NullVec<f32>

Performs the % operation.

impl<'b> Rem<Nullable<f32>> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<f32>) -> Nullable<f32>

Performs the % operation.

impl Rem<Nullable<f32>> for NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<f32>) -> NullVec<f32>

Performs the % operation.

impl<'b> Rem<Nullable<f64>> for &'b NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<f64>) -> NullVec<f64>

Performs the % operation.

impl<'b> Rem<Nullable<f64>> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<f64>) -> Nullable<f64>

Performs the % operation.

impl Rem<Nullable<f64>> for NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<f64>) -> NullVec<f64>

Performs the % operation.

impl<'b> Rem<Nullable<i16>> for &'b NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<i16>) -> NullVec<i16>

Performs the % operation.

impl<'b> Rem<Nullable<i16>> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<i16>) -> Nullable<i16>

Performs the % operation.

impl Rem<Nullable<i16>> for NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<i16>) -> NullVec<i16>

Performs the % operation.

impl<'b> Rem<Nullable<i32>> for &'b NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<i32>) -> NullVec<i32>

Performs the % operation.

impl<'b> Rem<Nullable<i32>> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<i32>) -> Nullable<i32>

Performs the % operation.

impl Rem<Nullable<i32>> for NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<i32>) -> NullVec<i32>

Performs the % operation.

impl<'b> Rem<Nullable<i64>> for &'b NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<i64>) -> NullVec<i64>

Performs the % operation.

impl<'b> Rem<Nullable<i64>> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<i64>) -> Nullable<i64>

Performs the % operation.

impl Rem<Nullable<i64>> for NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<i64>) -> NullVec<i64>

Performs the % operation.

impl<'b> Rem<Nullable<i8>> for &'b NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<i8>) -> NullVec<i8>

Performs the % operation.

impl<'b> Rem<Nullable<i8>> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<i8>) -> Nullable<i8>

Performs the % operation.

impl Rem<Nullable<i8>> for NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<i8>) -> NullVec<i8>

Performs the % operation.

impl<'b> Rem<Nullable<isize>> for &'b NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<isize>) -> NullVec<isize>

Performs the % operation.

impl<'b> Rem<Nullable<isize>> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<isize>) -> Nullable<isize>

Performs the % operation.

impl Rem<Nullable<isize>> for NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<isize>) -> NullVec<isize>

Performs the % operation.

impl<'b> Rem<Nullable<u16>> for &'b NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<u16>) -> NullVec<u16>

Performs the % operation.

impl<'b> Rem<Nullable<u16>> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<u16>) -> Nullable<u16>

Performs the % operation.

impl Rem<Nullable<u16>> for NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<u16>) -> NullVec<u16>

Performs the % operation.

impl<'b> Rem<Nullable<u32>> for &'b NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<u32>) -> NullVec<u32>

Performs the % operation.

impl<'b> Rem<Nullable<u32>> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<u32>) -> Nullable<u32>

Performs the % operation.

impl Rem<Nullable<u32>> for NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<u32>) -> NullVec<u32>

Performs the % operation.

impl<'b> Rem<Nullable<u64>> for &'b NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<u64>) -> NullVec<u64>

Performs the % operation.

impl<'b> Rem<Nullable<u64>> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<u64>) -> Nullable<u64>

Performs the % operation.

impl Rem<Nullable<u64>> for NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<u64>) -> NullVec<u64>

Performs the % operation.

impl<'b> Rem<Nullable<u8>> for &'b NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<u8>) -> NullVec<u8>

Performs the % operation.

impl<'b> Rem<Nullable<u8>> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<u8>) -> Nullable<u8>

Performs the % operation.

impl Rem<Nullable<u8>> for NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<u8>) -> NullVec<u8>

Performs the % operation.

impl<'b> Rem<Nullable<usize>> for &'b NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<usize>) -> NullVec<usize>

Performs the % operation.

impl<'b> Rem<Nullable<usize>> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<usize>) -> Nullable<usize>

Performs the % operation.

impl Rem<Nullable<usize>> for NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<usize>) -> NullVec<usize>

Performs the % operation.

impl<'b> Rem<f32> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the % operator.

fn rem(self, other: f32) -> Nullable<f32>

Performs the % operation.

impl Rem<f32> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the % operator.

fn rem(self, other: f32) -> Nullable<f32>

Performs the % operation.

impl<'b> Rem<f64> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the % operator.

fn rem(self, other: f64) -> Nullable<f64>

Performs the % operation.

impl Rem<f64> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the % operator.

fn rem(self, other: f64) -> Nullable<f64>

Performs the % operation.

impl<'b> Rem<i16> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the % operator.

fn rem(self, other: i16) -> Nullable<i16>

Performs the % operation.

impl Rem<i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the % operator.

fn rem(self, other: i16) -> Nullable<i16>

Performs the % operation.

impl<'b> Rem<i32> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the % operator.

fn rem(self, other: i32) -> Nullable<i32>

Performs the % operation.

impl Rem<i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the % operator.

fn rem(self, other: i32) -> Nullable<i32>

Performs the % operation.

impl<'b> Rem<i64> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the % operator.

fn rem(self, other: i64) -> Nullable<i64>

Performs the % operation.

impl Rem<i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the % operator.

fn rem(self, other: i64) -> Nullable<i64>

Performs the % operation.

impl<'b> Rem<i8> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the % operator.

fn rem(self, other: i8) -> Nullable<i8>

Performs the % operation.

impl Rem<i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the % operator.

fn rem(self, other: i8) -> Nullable<i8>

Performs the % operation.

impl<'b> Rem<isize> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the % operator.

fn rem(self, other: isize) -> Nullable<isize>

Performs the % operation.

impl Rem<isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the % operator.

fn rem(self, other: isize) -> Nullable<isize>

Performs the % operation.

impl<'b> Rem<u16> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the % operator.

fn rem(self, other: u16) -> Nullable<u16>

Performs the % operation.

impl Rem<u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the % operator.

fn rem(self, other: u16) -> Nullable<u16>

Performs the % operation.

impl<'b> Rem<u32> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the % operator.

fn rem(self, other: u32) -> Nullable<u32>

Performs the % operation.

impl Rem<u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the % operator.

fn rem(self, other: u32) -> Nullable<u32>

Performs the % operation.

impl<'b> Rem<u64> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the % operator.

fn rem(self, other: u64) -> Nullable<u64>

Performs the % operation.

impl Rem<u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the % operator.

fn rem(self, other: u64) -> Nullable<u64>

Performs the % operation.

impl<'b> Rem<u8> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the % operator.

fn rem(self, other: u8) -> Nullable<u8>

Performs the % operation.

impl Rem<u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the % operator.

fn rem(self, other: u8) -> Nullable<u8>

Performs the % operation.

impl<'b> Rem<usize> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the % operator.

fn rem(self, other: usize) -> Nullable<usize>

Performs the % operation.

impl Rem<usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the % operator.

fn rem(self, other: usize) -> Nullable<usize>

Performs the % operation.

impl Rem for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<f32>) -> Nullable<f32>

Performs the % operation.

impl Rem for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<f64>) -> Nullable<f64>

Performs the % operation.

impl Rem for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<i16>) -> Nullable<i16>

Performs the % operation.

impl Rem for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<i32>) -> Nullable<i32>

Performs the % operation.

impl Rem for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<i64>) -> Nullable<i64>

Performs the % operation.

impl Rem for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<i8>) -> Nullable<i8>

Performs the % operation.

impl Rem for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<isize>) -> Nullable<isize>

Performs the % operation.

impl Rem for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<u16>) -> Nullable<u16>

Performs the % operation.

impl Rem for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<u32>) -> Nullable<u32>

Performs the % operation.

impl Rem for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<u64>) -> Nullable<u64>

Performs the % operation.

impl Rem for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<u8>) -> Nullable<u8>

Performs the % operation.

impl Rem for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the % operator.

fn rem(self, other: Nullable<usize>) -> Nullable<usize>

Performs the % operation.

impl<'a, 'b> Sub<&'a Nullable<f32>> for &'b NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<f32>) -> NullVec<f32>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<f32>> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<f32>) -> Nullable<f32>

Performs the - operation.

impl<'a> Sub<&'a Nullable<f32>> for NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<f32>) -> NullVec<f32>

Performs the - operation.

impl<'a> Sub<&'a Nullable<f32>> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<f32>) -> Nullable<f32>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<f64>> for &'b NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<f64>) -> NullVec<f64>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<f64>> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<f64>) -> Nullable<f64>

Performs the - operation.

impl<'a> Sub<&'a Nullable<f64>> for NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<f64>) -> NullVec<f64>

Performs the - operation.

impl<'a> Sub<&'a Nullable<f64>> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<f64>) -> Nullable<f64>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<i16>> for &'b NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<i16>) -> NullVec<i16>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<i16>> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<i16>) -> Nullable<i16>

Performs the - operation.

impl<'a> Sub<&'a Nullable<i16>> for NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<i16>) -> NullVec<i16>

Performs the - operation.

impl<'a> Sub<&'a Nullable<i16>> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<i16>) -> Nullable<i16>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<i32>> for &'b NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<i32>) -> NullVec<i32>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<i32>> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<i32>) -> Nullable<i32>

Performs the - operation.

impl<'a> Sub<&'a Nullable<i32>> for NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<i32>) -> NullVec<i32>

Performs the - operation.

impl<'a> Sub<&'a Nullable<i32>> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<i32>) -> Nullable<i32>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<i64>> for &'b NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<i64>) -> NullVec<i64>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<i64>> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<i64>) -> Nullable<i64>

Performs the - operation.

impl<'a> Sub<&'a Nullable<i64>> for NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<i64>) -> NullVec<i64>

Performs the - operation.

impl<'a> Sub<&'a Nullable<i64>> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<i64>) -> Nullable<i64>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<i8>> for &'b NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<i8>) -> NullVec<i8>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<i8>> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<i8>) -> Nullable<i8>

Performs the - operation.

impl<'a> Sub<&'a Nullable<i8>> for NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<i8>) -> NullVec<i8>

Performs the - operation.

impl<'a> Sub<&'a Nullable<i8>> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<i8>) -> Nullable<i8>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<isize>> for &'b NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<isize>) -> NullVec<isize>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<isize>> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<isize>) -> Nullable<isize>

Performs the - operation.

impl<'a> Sub<&'a Nullable<isize>> for NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<isize>) -> NullVec<isize>

Performs the - operation.

impl<'a> Sub<&'a Nullable<isize>> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<isize>) -> Nullable<isize>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<u16>> for &'b NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<u16>) -> NullVec<u16>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<u16>> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<u16>) -> Nullable<u16>

Performs the - operation.

impl<'a> Sub<&'a Nullable<u16>> for NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<u16>) -> NullVec<u16>

Performs the - operation.

impl<'a> Sub<&'a Nullable<u16>> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<u16>) -> Nullable<u16>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<u32>> for &'b NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<u32>) -> NullVec<u32>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<u32>> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<u32>) -> Nullable<u32>

Performs the - operation.

impl<'a> Sub<&'a Nullable<u32>> for NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<u32>) -> NullVec<u32>

Performs the - operation.

impl<'a> Sub<&'a Nullable<u32>> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<u32>) -> Nullable<u32>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<u64>> for &'b NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<u64>) -> NullVec<u64>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<u64>> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<u64>) -> Nullable<u64>

Performs the - operation.

impl<'a> Sub<&'a Nullable<u64>> for NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<u64>) -> NullVec<u64>

Performs the - operation.

impl<'a> Sub<&'a Nullable<u64>> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<u64>) -> Nullable<u64>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<u8>> for &'b NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<u8>) -> NullVec<u8>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<u8>> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<u8>) -> Nullable<u8>

Performs the - operation.

impl<'a> Sub<&'a Nullable<u8>> for NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<u8>) -> NullVec<u8>

Performs the - operation.

impl<'a> Sub<&'a Nullable<u8>> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<u8>) -> Nullable<u8>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<usize>> for &'b NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<usize>) -> NullVec<usize>

Performs the - operation.

impl<'a, 'b> Sub<&'a Nullable<usize>> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<usize>) -> Nullable<usize>

Performs the - operation.

impl<'a> Sub<&'a Nullable<usize>> for NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<usize>) -> NullVec<usize>

Performs the - operation.

impl<'a> Sub<&'a Nullable<usize>> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the - operator.

fn sub(self, other: &'a Nullable<usize>) -> Nullable<usize>

Performs the - operation.

impl<'a, 'b> Sub<&'a f32> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the - operator.

fn sub(self, other: &'a f32) -> Nullable<f32>

Performs the - operation.

impl<'a> Sub<&'a f32> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the - operator.

fn sub(self, other: &'a f32) -> Nullable<f32>

Performs the - operation.

impl<'a, 'b> Sub<&'a f64> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the - operator.

fn sub(self, other: &'a f64) -> Nullable<f64>

Performs the - operation.

impl<'a> Sub<&'a f64> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the - operator.

fn sub(self, other: &'a f64) -> Nullable<f64>

Performs the - operation.

impl<'a, 'b> Sub<&'a i16> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the - operator.

fn sub(self, other: &'a i16) -> Nullable<i16>

Performs the - operation.

impl<'a> Sub<&'a i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the - operator.

fn sub(self, other: &'a i16) -> Nullable<i16>

Performs the - operation.

impl<'a, 'b> Sub<&'a i32> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the - operator.

fn sub(self, other: &'a i32) -> Nullable<i32>

Performs the - operation.

impl<'a> Sub<&'a i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the - operator.

fn sub(self, other: &'a i32) -> Nullable<i32>

Performs the - operation.

impl<'a, 'b> Sub<&'a i64> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the - operator.

fn sub(self, other: &'a i64) -> Nullable<i64>

Performs the - operation.

impl<'a> Sub<&'a i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the - operator.

fn sub(self, other: &'a i64) -> Nullable<i64>

Performs the - operation.

impl<'a, 'b> Sub<&'a i8> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the - operator.

fn sub(self, other: &'a i8) -> Nullable<i8>

Performs the - operation.

impl<'a> Sub<&'a i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the - operator.

fn sub(self, other: &'a i8) -> Nullable<i8>

Performs the - operation.

impl<'a, 'b> Sub<&'a isize> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the - operator.

fn sub(self, other: &'a isize) -> Nullable<isize>

Performs the - operation.

impl<'a> Sub<&'a isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the - operator.

fn sub(self, other: &'a isize) -> Nullable<isize>

Performs the - operation.

impl<'a, 'b> Sub<&'a u16> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the - operator.

fn sub(self, other: &'a u16) -> Nullable<u16>

Performs the - operation.

impl<'a> Sub<&'a u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the - operator.

fn sub(self, other: &'a u16) -> Nullable<u16>

Performs the - operation.

impl<'a, 'b> Sub<&'a u32> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the - operator.

fn sub(self, other: &'a u32) -> Nullable<u32>

Performs the - operation.

impl<'a> Sub<&'a u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the - operator.

fn sub(self, other: &'a u32) -> Nullable<u32>

Performs the - operation.

impl<'a, 'b> Sub<&'a u64> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the - operator.

fn sub(self, other: &'a u64) -> Nullable<u64>

Performs the - operation.

impl<'a> Sub<&'a u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the - operator.

fn sub(self, other: &'a u64) -> Nullable<u64>

Performs the - operation.

impl<'a, 'b> Sub<&'a u8> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the - operator.

fn sub(self, other: &'a u8) -> Nullable<u8>

Performs the - operation.

impl<'a> Sub<&'a u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the - operator.

fn sub(self, other: &'a u8) -> Nullable<u8>

Performs the - operation.

impl<'a, 'b> Sub<&'a usize> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the - operator.

fn sub(self, other: &'a usize) -> Nullable<usize>

Performs the - operation.

impl<'a> Sub<&'a usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the - operator.

fn sub(self, other: &'a usize) -> Nullable<usize>

Performs the - operation.

impl<'b> Sub<Nullable<f32>> for &'b NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<f32>) -> NullVec<f32>

Performs the - operation.

impl<'b> Sub<Nullable<f32>> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<f32>) -> Nullable<f32>

Performs the - operation.

impl Sub<Nullable<f32>> for NullVec<f32>

type Output = NullVec<f32>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<f32>) -> NullVec<f32>

Performs the - operation.

impl<'b> Sub<Nullable<f64>> for &'b NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<f64>) -> NullVec<f64>

Performs the - operation.

impl<'b> Sub<Nullable<f64>> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<f64>) -> Nullable<f64>

Performs the - operation.

impl Sub<Nullable<f64>> for NullVec<f64>

type Output = NullVec<f64>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<f64>) -> NullVec<f64>

Performs the - operation.

impl<'b> Sub<Nullable<i16>> for &'b NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<i16>) -> NullVec<i16>

Performs the - operation.

impl<'b> Sub<Nullable<i16>> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<i16>) -> Nullable<i16>

Performs the - operation.

impl Sub<Nullable<i16>> for NullVec<i16>

type Output = NullVec<i16>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<i16>) -> NullVec<i16>

Performs the - operation.

impl<'b> Sub<Nullable<i32>> for &'b NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<i32>) -> NullVec<i32>

Performs the - operation.

impl<'b> Sub<Nullable<i32>> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<i32>) -> Nullable<i32>

Performs the - operation.

impl Sub<Nullable<i32>> for NullVec<i32>

type Output = NullVec<i32>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<i32>) -> NullVec<i32>

Performs the - operation.

impl<'b> Sub<Nullable<i64>> for &'b NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<i64>) -> NullVec<i64>

Performs the - operation.

impl<'b> Sub<Nullable<i64>> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<i64>) -> Nullable<i64>

Performs the - operation.

impl Sub<Nullable<i64>> for NullVec<i64>

type Output = NullVec<i64>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<i64>) -> NullVec<i64>

Performs the - operation.

impl<'b> Sub<Nullable<i8>> for &'b NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<i8>) -> NullVec<i8>

Performs the - operation.

impl<'b> Sub<Nullable<i8>> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<i8>) -> Nullable<i8>

Performs the - operation.

impl Sub<Nullable<i8>> for NullVec<i8>

type Output = NullVec<i8>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<i8>) -> NullVec<i8>

Performs the - operation.

impl<'b> Sub<Nullable<isize>> for &'b NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<isize>) -> NullVec<isize>

Performs the - operation.

impl<'b> Sub<Nullable<isize>> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<isize>) -> Nullable<isize>

Performs the - operation.

impl Sub<Nullable<isize>> for NullVec<isize>

type Output = NullVec<isize>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<isize>) -> NullVec<isize>

Performs the - operation.

impl<'b> Sub<Nullable<u16>> for &'b NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<u16>) -> NullVec<u16>

Performs the - operation.

impl<'b> Sub<Nullable<u16>> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<u16>) -> Nullable<u16>

Performs the - operation.

impl Sub<Nullable<u16>> for NullVec<u16>

type Output = NullVec<u16>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<u16>) -> NullVec<u16>

Performs the - operation.

impl<'b> Sub<Nullable<u32>> for &'b NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<u32>) -> NullVec<u32>

Performs the - operation.

impl<'b> Sub<Nullable<u32>> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<u32>) -> Nullable<u32>

Performs the - operation.

impl Sub<Nullable<u32>> for NullVec<u32>

type Output = NullVec<u32>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<u32>) -> NullVec<u32>

Performs the - operation.

impl<'b> Sub<Nullable<u64>> for &'b NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<u64>) -> NullVec<u64>

Performs the - operation.

impl<'b> Sub<Nullable<u64>> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<u64>) -> Nullable<u64>

Performs the - operation.

impl Sub<Nullable<u64>> for NullVec<u64>

type Output = NullVec<u64>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<u64>) -> NullVec<u64>

Performs the - operation.

impl<'b> Sub<Nullable<u8>> for &'b NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<u8>) -> NullVec<u8>

Performs the - operation.

impl<'b> Sub<Nullable<u8>> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<u8>) -> Nullable<u8>

Performs the - operation.

impl Sub<Nullable<u8>> for NullVec<u8>

type Output = NullVec<u8>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<u8>) -> NullVec<u8>

Performs the - operation.

impl<'b> Sub<Nullable<usize>> for &'b NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<usize>) -> NullVec<usize>

Performs the - operation.

impl<'b> Sub<Nullable<usize>> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<usize>) -> Nullable<usize>

Performs the - operation.

impl Sub<Nullable<usize>> for NullVec<usize>

type Output = NullVec<usize>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<usize>) -> NullVec<usize>

Performs the - operation.

impl<'b> Sub<f32> for &'b Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the - operator.

fn sub(self, other: f32) -> Nullable<f32>

Performs the - operation.

impl Sub<f32> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the - operator.

fn sub(self, other: f32) -> Nullable<f32>

Performs the - operation.

impl<'b> Sub<f64> for &'b Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the - operator.

fn sub(self, other: f64) -> Nullable<f64>

Performs the - operation.

impl Sub<f64> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the - operator.

fn sub(self, other: f64) -> Nullable<f64>

Performs the - operation.

impl<'b> Sub<i16> for &'b Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the - operator.

fn sub(self, other: i16) -> Nullable<i16>

Performs the - operation.

impl Sub<i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the - operator.

fn sub(self, other: i16) -> Nullable<i16>

Performs the - operation.

impl<'b> Sub<i32> for &'b Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the - operator.

fn sub(self, other: i32) -> Nullable<i32>

Performs the - operation.

impl Sub<i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the - operator.

fn sub(self, other: i32) -> Nullable<i32>

Performs the - operation.

impl<'b> Sub<i64> for &'b Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the - operator.

fn sub(self, other: i64) -> Nullable<i64>

Performs the - operation.

impl Sub<i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the - operator.

fn sub(self, other: i64) -> Nullable<i64>

Performs the - operation.

impl<'b> Sub<i8> for &'b Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the - operator.

fn sub(self, other: i8) -> Nullable<i8>

Performs the - operation.

impl Sub<i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the - operator.

fn sub(self, other: i8) -> Nullable<i8>

Performs the - operation.

impl<'b> Sub<isize> for &'b Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the - operator.

fn sub(self, other: isize) -> Nullable<isize>

Performs the - operation.

impl Sub<isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the - operator.

fn sub(self, other: isize) -> Nullable<isize>

Performs the - operation.

impl<'b> Sub<u16> for &'b Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the - operator.

fn sub(self, other: u16) -> Nullable<u16>

Performs the - operation.

impl Sub<u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the - operator.

fn sub(self, other: u16) -> Nullable<u16>

Performs the - operation.

impl<'b> Sub<u32> for &'b Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the - operator.

fn sub(self, other: u32) -> Nullable<u32>

Performs the - operation.

impl Sub<u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the - operator.

fn sub(self, other: u32) -> Nullable<u32>

Performs the - operation.

impl<'b> Sub<u64> for &'b Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the - operator.

fn sub(self, other: u64) -> Nullable<u64>

Performs the - operation.

impl Sub<u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the - operator.

fn sub(self, other: u64) -> Nullable<u64>

Performs the - operation.

impl<'b> Sub<u8> for &'b Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the - operator.

fn sub(self, other: u8) -> Nullable<u8>

Performs the - operation.

impl Sub<u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the - operator.

fn sub(self, other: u8) -> Nullable<u8>

Performs the - operation.

impl<'b> Sub<usize> for &'b Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the - operator.

fn sub(self, other: usize) -> Nullable<usize>

Performs the - operation.

impl Sub<usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the - operator.

fn sub(self, other: usize) -> Nullable<usize>

Performs the - operation.

impl Sub for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<f32>) -> Nullable<f32>

Performs the - operation.

impl Sub for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<f64>) -> Nullable<f64>

Performs the - operation.

impl Sub for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<i16>) -> Nullable<i16>

Performs the - operation.

impl Sub for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<i32>) -> Nullable<i32>

Performs the - operation.

impl Sub for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<i64>) -> Nullable<i64>

Performs the - operation.

impl Sub for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<i8>) -> Nullable<i8>

Performs the - operation.

impl Sub for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<isize>) -> Nullable<isize>

Performs the - operation.

impl Sub for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<u16>) -> Nullable<u16>

Performs the - operation.

impl Sub for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<u32>) -> Nullable<u32>

Performs the - operation.

impl Sub for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<u64>) -> Nullable<u64>

Performs the - operation.

impl Sub for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<u8>) -> Nullable<u8>

Performs the - operation.

impl Sub for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the - operator.

fn sub(self, other: Nullable<usize>) -> Nullable<usize>

Performs the - operation.

impl<T> Eq for Nullable<T>

where T: Eq + NullStorable,

impl<T: NullStorable> StructuralPartialEq for Nullable<T>