rustc: Make < and = into traits

Author: pcwalton

src/cargo/cargo.rs

@@ -25,6 +25,25 @@ type package = {
     versions: ~[(~str, ~str)]
 };
 
+impl package : cmp::Ord {
+    pure fn lt(&&other: package) -> bool {
+        if self.name.lt(other.name) { return true; }
+        if other.name.lt(self.name) { return false; }
+        if self.uuid.lt(other.uuid) { return true; }
+        if other.uuid.lt(self.uuid) { return false; }
+        if self.url.lt(other.url) { return true; }
+        if other.url.lt(self.url) { return false; }
+        if self.method.lt(other.method) { return true; }
+        if other.method.lt(self.method) { return false; }
+        if self.description.lt(other.description) { return true; }
+        if other.description.lt(self.description) { return false; }
+        if self.tags.lt(other.tags) { return true; }
+        if other.tags.lt(self.tags) { return false; }
+        if self.versions.lt(other.versions) { return true; }
+        return false;
+    }
+}
+
 type local_package = {
     name: ~str,
     metaname: ~str,
@@ -74,6 +93,12 @@ type options = {
 
 enum mode { system_mode, user_mode, local_mode }
 
+impl mode : cmp::Eq {
+    pure fn eq(&&other: mode) -> bool {
+        (self as uint) == (other as uint)
+    }
+}
+
 fn opts() -> ~[getopts::Opt] {
     ~[optflag(~"g"), optflag(~"G"), optflag(~"test"),
      optflag(~"h"), optflag(~"help")]

src/fuzzer/fuzzer.rs

@@ -8,6 +8,12 @@ import syntax::diagnostic;
 enum test_mode { tm_converge, tm_run, }
 type context = { mode: test_mode }; // + rng
 
+impl test_mode : cmp::Eq {
+    pure fn eq(&&other: test_mode) -> bool {
+        (self as uint) == (other as uint)
+    }
+}
+
 fn write_file(filename: &Path, content: ~str) {
     result::get(
         io::file_writer(filename, ~[io::Create, io::Truncate]))

src/libcore/bool.rs

@@ -6,6 +6,8 @@
 
 //! Boolean logic
 
+import cmp::Eq;
+
 export not, and, or, xor, implies;
 export eq, ne, is_true, is_false;
 export from_str, to_str, all_values, to_bit;
@@ -67,6 +69,12 @@ fn all_values(blk: fn(v: bool)) {
 /// converts truth value to an 8 bit byte
 pure fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } }
 
+impl bool : cmp::Eq {
+    pure fn eq(&&other: bool) -> bool {
+        self == other
+    }
+}
+
 #[test]
 fn test_bool_from_str() {
     do all_values |v| {

src/libcore/box.rs

@@ -4,13 +4,23 @@
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
+import cmp::{Eq, Ord};
+
 export ptr_eq;
 
 pure fn ptr_eq<T>(a: @T, b: @T) -> bool {
     //! Determine if two shared boxes point to the same object
     unsafe { ptr::addr_of(*a) == ptr::addr_of(*b) }
 }
 
+impl<T:Eq> @const T : Eq {
+    pure fn eq(&&other: @const T) -> bool { *self == *other }
+}
+
+impl<T:Ord> @const T : Ord {
+    pure fn lt(&&other: @const T) -> bool { *self < *other }
+}
+
 #[test]
 fn test() {
     let x = @3;

src/libcore/char.rs

@@ -4,6 +4,8 @@
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
+import cmp::Eq;
+
 /*
     Lu  Uppercase_Letter    an uppercase letter
     Ll  Lowercase_Letter    a lowercase letter
@@ -187,6 +189,10 @@ pure fn cmp(a: char, b: char) -> int {
     else { 0 }
 }
 
+impl char: Eq {
+    pure fn eq(&&other: char) -> bool { self == other }
+}
+
 #[test]
 fn test_is_lowercase() {
     assert is_lowercase('a');

src/libcore/cmp.rs

@@ -28,13 +28,13 @@ trait Eq {
 }
 
 pure fn lt<T: Ord>(v1: &T, v2: &T) -> bool {
-    v1.lt(*v2)
+    v1.lt(v2)
 }
 
 pure fn le<T: Ord Eq>(v1: &T, v2: &T) -> bool {
-    v1.lt(*v2) || v1.eq(*v2)
+    v1.lt(v2) || v1.eq(v2)
 }
 
 pure fn eq<T: Eq>(v1: &T, v2: &T) -> bool {
-    v1.eq(*v2)
+    v1.eq(v2)
 }

src/libcore/core.rc

@@ -57,6 +57,8 @@ export num;
 export path;
 export managed;
 export flate;
+export unit;
+export uniq;
 
 // NDM seems to be necessary for resolve to work
 export option_iter;
@@ -183,6 +185,10 @@ mod at_vec;
 mod bool;
 #[warn(non_camel_case_types)]
 mod tuple;
+#[warn(non_camel_case_types)]
+mod unit;
+#[warn(non_camel_case_types)]
+mod uniq;
 
 // Ubiquitous-utility-type modules
 

src/libcore/core.rs

@@ -18,8 +18,9 @@ import PosixPath = path::PosixPath;
 import tuple::{TupleOps, ExtendedTupleOps};
 import str::{StrSlice, UniqueStr};
 import vec::{ConstVector, CopyableVector, ImmutableVector};
-import vec::{ImmutableCopyableVector};
-import iter::{BaseIter, ExtendedIter, CopyableIter, Times, TimesIx};
+import vec::{ImmutableEqVector, ImmutableCopyableVector};
+import iter::{BaseIter, ExtendedIter, EqIter, CopyableIter};
+import iter::{CopyableOrderedIter, Times, TimesIx};
 import num::Num;
 import ptr::Ptr;
 import to_str::ToStr;
@@ -33,8 +34,8 @@ export Num, Times, TimesIx;
 // The following exports are the common traits
 export StrSlice, UniqueStr;
 export ConstVector, CopyableVector, ImmutableVector;
-export ImmutableCopyableVector, IterTraitExtensions;
-export BaseIter, CopyableIter, ExtendedIter;
+export ImmutableEqVector, ImmutableCopyableVector, IterTraitExtensions;
+export BaseIter, CopyableIter, CopyableOrderedIter, ExtendedIter, EqIter;
 export TupleOps, ExtendedTupleOps;
 export Ptr;
 export ToStr;

src/libcore/either.rs

@@ -4,6 +4,7 @@
 
 //! A type that represents one of two alternatives
 
+import cmp::Eq;
 import result::Result;
 
 /// The either type
@@ -125,6 +126,25 @@ pure fn unwrap_right<T,U>(+eith: Either<T,U>) -> U {
     }
 }
 
+impl<T:Eq,U:Eq> Either<T,U> : Eq {
+    pure fn eq(&&other: Either<T,U>) -> bool {
+        match self {
+            Left(a) => {
+                match other {
+                    Left(b) => a.eq(b),
+                    Right(_) => false
+                }
+            }
+            Right(a) => {
+                match other {
+                    Left(_) => false,
+                    Right(b) => a.eq(b)
+                }
+            }
+        }
+    }
+}
+
 #[test]
 fn test_either_left() {
     let val = Left(10);

src/libcore/extfmt.rs

@@ -25,6 +25,7 @@ debug!("hello, %s!", "world");
 
 */
 
+import cmp::Eq;
 import option::{Some, None};
 
 
@@ -383,7 +384,24 @@ mod rt {
               count_implied => 1u
             };
     }
+
     enum pad_mode { pad_signed, pad_unsigned, pad_nozero, pad_float }
+
+    impl pad_mode: Eq {
+        pure fn eq(&&other: pad_mode) -> bool {
+            match (self, other) {
+                (pad_signed, pad_signed) => true,
+                (pad_unsigned, pad_unsigned) => true,
+                (pad_nozero, pad_nozero) => true,
+                (pad_float, pad_float) => true,
+                (pad_signed, _) => false,
+                (pad_unsigned, _) => false,
+                (pad_nozero, _) => false,
+                (pad_float, _) => false
+            }
+        }
+    }
+
     fn pad(cv: conv, &s: ~str, mode: pad_mode) -> ~str {
         let uwidth : uint = match cv.width {
           count_implied => return s,

src/libcore/float.rs

@@ -41,6 +41,7 @@ import f64::{lgamma, ln, log_radix, ln1p, log10, log2, ilog_radix};
 import f64::{modf, pow, round, sinh, tanh, tgamma, trunc};
 import f64::signbit;
 import f64::{j0, j1, jn, y0, y1, yn};
+import cmp::{Eq, Ord};
 import num::from_int;
 
 const NaN: float = 0.0/0.0;
@@ -311,7 +312,7 @@ fn from_str(num: &str) -> Option<float> {
       }
    }
 
-   if (c == 'e') | (c == 'E') {//Examine exponent
+   if (c == 'e') || (c == 'E') { //Examine exponent
       let mut exponent = 0u;
       let mut neg_exponent = false;
       if(pos < len) {
@@ -414,6 +415,14 @@ pure fn sin(x: float) -> float { f64::sin(x as f64) as float }
 pure fn cos(x: float) -> float { f64::cos(x as f64) as float }
 pure fn tan(x: float) -> float { f64::tan(x as f64) as float }
 
+impl float: Eq {
+    pure fn eq(&&other: float) -> bool { self == other }
+}
+
+impl float: Ord {
+    pure fn lt(&&other: float) -> bool { self < other }
+}
+
 impl float: num::Num {
     pure fn add(&&other: float)    -> float { return self + other; }
     pure fn sub(&&other: float)    -> float { return self - other; }
@@ -521,7 +530,7 @@ fn test_to_str_inf() {
 
 #[test]
 fn test_traits() {
-    fn test<U:num::Num>(ten: &U) {
+    fn test<U:num::Num cmp::Eq>(ten: &U) {
         assert (ten.to_int() == 10);
 
         let two: U = from_int(2);

src/libcore/int-template.rs

@@ -239,7 +239,7 @@ fn test_to_str() {
 
 #[test]
 fn test_interfaces() {
-    fn test<U:num::Num>(+ten: U) {
+    fn test<U:num::Num cmp::Eq>(+ten: U) {
         assert (ten.to_int() == 10);
 
         let two: U = from_int(2);

src/libcore/io.rs

@@ -6,6 +6,7 @@ Basic input/output
 
 import result::Result;
 
+import cmp::Eq;
 import dvec::DVec;
 import libc::{c_int, c_long, c_uint, c_void, size_t, ssize_t};
 import libc::consts::os::posix88::*;
@@ -324,6 +325,15 @@ enum FileFlag { Append, Create, Truncate, NoFlag, }
 // What type of writer are we?
 enum WriterType { Screen, File }
 
+impl WriterType: Eq {
+    pure fn eq(&&other: WriterType) -> bool {
+        match (self, other) {
+            (Screen, Screen) | (File, File) => true,
+            (Screen, _) | (File, _) => false
+        }
+    }
+}
+
 // FIXME (#2004): Seekable really should be orthogonal.
 // FIXME (#2004): eventually u64
 trait Writer {

src/libcore/iter-trait.rs

@@ -2,6 +2,7 @@
 // workaround our lack of traits and lack of macros.  See core.{rc,rs} for
 // how this file is used.
 
+import cmp::{Eq, Ord};
 import inst::{IMPL_T, EACH, SIZE_HINT};
 export extensions;
 
@@ -17,6 +18,9 @@ impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
     pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B {
         iter::foldl(self, b0, blk)
     }
+}
+
+impl<A: Eq> IMPL_T<A>: iter::EqIter<A> {
     pure fn contains(x: A) -> bool { iter::contains(self, x) }
     pure fn count(x: A) -> uint { iter::count(self, x) }
     pure fn position(f: fn(A) -> bool) -> Option<uint> {
@@ -38,7 +42,11 @@ impl<A: copy> IMPL_T<A>: iter::CopyableIter<A> {
     //     iter::flat_map_to_vec(self, op)
     // }
 
+    pure fn find(p: fn(A) -> bool) -> Option<A> { iter::find(self, p) }
+}
+
+impl<A: copy Ord> IMPL_T<A>: iter::CopyableOrderedIter<A> {
     pure fn min() -> A { iter::min(self) }
     pure fn max() -> A { iter::max(self) }
-    pure fn find(p: fn(A) -> bool) -> Option<A> { iter::find(self, p) }
 }
+