Enum brassfibre::prelude::Nullable

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

Nullable Scalar

Variants

Value(T)

Value which is not Null

Null

Null

Methods

impl<T> Nullable<T> where
    T: NullStorable, 

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

fn new(value: T) -> Nullable<T>

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<T> Clone for Nullable<T> where
    T: NullStorable + Clone, 

fn clone(&self) -> Nullable<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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>

The method for the - operator

impl Sub<Nullable<u16>> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the - operator

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

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

impl Sub<Nullable<u32>> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the - operator

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

The method for the - operator

impl Sub<u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the - operator

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

The method for the - operator

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>

The method for the - operator

impl Sub<Nullable<f32>> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the - operator

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

The method for the - operator

impl Sub<f64> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the - operator

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

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

impl Sub<Nullable<i64>> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the - operator

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

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

impl Sub<i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the - operator

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

The method for the - operator

impl Sub<u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the - operator

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

The method for the - operator

impl Sub<Nullable<i32>> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the - operator

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

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

impl Sub<i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the - operator

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

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

impl Sub<Nullable<i16>> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the - operator

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

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

impl Sub<u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the - operator

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

The method for the - operator

impl Sub<isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the - operator

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

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

impl Sub<Nullable<u8>> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the - operator

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

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

impl Sub<i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the - operator

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

The method for the - operator

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>

The method for the - operator

impl Sub<Nullable<f64>> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the - operator

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

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

impl Sub<u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the - operator

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

The method for the - operator

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>

The method for the - operator

impl Sub<Nullable<isize>> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the - operator

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

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

impl Sub<usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the - operator

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

The method for the - operator

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>

The method for the - operator

impl Sub<Nullable<u64>> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the - operator

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

The method for the - operator

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>

The method for the - operator

impl Sub<i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the - operator

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

The method for the - operator

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>

The method for the - operator

impl Sub<Nullable<usize>> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the - operator

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

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

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>

The method for the - operator

impl Sub<f32> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the - operator

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

The method for the - operator

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>

The method for the - operator

impl Sub<Nullable<i8>> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the - operator

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

The method for the - operator

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>

The method for the - operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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

type Output = Nullable<u32>

The resulting type after applying the | operator

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

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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

type Output = Nullable<i8>

The resulting type after applying the | operator

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

The method for the | operator

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>

The method for the | operator

impl BitOr<u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the | operator

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

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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

type Output = Nullable<i64>

The resulting type after applying the | operator

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

The method for the | operator

impl BitOr<bool> for Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the | operator

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

The method for the | operator

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>

The method for the | operator

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

type Output = Nullable<u16>

The resulting type after applying the | operator

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

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

impl BitOr<u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the | operator

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

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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

type Output = Nullable<u8>

The resulting type after applying the | operator

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

The method for the | operator

impl BitOr<i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the | operator

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

The method for the | operator

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>

The method for the | operator

impl BitOr<i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the | operator

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

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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

type Output = Nullable<isize>

The resulting type after applying the | operator

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

The method for the | operator

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>

The method for the | operator

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

type Output = Nullable<bool>

The resulting type after applying the | operator

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

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

impl BitOr<u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the | operator

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

The method for the | operator

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>

The method for the | operator

impl BitOr<u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the | operator

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

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

impl BitOr<isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the | operator

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

The method for the | operator

impl BitOr<i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the | operator

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

The method for the | operator

impl BitOr<usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the | operator

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

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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

type Output = Nullable<usize>

The resulting type after applying the | operator

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

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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

type Output = Nullable<u64>

The resulting type after applying the | operator

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

The method for the | operator

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>

The method for the | operator

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

type Output = Nullable<i16>

The resulting type after applying the | operator

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

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

impl BitOr<i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the | operator

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

The method for the | operator

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>

The method for the | operator

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>

The method for the | operator

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

type Output = Nullable<i32>

The resulting type after applying the | operator

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

The method for the | operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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

type Output = Nullable<i32>

The resulting type after applying the + operator

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

The method for the + operator

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>

The method for the + operator

impl Add<f32> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the + operator

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

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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

type Output = Nullable<i16>

The resulting type after applying the + operator

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

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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

