Trait Div 

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

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

Required Associated Types

type Output

The resulting type after applying the / operator.

Required Methods

fn op_div(self, rhs: Rhs) -> Self::Output

Performs the / operation.

Example

assert_eq!(12 / 2, 6);

Implementations on Foreign Types

impl Div for Bson

type Output = Bson

fn op_div(self, rhs: Bson) -> <Bson as Div>::Output

impl Div for f32

type Output = f32

fn op_div(self, rhs: f32) -> <f32 as Div>::Output

impl Div for f64

type Output = f64

fn op_div(self, rhs: f64) -> <f64 as Div>::Output

impl Div for i8

type Output = i8

fn op_div(self, rhs: i8) -> <i8 as Div>::Output

impl Div for i16

type Output = i16

fn op_div(self, rhs: i16) -> <i16 as Div>::Output

impl Div for i32

type Output = i32

fn op_div(self, rhs: i32) -> <i32 as Div>::Output

impl Div for i64

type Output = i64

fn op_div(self, rhs: i64) -> <i64 as Div>::Output

impl Div for isize

type Output = isize

fn op_div(self, rhs: isize) -> <isize as Div>::Output

impl Div for u8

type Output = u8

fn op_div(self, rhs: u8) -> <u8 as Div>::Output

impl Div for u16

type Output = u16

fn op_div(self, rhs: u16) -> <u16 as Div>::Output

impl Div for u32

type Output = u32

fn op_div(self, rhs: u32) -> <u32 as Div>::Output

impl Div for u64

type Output = u64

fn op_div(self, rhs: u64) -> <u64 as Div>::Output

impl Div<&&Bson> for &Bson

type Output = Bson

fn op_div(self, rhs: &&Bson) -> <&Bson as Div<&&Bson>>::Output

impl Div<&&Bson> for Bson

type Output = Bson

fn op_div(self, rhs: &&Bson) -> <Bson as Div<&&Bson>>::Output

impl Div<&&Bson> for f32

type Output = f64

fn op_div(self, other: &&Bson) -> <f32 as Div<&&Bson>>::Output

impl Div<&&Bson> for f64

type Output = f64

fn op_div(self, other: &&Bson) -> <f64 as Div<&&Bson>>::Output

impl Div<&&Bson> for i8

type Output = i64

fn op_div(self, other: &&Bson) -> <i8 as Div<&&Bson>>::Output

impl Div<&&Bson> for i16

type Output = i64

fn op_div(self, other: &&Bson) -> <i16 as Div<&&Bson>>::Output

impl Div<&&Bson> for i32

type Output = i64

fn op_div(self, other: &&Bson) -> <i32 as Div<&&Bson>>::Output

impl Div<&&Bson> for i64

type Output = i64

fn op_div(self, other: &&Bson) -> <i64 as Div<&&Bson>>::Output

impl Div<&&Bson> for isize

type Output = i64

fn op_div(self, other: &&Bson) -> <isize as Div<&&Bson>>::Output

impl Div<&&Bson> for u8

type Output = u64

fn op_div(self, other: &&Bson) -> <u8 as Div<&&Bson>>::Output

impl Div<&&Bson> for u16

type Output = u64

fn op_div(self, other: &&Bson) -> <u16 as Div<&&Bson>>::Output

impl Div<&&Bson> for u32

type Output = u64

fn op_div(self, other: &&Bson) -> <u32 as Div<&&Bson>>::Output

impl Div<&&Bson> for u64

type Output = u64

fn op_div(self, other: &&Bson) -> <u64 as Div<&&Bson>>::Output

impl Div<&&f32> for Bson

type Output = f64

fn op_div(self, other: &&f32) -> <Bson as Div<&&f32>>::Output

impl Div<&&f64> for Bson

type Output = f64

fn op_div(self, other: &&f64) -> <Bson as Div<&&f64>>::Output

impl Div<&&i8> for Bson

type Output = i64

fn op_div(self, other: &&i8) -> <Bson as Div<&&i8>>::Output

impl Div<&&i16> for Bson

type Output = i64

fn op_div(self, other: &&i16) -> <Bson as Div<&&i16>>::Output

impl Div<&&i32> for Bson

type Output = i64

fn op_div(self, other: &&i32) -> <Bson as Div<&&i32>>::Output

