use gen_ops::*;
use std::ops::*;
mod where_clause_ncomm {
use super::*;
#[derive(Copy, Clone, PartialEq, Debug)]
pub struct Complex<T>(pub T, pub T);
gen_ops!(
<T>;
types Complex<T>, Complex<T> => Complex<T>;
for + call |a: &Complex<T>, b: &Complex<T>| Complex(a.0+b.0, a.1+b.1);
(where T: Add<Output=T>)
for - call |a: &Complex<T>, b: &Complex<T>| Complex(a.0-b.0, a.1-b.1);
(where T: Sub<Output=T>)
where T: Copy
);
#[test]
fn where_clause_bin_test() {
assert_eq!(Complex(1, -5) + Complex(5, 6), Complex(6, 1));
assert_eq!(Complex(1, -5) - Complex(5, 6), Complex(-4, -11));
}
gen_ops!(
<T>;
types Complex<T>, Complex<T>;
for += call |a: &mut Complex<T>, b: &Complex<T>| {
a.0 += b.0;
a.1 += b.1;
}; (where T: AddAssign<T>)
for -= call |a: &mut Complex<T>, b: &Complex<T>| {
a.0 -= b.0;
a.1 -= b.1;
}; (where T: SubAssign<T>)
where T: Copy
);
#[test]
fn where_clause_asgn_test() {
let x = Complex(5, -2);
let b = Complex(1, -4);
{
let mut a = x;
a += b;
assert_eq!(a, Complex(6, -6));
}
{
let mut a = x;
a -= b;
assert_eq!(a, Complex(4, 2));
}
}
gen_ops!(
<T>;
types Complex<T> => Complex<T>;
for - call |a: &Complex<T>| Complex(-a.0, -a.1);
(where T: Neg<Output=T>)
for ! call |a: &Complex<T>| Complex(a.0, -a.1);
(where T: Neg<Output=T>)
where T: Copy
);
#[test]
fn where_clause_un_test() {
let a = Complex(5, -4);
assert_eq!(-a, Complex(-5, 4));
assert_eq!(!a, Complex(5, 4));
}
}
mod where_clause_ncomm_ex {
use super::*;
#[derive(Copy, Clone, PartialEq, Debug)]
pub struct Complex<T>(pub T, pub T);
gen_ops_ex!(
<T>;
types ref Complex<T>, ref Complex<T> => Complex<T>;
for + call |a: &Complex<T>, b: &Complex<T>| Complex(a.0+b.0, a.1+b.1);
(where T: Add<Output=T>)
for - call |a: &Complex<T>, b: &Complex<T>| Complex(a.0-b.0, a.1-b.1);
(where T: Sub<Output=T>)
where T: Copy
);
#[test]
fn where_clause_bin_ex_test() {
let a = Complex(1, -5);
let b = Complex(5, 6);
let res_add = Complex(6, 1);
let res_sub = Complex(-4, -11);
assert_eq!(a + b, res_add);
assert_eq!(&a + b, res_add);
assert_eq!(a + b, res_add);
assert_eq!(&a + &b, res_add);
assert_eq!(a - b, res_sub);
assert_eq!(&a - b, res_sub);
assert_eq!(a - &b, res_sub);
assert_eq!(&a - &b, res_sub);
}
gen_ops_ex!(
<T>;
types mut Complex<T>, ref Complex<T>;
for += call |a: &mut Complex<T>, b: &Complex<T>| {
a.0 += b.0;
a.1 += b.1;
}; (where T: AddAssign<T>)
for -= call |a: &mut Complex<T>, b: &Complex<T>| {
a.0 -= b.0;
a.1 -= b.1;
}; (where T: SubAssign<T>)
where T: Copy
);
#[test]
fn where_clause_asgn_ex_test() {
let mut x = Complex(5, -2);
let b = Complex(1, -4);
let res_add = Complex(6, -6);
let res_sub = Complex(4, 2);
{
let mut a = x;
a += b;
assert_eq!(a, res_add);
}
{
let mut a = x;
a += &b;
assert_eq!(a, res_add);
}
{
let mut a = &mut x;
a += b;
assert_eq!(x, res_add);
}
x = Complex(5, -2);
{
let mut a = &mut x;
a += &b;
assert_eq!(x, res_add);
}
x = Complex(5, -2);
{
let mut a = x;
a -= b;
assert_eq!(a, res_sub);
}
{
let mut a = x;
a -= &b;
assert_eq!(a, res_sub);
}
{
let mut a = &mut x;
a -= b;
assert_eq!(x, res_sub);
}
x = Complex(5, -2);
{
let mut a = &mut x;
a -= &b;
assert_eq!(x, res_sub);
}
}
gen_ops_ex!(
<T>;
types ref Complex<T> => Complex<T>;
for - call |a: &Complex<T>| Complex(-a.0, -a.1);
(where T: Neg<Output=T>)
for ! call |a: &Complex<T>| Complex(a.0, -a.1);
(where T: Neg<Output=T>)
where T: Copy
);
#[test]
fn where_clause_un_ex_test() {
let a = Complex(5, -4);
assert_eq!(-a, Complex(-5, 4));
assert_eq!(-&a, Complex(-5, 4));
assert_eq!(!a, Complex(5, 4));
assert_eq!(!&a, Complex(5, 4));
}
}
mod where_clause_comm {
use super::*;
#[derive(Copy, Clone, PartialEq, Debug)]
pub struct Complex<T>(pub T, pub T);
gen_ops_comm!(
<T>;
types Complex<T>, i32 => Complex<T>;
for + call |a: &Complex<T>, b: &i32| Complex(a.0+*b, a.1);
(where T: Add<i32, Output=T>)
for * call |a: &Complex<T>, b:&i32| Complex(a.0*(*b), a.1*(*b));
(where T: Mul<i32, Output=T>)
where T: Copy
);
#[test]
fn where_clause_bin_comm_test() {
let a = Complex(1, -5);
let b = -3;
let res_add = Complex(-2, -5);
let res_mul = Complex(-3, 15);
assert_eq!(a + b, res_add);
assert_eq!(b + a, res_add);
assert_eq!(a * b, res_mul);
assert_eq!(b * a, res_mul);
}
}
mod where_clause_comm_ex {
use super::*;
#[derive(Copy, Clone, PartialEq, Debug)]
pub struct Complex<T>(pub T, pub T);
gen_ops_comm_ex!(
<T>;
types ref Complex<T>, ref i32 => Complex<T>;
for + call |a: &Complex<T>, b: &i32| Complex(a.0+*b, a.1);
(where T: Add<i32, Output=T>)
for * call |a: &Complex<T>, b:&i32| Complex(a.0*(*b), a.1*(*b));
(where T: Mul<i32, Output=T>)
where T: Copy
);
#[test]
fn where_clause_bin_comm_ex_test() {
let a = Complex(1, -5);
let b = -3;
let res_add = Complex(-2, -5);
let res_mul = Complex(-3, 15);
assert_eq!(a + b, res_add);
assert_eq!(&a + b, res_add);
assert_eq!(a + &b, res_add);
assert_eq!(&a + &b, res_add);
assert_eq!(b + a, res_add);
assert_eq!(&b + a, res_add);
assert_eq!(b + &a, res_add);
assert_eq!(&b + &a, res_add);
assert_eq!(a * b, res_mul);
assert_eq!(&a * b, res_mul);
assert_eq!(a * &b, res_mul);
assert_eq!(&a * &b, res_mul);
assert_eq!(b * a, res_mul);
assert_eq!(&b * a, res_mul);
assert_eq!(b * &a, res_mul);
assert_eq!(&b * &a, res_mul);
}
}