type Output = Nullable<usize>

The resulting type after applying the + operator

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

The method for the + operator

impl Add<usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the + operator

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

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

impl Add<u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the + operator

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

The method for the + operator

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

type Output = Nullable<f64>

The resulting type after applying the + operator

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

The method for the + operator

impl Add<i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the + operator

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

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

impl Add<i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the + operator

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

The method for the + operator

impl Add<isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the + operator

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

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

impl Add<u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the + operator

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

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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

type Output = Nullable<isize>

The resulting type after applying the + operator

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

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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

type Output = Nullable<f32>

The resulting type after applying the + operator

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

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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

type Output = Nullable<u16>

The resulting type after applying the + operator

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

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

impl Add<u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the + operator

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

The method for the + operator

impl Add<u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the + operator

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

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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

type Output = Nullable<u8>

The resulting type after applying the + operator

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

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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

type Output = Nullable<u32>

The resulting type after applying the + operator

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

The method for the + operator

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>

The method for the + operator

impl Add<i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the + operator

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

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

impl Add<f64> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the + operator

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

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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

type Output = Nullable<i8>

The resulting type after applying the + operator

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

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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

type Output = Nullable<i64>

The resulting type after applying the + operator

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

The method for the + operator

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

type Output = Nullable<u64>

The resulting type after applying the + operator

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

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

impl Add<i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the + operator

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

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the + operator

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>

The method for the & operator

impl BitAnd<i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the & operator

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

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

impl BitAnd<u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the & operator

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

The method for the & operator

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>

The method for the & operator

impl BitAnd<i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the & operator

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

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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

type Output = Nullable<usize>

The resulting type after applying the & operator

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

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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

type Output = Nullable<bool>

The resulting type after applying the & operator

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

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

impl BitAnd<u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the & operator

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

The method for the & operator

impl BitAnd<isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the & operator

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

The method for the & operator

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

type Output = Nullable<u8>

The resulting type after applying the & operator

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

The method for the & operator

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>

The method for the & operator

impl BitAnd<i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the & operator

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

The method for the & operator

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

type Output = Nullable<i16>

The resulting type after applying the & operator

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

The method for the & operator

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>

The method for the & operator

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

type Output = Nullable<i64>

The resulting type after applying the & operator

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

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

impl BitAnd<usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the & operator

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

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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

type Output = Nullable<i32>

The resulting type after applying the & operator

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

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

impl BitAnd<u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the & operator

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

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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

type Output = Nullable<isize>

The resulting type after applying the & operator

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

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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

type Output = Nullable<u32>

The resulting type after applying the & operator

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

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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

type Output = Nullable<i8>

The resulting type after applying the & operator

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

The method for the & operator

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

type Output = Nullable<u16>

The resulting type after applying the & operator

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

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

impl BitAnd<bool> for Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the & operator

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

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

impl BitAnd<u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the & operator

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

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

impl BitAnd<i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the & operator

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

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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>

The method for the & operator

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

type Output = Nullable<u64>

The resulting type after applying the & operator

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

The method for the & operator

impl From<Scalar> for Nullable<u32>

fn from(value: Scalar) -> Nullable<u32>

Performs the conversion.

impl From<Scalar> for Nullable<f32>

fn from(value: Scalar) -> Nullable<f32>

Performs the conversion.

impl From<Scalar> for Nullable<u8>

fn from(value: Scalar) -> Nullable<u8>

Performs the conversion.

impl From<Scalar> for Nullable<i64>

fn from(value: Scalar) -> Nullable<i64>

Performs the conversion.

impl From<Scalar> for Nullable<u16>

fn from(value: Scalar) -> Nullable<u16>

Performs the conversion.

impl From<Scalar> for Nullable<usize>

fn from(value: Scalar) -> Nullable<usize>

Performs the conversion.

impl From<Scalar> for Nullable<i8>

fn from(value: Scalar) -> Nullable<i8>

Performs the conversion.

impl From<Scalar> for Nullable<i16>

fn from(value: Scalar) -> Nullable<i16>

Performs the conversion.

impl From<Scalar> for Nullable<String>

fn from(value: Scalar) -> Nullable<String>

Performs the conversion.