impl Div<&&i64> for Bson

type Output = i64

fn op_div(self, other: &&i64) -> <Bson as Div<&&i64>>::Output

impl Div<&&isize> for Bson

type Output = i64

fn op_div(self, other: &&isize) -> <Bson as Div<&&isize>>::Output

impl Div<&&u8> for Bson

type Output = u64

fn op_div(self, other: &&u8) -> <Bson as Div<&&u8>>::Output

impl Div<&&u16> for Bson

type Output = u64

fn op_div(self, other: &&u16) -> <Bson as Div<&&u16>>::Output

impl Div<&&u32> for Bson

type Output = u64

fn op_div(self, other: &&u32) -> <Bson as Div<&&u32>>::Output

impl Div<&&u64> for Bson

type Output = u64

fn op_div(self, other: &&u64) -> <Bson as Div<&&u64>>::Output

impl Div<&Bson> for &Bson

type Output = Bson

fn op_div(self, rhs: &Bson) -> <&Bson as Div<&Bson>>::Output

impl Div<&Bson> for Bson

type Output = Bson

fn op_div(self, rhs: &Bson) -> <Bson as Div<&Bson>>::Output

impl Div<&Bson> for f32

type Output = f64

fn op_div(self, other: &Bson) -> <f32 as Div<&Bson>>::Output

impl Div<&Bson> for f64

type Output = f64

fn op_div(self, other: &Bson) -> <f64 as Div<&Bson>>::Output

impl Div<&Bson> for i8

type Output = i64

fn op_div(self, other: &Bson) -> <i8 as Div<&Bson>>::Output

impl Div<&Bson> for i16

type Output = i64

fn op_div(self, other: &Bson) -> <i16 as Div<&Bson>>::Output

impl Div<&Bson> for i32

type Output = i64

fn op_div(self, other: &Bson) -> <i32 as Div<&Bson>>::Output

impl Div<&Bson> for i64

type Output = i64

fn op_div(self, other: &Bson) -> <i64 as Div<&Bson>>::Output

impl Div<&Bson> for isize

type Output = i64

fn op_div(self, other: &Bson) -> <isize as Div<&Bson>>::Output

impl Div<&Bson> for u8

type Output = u64

fn op_div(self, other: &Bson) -> <u8 as Div<&Bson>>::Output

impl Div<&Bson> for u16

type Output = u64

fn op_div(self, other: &Bson) -> <u16 as Div<&Bson>>::Output

impl Div<&Bson> for u32

type Output = u64

fn op_div(self, other: &Bson) -> <u32 as Div<&Bson>>::Output

impl Div<&Bson> for u64

type Output = u64

fn op_div(self, other: &Bson) -> <u64 as Div<&Bson>>::Output

impl Div<&f32> for &f32

type Output = f32

fn op_div(self, rhs: &f32) -> <&f32 as Div<&f32>>::Output

impl Div<&f32> for Bson

type Output = f64

fn op_div(self, other: &f32) -> <Bson as Div<&f32>>::Output

impl Div<&f32> for f32

type Output = f32

fn op_div(self, rhs: &f32) -> <f32 as Div<&f32>>::Output

impl Div<&f64> for &f64

type Output = f64

fn op_div(self, rhs: &f64) -> <&f64 as Div<&f64>>::Output

impl Div<&f64> for Bson

type Output = f64

fn op_div(self, other: &f64) -> <Bson as Div<&f64>>::Output

impl Div<&f64> for f64

type Output = f64

fn op_div(self, rhs: &f64) -> <f64 as Div<&f64>>::Output

impl Div<&i8> for &i8

type Output = i8

fn op_div(self, rhs: &i8) -> <&i8 as Div<&i8>>::Output

impl Div<&i8> for Bson

type Output = i64

fn op_div(self, other: &i8) -> <Bson as Div<&i8>>::Output

impl Div<&i8> for i8

type Output = i8

fn op_div(self, rhs: &i8) -> <i8 as Div<&i8>>::Output

impl Div<&i16> for &i16

type Output = i16

fn op_div(self, rhs: &i16) -> <&i16 as Div<&i16>>::Output

impl Div<&i16> for Bson

type Output = i64

fn op_div(self, other: &i16) -> <Bson as Div<&i16>>::Output

impl Div<&i16> for i16

type Output = i16

