use std::cmp::PartialEq;
-pub trait MyNum : Add<Self,Self> + Sub<Self,Self> + Mul<Self,Self> + PartialEq {
+pub trait MyNum : Add<Self,Self> + Sub<Self,Self> + Mul<Self,Self> + PartialEq + Clone {
}
-#[deriving(Show)]
+#[deriving(Clone, Show)]
pub struct MyInt {
pub val: int
}
impl Add<MyInt, MyInt> for MyInt {
- fn add(&self, other: &MyInt) -> MyInt { mi(self.val + other.val) }
+ fn add(self, other: MyInt) -> MyInt { mi(self.val + other.val) }
}
impl Sub<MyInt, MyInt> for MyInt {
- fn sub(&self, other: &MyInt) -> MyInt { mi(self.val - other.val) }
+ fn sub(self, other: MyInt) -> MyInt { mi(self.val - other.val) }
}
impl Mul<MyInt, MyInt> for MyInt {
- fn mul(&self, other: &MyInt) -> MyInt { mi(self.val * other.val) }
+ fn mul(self, other: MyInt) -> MyInt { mi(self.val * other.val) }
}
impl PartialEq for MyInt {
assert_eq!(false != true, true);
assert_eq!(false.ne(&false), false);
- assert_eq!(false.bitand(&false), false);
- assert_eq!(true.bitand(&false), false);
- assert_eq!(false.bitand(&true), false);
- assert_eq!(true.bitand(&true), true);
+ assert_eq!(false.bitand(false), false);
+ assert_eq!(true.bitand(false), false);
+ assert_eq!(false.bitand(true), false);
+ assert_eq!(true.bitand(true), true);
assert_eq!(false & false, false);
assert_eq!(true & false, false);
assert_eq!(false & true, false);
assert_eq!(true & true, true);
- assert_eq!(false.bitor(&false), false);
- assert_eq!(true.bitor(&false), true);
- assert_eq!(false.bitor(&true), true);
- assert_eq!(true.bitor(&true), true);
+ assert_eq!(false.bitor(false), false);
+ assert_eq!(true.bitor(false), true);
+ assert_eq!(false.bitor(true), true);
+ assert_eq!(true.bitor(true), true);
assert_eq!(false | false, false);
assert_eq!(true | false, true);
assert_eq!(false | true, true);
assert_eq!(true | true, true);
- assert_eq!(false.bitxor(&false), false);
- assert_eq!(true.bitxor(&false), true);
- assert_eq!(false.bitxor(&true), true);
- assert_eq!(true.bitxor(&true), false);
+ assert_eq!(false.bitxor(false), false);
+ assert_eq!(true.bitxor(false), true);
+ assert_eq!(false.bitxor(true), true);
+ assert_eq!(true.bitxor(true), false);
assert_eq!(false ^ false, false);
assert_eq!(true ^ false, true);
struct Vector2<T>(T, T);
impl<T: Add<T, T>> Add<Vector2<T>, Vector2<T>> for Vector2<T> {
- fn add(&self, other: &Vector2<T>) -> Vector2<T> {
+ fn add(self, other: Vector2<T>) -> Vector2<T> {
match (self, other) {
- (&Vector2(ref x0, ref y0), &Vector2(ref x1, ref y1)) => {
- Vector2(*x0 + *x1, *y0 + *y1)
+ (Vector2(x0, y0), Vector2(x1, y1)) => {
+ Vector2(x0 + x1, y0 + y1)
}
}
}
}
impl<T: Add<T, T>> Add<Vector3<T>, Vector3<T>> for Vector3<T> {
- fn add(&self, other: &Vector3<T>) -> Vector3<T> {
+ fn add(self, other: Vector3<T>) -> Vector3<T> {
Vector3 {
x: self.x + other.x,
y: self.y + other.y,
}
impl<T: Add<T, T>> Add<Matrix3x2<T>, Matrix3x2<T>> for Matrix3x2<T> {
- fn add(&self, other: &Matrix3x2<T>) -> Matrix3x2<T> {
+ fn add(self, other: Matrix3x2<T>) -> Matrix3x2<T> {
Matrix3x2 {
x: self.x + other.x,
y: self.y + other.y,
// Vec2's implementation of Mul "from the other side" using the above trait
impl<Res, Rhs: RhsOfVec2Mul<Res>> Mul<Rhs,Res> for Vec2 {
- fn mul(&self, rhs: &Rhs) -> Res { rhs.mul_vec2_by(self) }
+ fn mul(self, rhs: Rhs) -> Res { rhs.mul_vec2_by(&self) }
}
// Implementation of 'f64 as right-hand-side of Vec2::Mul'
pub fn main() {
// ints
// num
- assert_eq!(15i.add(&6), 21);
- assert_eq!(15i8.add(&6i8), 21i8);
- assert_eq!(15i16.add(&6i16), 21i16);
- assert_eq!(15i32.add(&6i32), 21i32);
- assert_eq!(15i64.add(&6i64), 21i64);
+ assert_eq!(15i.add(6), 21);
+ assert_eq!(15i8.add(6i8), 21i8);
+ assert_eq!(15i16.add(6i16), 21i16);
+ assert_eq!(15i32.add(6i32), 21i32);
+ assert_eq!(15i64.add(6i64), 21i64);
// uints
// num
- assert_eq!(15u.add(&6u), 21u);
- assert_eq!(15u8.add(&6u8), 21u8);
- assert_eq!(15u16.add(&6u16), 21u16);
- assert_eq!(15u32.add(&6u32), 21u32);
- assert_eq!(15u64.add(&6u64), 21u64);
+ assert_eq!(15u.add(6u), 21u);
+ assert_eq!(15u8.add(6u8), 21u8);
+ assert_eq!(15u16.add(6u16), 21u16);
+ assert_eq!(15u32.add(6u32), 21u32);
+ assert_eq!(15u64.add(6u64), 21u64);
// floats
// num
}
impl ops::Add<Point,Point> for Point {
- fn add(&self, other: &Point) -> Point {
- Point {x: self.x + (*other).x, y: self.y + (*other).y}
+ fn add(self, other: Point) -> Point {
+ Point {x: self.x + other.x, y: self.y + other.y}
}
}
impl ops::Add<int,Point> for Point {
- fn add(&self, &other: &int) -> Point {
+ fn add(self, other: int) -> Point {
Point {x: self.x + other,
y: self.y + other}
}
use std::cmp;
use std::ops;
-#[deriving(Show)]
+#[deriving(Copy, Show)]
struct Point {
x: int,
y: int
}
impl ops::Add<Point,Point> for Point {
- fn add(&self, other: &Point) -> Point {
- Point {x: self.x + (*other).x, y: self.y + (*other).y}
+ fn add(self, other: Point) -> Point {
+ Point {x: self.x + other.x, y: self.y + other.y}
}
}
impl ops::Sub<Point,Point> for Point {
- fn sub(&self, other: &Point) -> Point {
- Point {x: self.x - (*other).x, y: self.y - (*other).y}
+ fn sub(self, other: Point) -> Point {
+ Point {x: self.x - other.x, y: self.y - other.y}
}
}
impl<'a, A: Add<int, int>> Fn<(A,), int> for G {
extern "rust-call" fn call(&self, (arg,): (A,)) -> int {
- arg.add(&1)
+ arg.add(1)
}
}
}
impl ops::Add<f32x4, f32x4> for f32x4 {
- fn add(&self, rhs: &f32x4) -> f32x4 {
- *self + *rhs
+ fn add(self, rhs: f32x4) -> f32x4 {
+ self + rhs
}
}
use trait_inheritance_overloading_xc::{MyNum, MyInt};
fn f<T:MyNum>(x: T, y: T) -> (T, T, T) {
- return (x + y, x - y, x * y);
+ return (x.clone() + y.clone(), x.clone() - y.clone(), x * y);
}
fn mi(v: int) -> MyInt { MyInt { val: v } }
use std::cmp::PartialEq;
-trait MyNum : Add<Self,Self> + Sub<Self,Self> + Mul<Self,Self> + PartialEq { }
+trait MyNum : Add<Self,Self> + Sub<Self,Self> + Mul<Self,Self> + PartialEq + Clone { }
-#[deriving(Show)]
+#[deriving(Clone, Show)]
struct MyInt { val: int }
impl Add<MyInt, MyInt> for MyInt {
- fn add(&self, other: &MyInt) -> MyInt { mi(self.val + other.val) }
+ fn add(self, other: MyInt) -> MyInt { mi(self.val + other.val) }
}
impl Sub<MyInt, MyInt> for MyInt {
- fn sub(&self, other: &MyInt) -> MyInt { mi(self.val - other.val) }
+ fn sub(self, other: MyInt) -> MyInt { mi(self.val - other.val) }
}
impl Mul<MyInt, MyInt> for MyInt {
- fn mul(&self, other: &MyInt) -> MyInt { mi(self.val * other.val) }
+ fn mul(self, other: MyInt) -> MyInt { mi(self.val * other.val) }
}
impl PartialEq for MyInt {
impl MyNum for MyInt {}
fn f<T:MyNum>(x: T, y: T) -> (T, T, T) {
- return (x + y, x - y, x * y);
+ return (x.clone() + y.clone(), x.clone() - y.clone(), x * y);
}
fn mi(v: int) -> MyInt { MyInt { val: v } }