impl From<Scalar> for Nullable<f64>

fn from(value: Scalar) -> Nullable<f64>

Performs the conversion.

impl From<Scalar> for Nullable<i32>

fn from(value: Scalar) -> Nullable<i32>

Performs the conversion.

impl From<Scalar> for Nullable<isize>

fn from(value: Scalar) -> Nullable<isize>

Performs the conversion.

impl From<Scalar> for Nullable<bool>

fn from(value: Scalar) -> Nullable<bool>

Performs the conversion.

impl From<Scalar> for Nullable<u64>

fn from(value: Scalar) -> Nullable<u64>

Performs the conversion.

impl<T> From<T> for Nullable<T> where
    T: NullStorable, 

///////////////////////////////////////////////////////////////////////////// Basic conversion /////////////////////////////////////////////////////////////////////////////

fn from(value: T) -> Nullable<T>

Performs the conversion.

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>

The method for the / operator

impl Div<Nullable<f32>> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the / operator

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

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

impl Div<f32> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the / operator

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

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

impl Div<u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the / operator

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

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

impl Div<Nullable<i64>> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the / operator

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

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

impl Div<Nullable<usize>> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the / operator

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

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

impl Div<Nullable<i32>> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the / operator

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

The method for the / operator

impl Div<u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the / operator

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

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

impl Div<u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the / operator

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

The method for the / operator

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>

The method for the / operator

impl Div<Nullable<f64>> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the / operator

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

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

impl Div<isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the / operator

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

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

impl Div<Nullable<isize>> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the / operator

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

The method for the / operator

impl Div<Nullable<u8>> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the / operator

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

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

impl Div<Nullable<u32>> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the / operator

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

The method for the / operator

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>

The method for the / operator

impl Div<usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the / operator

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

The method for the / operator

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>

The method for the / operator

impl Div<Nullable<u16>> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the / operator

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

The method for the / operator

impl Div<i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the / operator

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

The method for the / operator

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>

The method for the / operator

impl Div<u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the / operator

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

The method for the / operator

impl Div<i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the / operator

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

The method for the / operator

impl Div<i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the / operator

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

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

impl Div<Nullable<u64>> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the / operator

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

The method for the / operator

impl Div<Nullable<i8>> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the / operator

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

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

impl Div<i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the / operator

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

The method for the / operator

impl Div<f64> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the / operator

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

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

impl Div<Nullable<i16>> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the / operator

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

The method for the / operator

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>

The method for the / operator

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>

The method for the / operator

impl Rem<Nullable<u64>> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

impl Rem<Nullable<f32>> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the % operator

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

The method for the % operator

impl Rem<Nullable<i32>> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

impl Rem<i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

impl Rem<f32> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

impl Rem<u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

impl Rem<u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

impl Rem<Nullable<i16>> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

impl Rem<Nullable<u8>> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

impl Rem<Nullable<usize>> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

impl Rem<Nullable<f64>> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

impl Rem<Nullable<i8>> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

impl Rem<u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

impl Rem<i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the % operator

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

The method for the % operator

impl Rem<usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

impl Rem<Nullable<u32>> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

impl Rem<Nullable<isize>> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

impl Rem<i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

impl Rem<u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

impl Rem<isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

impl Rem<f64> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

impl Rem<Nullable<u16>> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

impl Rem<Nullable<i64>> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

impl Rem<i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the % operator

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

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the % operator

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>

The method for the * operator

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>

The method for the * operator

impl Mul<Nullable<i16>> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the * operator

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

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

impl Mul<u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the * operator

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

The method for the * operator

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>

The method for the * operator

impl Mul<Nullable<u16>> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the * operator

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

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

impl Mul<usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the * operator

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

The method for the * operator

impl Mul<Nullable<u8>> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the * operator

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

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

impl Mul<isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the * operator

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

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

impl Mul<f64> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the * operator

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

The method for the * operator

impl Mul<i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the * operator

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

The method for the * operator

impl Mul<Nullable<f32>> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the * operator

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

The method for the * operator

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>

The method for the * operator

impl Mul<u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the * operator

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

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

impl Mul<Nullable<isize>> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the * operator

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

The method for the * operator