fn op_div(self, rhs: &i16) -> <i16 as Div<&i16>>::Output

impl Div<&i32> for &i32

type Output = i32

fn op_div(self, rhs: &i32) -> <&i32 as Div<&i32>>::Output

impl Div<&i32> for Bson

type Output = i64

fn op_div(self, other: &i32) -> <Bson as Div<&i32>>::Output

impl Div<&i32> for i32

type Output = i32

fn op_div(self, rhs: &i32) -> <i32 as Div<&i32>>::Output

impl Div<&i64> for &i64

type Output = i64

fn op_div(self, rhs: &i64) -> <&i64 as Div<&i64>>::Output

impl Div<&i64> for Bson

type Output = i64

fn op_div(self, other: &i64) -> <Bson as Div<&i64>>::Output

impl Div<&i64> for i64

type Output = i64

fn op_div(self, rhs: &i64) -> <i64 as Div<&i64>>::Output

impl Div<&isize> for &isize

type Output = isize

fn op_div(self, rhs: &isize) -> <&isize as Div<&isize>>::Output

impl Div<&isize> for Bson

type Output = i64

fn op_div(self, other: &isize) -> <Bson as Div<&isize>>::Output

impl Div<&isize> for isize

type Output = isize

fn op_div(self, rhs: &isize) -> <isize as Div<&isize>>::Output

impl Div<&u8> for &u8

type Output = u8

fn op_div(self, rhs: &u8) -> <&u8 as Div<&u8>>::Output

impl Div<&u8> for Bson

type Output = u64

fn op_div(self, other: &u8) -> <Bson as Div<&u8>>::Output

impl Div<&u8> for u8

type Output = u8

fn op_div(self, rhs: &u8) -> <u8 as Div<&u8>>::Output

impl Div<&u16> for &u16

type Output = u16

fn op_div(self, rhs: &u16) -> <&u16 as Div<&u16>>::Output

impl Div<&u16> for Bson

type Output = u64

fn op_div(self, other: &u16) -> <Bson as Div<&u16>>::Output

impl Div<&u16> for u16

type Output = u16

fn op_div(self, rhs: &u16) -> <u16 as Div<&u16>>::Output

impl Div<&u32> for &u32

type Output = u32

fn op_div(self, rhs: &u32) -> <&u32 as Div<&u32>>::Output

impl Div<&u32> for Bson

type Output = u64

fn op_div(self, other: &u32) -> <Bson as Div<&u32>>::Output

impl Div<&u32> for u32

type Output = u32

fn op_div(self, rhs: &u32) -> <u32 as Div<&u32>>::Output

impl Div<&u64> for &u64

type Output = u64

fn op_div(self, rhs: &u64) -> <&u64 as Div<&u64>>::Output

impl Div<&u64> for Bson

type Output = u64

fn op_div(self, other: &u64) -> <Bson as Div<&u64>>::Output

impl Div<&u64> for u64

type Output = u64

fn op_div(self, rhs: &u64) -> <u64 as Div<&u64>>::Output

impl Div<Bson> for &Bson

type Output = Bson

fn op_div(self, rhs: Bson) -> <&Bson as Div<Bson>>::Output

impl Div<Bson> for f32

type Output = f64

fn op_div(self, other: Bson) -> <f32 as Div<Bson>>::Output

impl Div<Bson> for f64

type Output = f64

fn op_div(self, other: Bson) -> <f64 as Div<Bson>>::Output

impl Div<Bson> for i8

type Output = i64

fn op_div(self, other: Bson) -> <i8 as Div<Bson>>::Output

impl Div<Bson> for i16

type Output = i64

fn op_div(self, other: Bson) -> <i16 as Div<Bson>>::Output

impl Div<Bson> for i32

type Output = i64

fn op_div(self, other: Bson) -> <i32 as Div<Bson>>::Output

impl Div<Bson> for i64

type Output = i64

fn op_div(self, other: Bson) -> <i64 as Div<Bson>>::Output

impl Div<Bson> for isize

type Output = i64

fn op_div(self, other: Bson) -> <isize as Div<Bson>>::Output

impl Div<Bson> for u8

type Output = u64

fn op_div(self, other: Bson) -> <u8 as Div<Bson>>::Output

impl Div<Bson> for u16

type Output = u64

fn op_div(self, other: Bson) -> <u16 as Div<Bson>>::Output

impl Div<Bson> for u32

type Output = u64

fn op_div(self, other: Bson) -> <u32 as Div<Bson>>::Output

impl Div<Bson> for u64

type Output = u64

fn op_div(self, other: Bson) -> <u64 as Div<Bson>>::Output

impl Div<f32> for &f32

type Output = f32

fn op_div(self, rhs: f32) -> <&f32 as Div<f32>>::Output

impl Div<f32> for Bson

type Output = f64

fn op_div(self, other: f32) -> <Bson as Div<f32>>::Output

impl Div<f64> for &f64

type Output = f64

fn op_div(self, rhs: f64) -> <&f64 as Div<f64>>::Output

impl Div<f64> for Bson

type Output = f64

fn op_div(self, other: f64) -> <Bson as Div<f64>>::Output

impl Div<i8> for &i8

type Output = i8

fn op_div(self, rhs: i8) -> <&i8 as Div<i8>>::Output

impl Div<i8> for Bson

type Output = i64

fn op_div(self, other: i8) -> <Bson as Div<i8>>::Output

impl Div<i16> for &i16

type Output = i16

fn op_div(self, rhs: i16) -> <&i16 as Div<i16>>::Output

impl Div<i16> for Bson

type Output = i64

fn op_div(self, other: i16) -> <Bson as Div<i16>>::Output

impl Div<i32> for &i32

type Output = i32

fn op_div(self, rhs: i32) -> <&i32 as Div<i32>>::Output

impl Div<i32> for Bson

type Output = i64

fn op_div(self, other: i32) -> <Bson as Div<i32>>::Output

impl Div<i64> for &i64

type Output = i64

fn op_div(self, rhs: i64) -> <&i64 as Div<i64>>::Output

impl Div<i64> for Bson

type Output = i64

fn op_div(self, other: i64) -> <Bson as Div<i64>>::Output

impl Div<isize> for &isize

type Output = isize

fn op_div(self, rhs: isize) -> <&isize as Div<isize>>::Output

impl Div<isize> for Bson

type Output = i64

fn op_div(self, other: isize) -> <Bson as Div<isize>>::Output

impl Div<u8> for &u8

type Output = u8

fn op_div(self, rhs: u8) -> <&u8 as Div<u8>>::Output

impl Div<u8> for Bson

type Output = u64

fn op_div(self, other: u8) -> <Bson as Div<u8>>::Output

impl Div<u16> for &u16

type Output = u16

fn op_div(self, rhs: u16) -> <&u16 as Div<u16>>::Output

impl Div<u16> for Bson

type Output = u64

fn op_div(self, other: u16) -> <Bson as Div<u16>>::Output

impl Div<u32> for &u32

type Output = u32

fn op_div(self, rhs: u32) -> <&u32 as Div<u32>>::Output

impl Div<u32> for Bson

type Output = u64

fn op_div(self, other: u32) -> <Bson as Div<u32>>::Output

impl Div<u64> for &u64

type Output = u64

fn op_div(self, rhs: u64) -> <&u64 as Div<u64>>::Output

impl Div<u64> for Bson

type Output = u64

fn op_div(self, other: u64) -> <Bson as Div<u64>>::Output

impl<'a> Div<&&f32> for &'a Bson

type Output = f64

fn op_div(self, other: &&f32) -> <&'a Bson as Div<&&f32>>::Output

impl<'a> Div<&&f64> for &'a Bson

type Output = f64

fn op_div(self, other: &&f64) -> <&'a Bson as Div<&&f64>>::Output

impl<'a> Div<&&i8> for &'a Bson

type Output = i64

fn op_div(self, other: &&i8) -> <&'a Bson as Div<&&i8>>::Output

impl<'a> Div<&&i16> for &'a Bson

type Output = i64

fn op_div(self, other: &&i16) -> <&'a Bson as Div<&&i16>>::Output

impl<'a> Div<&&i32> for &'a Bson

type Output = i64

fn op_div(self, other: &&i32) -> <&'a Bson as Div<&&i32>>::Output

impl<'a> Div<&&i64> for &'a Bson

type Output = i64

fn op_div(self, other: &&i64) -> <&'a Bson as Div<&&i64>>::Output

impl<'a> Div<&&isize> for &'a Bson