impl Mul<Nullable<i8>> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the * operator

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

The method for the * operator

impl Mul<i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the * operator

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

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

impl Mul<Nullable<usize>> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the * operator

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

The method for the * operator

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>

The method for the * operator

impl Mul<Nullable<i32>> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the * operator

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

The method for the * operator

impl Mul<u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the * operator

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

The method for the * operator

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>

The method for the * operator

impl Mul<Nullable<i64>> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the * operator

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

The method for the * operator

impl Mul<Nullable<f64>> for Nullable<f64>

type Output = Nullable<f64>

The resulting type after applying the * operator

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

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

impl Mul<u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the * operator

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

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

impl Mul<f32> for Nullable<f32>

type Output = Nullable<f32>

The resulting type after applying the * operator

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

The method for the * operator

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>

The method for the * operator

impl Mul<Nullable<u64>> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the * operator

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

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

impl Mul<i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the * operator

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

The method for the * operator

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>

The method for the * operator

impl Mul<Nullable<u32>> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the * operator

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

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

impl Mul<i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the * operator

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

The method for the * operator

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>

The method for the * operator

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>

The method for the * operator

impl BitXor<Nullable<isize>> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the ^ operator

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

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

impl BitXor<Nullable<u8>> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the ^ operator

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

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

impl BitXor<Nullable<u16>> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the ^ operator

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

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

impl BitXor<Nullable<u32>> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the ^ operator

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

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

impl BitXor<u32> for Nullable<u32>

type Output = Nullable<u32>

The resulting type after applying the ^ operator

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

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

impl BitXor<Nullable<i64>> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the ^ operator

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

The method for the ^ operator

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>

The method for the ^ operator

impl BitXor<Nullable<i8>> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the ^ operator

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

The method for the ^ operator

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>

The method for the ^ operator

impl BitXor<u16> for Nullable<u16>

type Output = Nullable<u16>

The resulting type after applying the ^ operator

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

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

impl BitXor<usize> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the ^ operator

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

The method for the ^ operator

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>

The method for the ^ operator

impl BitXor<u8> for Nullable<u8>

type Output = Nullable<u8>

The resulting type after applying the ^ operator

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

The method for the ^ operator

impl BitXor<i16> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the ^ operator

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

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

impl BitXor<Nullable<i16>> for Nullable<i16>

type Output = Nullable<i16>

The resulting type after applying the ^ operator

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

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

impl BitXor<isize> for Nullable<isize>

type Output = Nullable<isize>

The resulting type after applying the ^ operator

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

The method for the ^ operator

impl BitXor<u64> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the ^ operator

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

The method for the ^ operator

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>

The method for the ^ operator

impl BitXor<bool> for Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the ^ operator

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

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

impl BitXor<Nullable<usize>> for Nullable<usize>

type Output = Nullable<usize>

The resulting type after applying the ^ operator

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

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

impl BitXor<Nullable<bool>> for Nullable<bool>

type Output = Nullable<bool>

The resulting type after applying the ^ operator

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

The method for the ^ operator

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>

The method for the ^ operator

impl BitXor<Nullable<i32>> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the ^ operator

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

The method for the ^ operator

impl BitXor<i8> for Nullable<i8>

type Output = Nullable<i8>

The resulting type after applying the ^ operator

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

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

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>

The method for the ^ operator

impl BitXor<Nullable<u64>> for Nullable<u64>

type Output = Nullable<u64>

The resulting type after applying the ^ operator

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

The method for the ^ operator

impl BitXor<i64> for Nullable<i64>

type Output = Nullable<i64>

The resulting type after applying the ^ operator

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

The method for the ^ operator

impl BitXor<i32> for Nullable<i32>

type Output = Nullable<i32>

The resulting type after applying the ^ operator

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

The method for the ^ operator

impl<T> Eq for Nullable<T> where
    T: NullStorable + Eq, 

impl<T> PartialEq<Nullable<T>> for Nullable<T> where
    T: NullStorable + PartialEq<T>, 

fn eq(&self, __arg_0: &Nullable<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &Nullable<T>) -> bool

This method tests for !=.

impl<T> Debug for Nullable<T> where
    T: NullStorable + Debug, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.