type Output = i64

fn op_div(self, other: &&isize) -> <&'a Bson as Div<&&isize>>::Output

impl<'a> Div<&&u8> for &'a Bson

type Output = u64

fn op_div(self, other: &&u8) -> <&'a Bson as Div<&&u8>>::Output

impl<'a> Div<&&u16> for &'a Bson

type Output = u64

fn op_div(self, other: &&u16) -> <&'a Bson as Div<&&u16>>::Output

impl<'a> Div<&&u32> for &'a Bson

type Output = u64

fn op_div(self, other: &&u32) -> <&'a Bson as Div<&&u32>>::Output

impl<'a> Div<&&u64> for &'a Bson

type Output = u64

fn op_div(self, other: &&u64) -> <&'a Bson as Div<&&u64>>::Output

impl<'a> Div<&f32> for &'a Bson

type Output = f64

fn op_div(self, other: &f32) -> <&'a Bson as Div<&f32>>::Output

impl<'a> Div<&f64> for &'a Bson

type Output = f64

fn op_div(self, other: &f64) -> <&'a Bson as Div<&f64>>::Output

impl<'a> Div<&i8> for &'a Bson

type Output = i64

fn op_div(self, other: &i8) -> <&'a Bson as Div<&i8>>::Output

impl<'a> Div<&i16> for &'a Bson

type Output = i64

fn op_div(self, other: &i16) -> <&'a Bson as Div<&i16>>::Output

impl<'a> Div<&i32> for &'a Bson

type Output = i64

fn op_div(self, other: &i32) -> <&'a Bson as Div<&i32>>::Output

impl<'a> Div<&i64> for &'a Bson

type Output = i64

fn op_div(self, other: &i64) -> <&'a Bson as Div<&i64>>::Output

impl<'a> Div<&isize> for &'a Bson

type Output = i64

fn op_div(self, other: &isize) -> <&'a Bson as Div<&isize>>::Output

impl<'a> Div<&u8> for &'a Bson

type Output = u64

fn op_div(self, other: &u8) -> <&'a Bson as Div<&u8>>::Output

impl<'a> Div<&u16> for &'a Bson

type Output = u64

fn op_div(self, other: &u16) -> <&'a Bson as Div<&u16>>::Output

impl<'a> Div<&u32> for &'a Bson

type Output = u64

fn op_div(self, other: &u32) -> <&'a Bson as Div<&u32>>::Output

impl<'a> Div<&u64> for &'a Bson

type Output = u64

fn op_div(self, other: &u64) -> <&'a Bson as Div<&u64>>::Output

impl<'a> Div<f32> for &'a Bson

type Output = f64

fn op_div(self, other: f32) -> <&'a Bson as Div<f32>>::Output

impl<'a> Div<f64> for &'a Bson

type Output = f64

fn op_div(self, other: f64) -> <&'a Bson as Div<f64>>::Output

impl<'a> Div<i8> for &'a Bson

type Output = i64

fn op_div(self, other: i8) -> <&'a Bson as Div<i8>>::Output

impl<'a> Div<i16> for &'a Bson

type Output = i64

fn op_div(self, other: i16) -> <&'a Bson as Div<i16>>::Output

impl<'a> Div<i32> for &'a Bson

type Output = i64

fn op_div(self, other: i32) -> <&'a Bson as Div<i32>>::Output

impl<'a> Div<i64> for &'a Bson

type Output = i64

fn op_div(self, other: i64) -> <&'a Bson as Div<i64>>::Output

impl<'a> Div<isize> for &'a Bson

type Output = i64

fn op_div(self, other: isize) -> <&'a Bson as Div<isize>>::Output

impl<'a> Div<u8> for &'a Bson

type Output = u64

fn op_div(self, other: u8) -> <&'a Bson as Div<u8>>::Output

impl<'a> Div<u16> for &'a Bson

type Output = u64

fn op_div(self, other: u16) -> <&'a Bson as Div<u16>>::Output

impl<'a> Div<u32> for &'a Bson

type Output = u64

fn op_div(self, other: u32) -> <&'a Bson as Div<u32>>::Output

impl<'a> Div<u64> for &'a Bson

type Output = u64

fn op_div(self, other: u64) -> <&'a Bson as Div<u64>>::Output

Implementors