mathieu/granite-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

std: Rename {Eq,Ord} to Partial{Eq,Ord}

Browse source 
This is part of the ongoing renaming of the equality traits. See #12517 for more
details. All code using Eq/Ord will temporarily need to move to Partial{Eq,Ord}
or the Total{Eq,Ord} traits. The Total traits will soon be renamed to {Eq,Ord}.

cc #12517

[breaking-change]
This commit is contained in:
Alex Crichton 2014-05-29 17:45:07 -07:00
parent f4fa7c8a07
commit 748bc3ca49
256 changed files with 834 additions and 831 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/compiletest/common.rs
View file

@ -12,7 +12,7 @@ use std::from_str::FromStr;
use std::fmt;
use regex::Regex;
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub enum Mode {
CompileFail,
RunFail,

26
src/doc/rust.md
View file

@ -1436,7 +1436,7 @@ trait Circle : Shape { fn radius() -> f64; }
~~~~
the syntax `Circle : Shape` means that types that implement `Circle` must also have an implementation for `Shape`.
Multiple supertraits are separated by `+`, `trait Circle : Shape + Eq { }`.
Multiple supertraits are separated by `+`, `trait Circle : Shape + PartialEq { }`.
In an implementation of `Circle` for a given type `T`, methods can refer to `Shape` methods,
since the typechecker checks that any type with an implementation of `Circle` also has an implementation of `Shape`.
@ -2159,23 +2159,23 @@ There are three different types of inline attributes:
The `deriving` attribute allows certain traits to be automatically
implemented for data structures. For example, the following will
create an `impl` for the `Eq` and `Clone` traits for `Foo`, the type
parameter `T` will be given the `Eq` or `Clone` constraints for the
create an `impl` for the `PartialEq` and `Clone` traits for `Foo`, the type
parameter `T` will be given the `PartialEq` or `Clone` constraints for the
appropriate `impl`:
~~~~
#[deriving(Eq, Clone)]
#[deriving(PartialEq, Clone)]
struct Foo<T> {
a: int,
b: T
}
~~~~
The generated `impl` for `Eq` is equivalent to
The generated `impl` for `PartialEq` is equivalent to
~~~~
# struct Foo<T> { a: int, b: T }
impl<T: Eq> Eq for Foo<T> {
impl<T: PartialEq> PartialEq for Foo<T> {
fn eq(&self, other: &Foo<T>) -> bool {
self.a == other.a && self.b == other.b
}
@ -2188,7 +2188,7 @@ impl<T: Eq> Eq for Foo<T> {
Supported traits for `deriving` are:
* Comparison traits: `Eq`, `TotalEq`, `Ord`, `TotalOrd`.
* Comparison traits: `PartialEq`, `TotalEq`, `PartialOrd`, `TotalOrd`.
* Serialization: `Encodable`, `Decodable`. These require `serialize`.
* `Clone`, to create `T` from `&T` via a copy.
* `Hash`, to iterate over the bytes in a data type.
@ -2734,22 +2734,22 @@ The default meaning of the operators on standard types is given here.
* `==`
: Equal to.
Calls the `eq` method on the `std::cmp::Eq` trait.
Calls the `eq` method on the `std::cmp::PartialEq` trait.
* `!=`
: Unequal to.
Calls the `ne` method on the `std::cmp::Eq` trait.
Calls the `ne` method on the `std::cmp::PartialEq` trait.
* `<`
: Less than.
Calls the `lt` method on the `std::cmp::Ord` trait.
Calls the `lt` method on the `std::cmp::PartialOrd` trait.
* `>`
: Greater than.
Calls the `gt` method on the `std::cmp::Ord` trait.
Calls the `gt` method on the `std::cmp::PartialOrd` trait.
* `<=`
: Less than or equal.
Calls the `le` method on the `std::cmp::Ord` trait.
Calls the `le` method on the `std::cmp::PartialOrd` trait.
* `>=`
: Greater than or equal.
Calls the `ge` method on the `std::cmp::Ord` trait.
Calls the `ge` method on the `std::cmp::PartialOrd` trait.
#### Type cast expressions

30
src/doc/tutorial.md
View file

@ -61,7 +61,7 @@ There are two ways to install the Rust compiler: by building from source or
by downloading prebuilt binaries or installers for your platform. The
[install page][rust-install] contains links to download binaries for both
the nightly build and the most current Rust major release. For Windows and
OS X, the install page provides links to native installers.
OS X, the install page provides links to native installers.
> *Note:* Windows users should read the detailed
> [Getting started][wiki-start] notes on the wiki. Even when using
@ -69,8 +69,8 @@ OS X, the install page provides links to native installers.
> the precise details of which are not discussed here.
For Linux and OS X, the install page provides links to binary tarballs.
To install the Rust compiler from the from a binary tarball, download
the binary package, extract it, and execute the `install.sh` script in
To install the Rust compiler from the from a binary tarball, download
the binary package, extract it, and execute the `install.sh` script in
the root directory of the package.
To build the Rust compiler from source, you will need to obtain the source through
@ -1303,7 +1303,7 @@ be specified up-front. Our previous definition of list equality relied on the el
the `==` operator available, and took advantage of the lack of a destructor on `u32` to copy it
without a move of ownership.
We can add a *trait bound* on the `Eq` trait to require that the type implement the `==` operator.
We can add a *trait bound* on the `PartialEq` trait to require that the type implement the `==` operator.
Two more `ref` annotations need to be added to avoid attempting to move out the element types:
~~~
@ -1311,7 +1311,7 @@ Two more `ref` annotations need to be added to avoid attempting to move out the
# Cons(T, Box<List<T>>),
# Nil
# }
fn eq<T: Eq>(xs: &List<T>, ys: &List<T>) -> bool {
fn eq<T: PartialEq>(xs: &List<T>, ys: &List<T>) -> bool {
// Match on the next node in both lists.
match (xs, ys) {
// If we have reached the end of both lists, they are equal.
@ -1329,8 +1329,8 @@ let ys = Cons('c', box Cons('a', box Cons('t', box Nil)));
assert!(eq(&xs, &ys));
~~~
This would be a good opportunity to implement the `Eq` trait for our list type, making the `==` and
`!=` operators available. We'll need to provide an `impl` for the `Eq` trait and a definition of the
This would be a good opportunity to implement the `PartialEq` trait for our list type, making the `==` and
`!=` operators available. We'll need to provide an `impl` for the `PartialEq` trait and a definition of the
`eq` method. In a method, the `self` parameter refers to an instance of the type we're implementing
on.
@ -1339,7 +1339,7 @@ on.
# Cons(T, Box<List<T>>),
# Nil
# }
impl<T: Eq> Eq for List<T> {
impl<T: PartialEq> PartialEq for List<T> {
fn eq(&self, ys: &List<T>) -> bool {
// Match on the next node in both lists.
match (self, ys) {
@ -1356,12 +1356,12 @@ impl<T: Eq> Eq for List<T> {
let xs = Cons(5, box Cons(10, box Nil));
let ys = Cons(5, box Cons(10, box Nil));
// The methods below are part of the Eq trait,
// The methods below are part of the PartialEq trait,
// which we implemented on our linked list.
assert!(xs.eq(&ys));
assert!(!xs.ne(&ys));
// The Eq trait also allows us to use the shorthand infix operators.
// The PartialEq trait also allows us to use the shorthand infix operators.
assert!(xs == ys); // `xs == ys` is short for `xs.eq(&ys)`
assert!(!(xs != ys)); // `xs != ys` is short for `xs.ne(&ys)`
~~~
@ -2345,12 +2345,12 @@ trait describes types that support an equality operation:
~~~~
// In a trait, `self` refers to the self argument.
// `Self` refers to the type implementing the trait.
trait Eq {
trait PartialEq {
fn equals(&self, other: &Self) -> bool;
}
// In an impl, `self` refers just to the value of the receiver
impl Eq for int {
impl PartialEq for int {
fn equals(&self, other: &int) -> bool { *other == *self }
}
~~~~
@ -2600,13 +2600,13 @@ A small number of traits in `std` and `extra` can have implementations
that can be automatically derived. These instances are specified by
placing the `deriving` attribute on a data type declaration. For
example, the following will mean that `Circle` has an implementation
for `Eq` and can be used with the equality operators, and that a value
for `PartialEq` and can be used with the equality operators, and that a value
of type `ABC` can be randomly generated and converted to a string:
~~~
extern crate rand;
#[deriving(Eq)]
#[deriving(PartialEq)]
struct Circle { radius: f64 }
#[deriving(Rand, Show)]
@ -2618,7 +2618,7 @@ fn main() {
}
~~~
The full list of derivable traits is `Eq`, `TotalEq`, `Ord`,
The full list of derivable traits is `PartialEq`, `TotalEq`, `Ord`,
`TotalOrd`, `Encodable`, `Decodable`, `Clone`,
`Hash`, `Rand`, `Default`, `Zero`, `FromPrimitive` and `Show`.

8
src/etc/generate-deriving-span-tests.py
View file

@ -35,7 +35,7 @@ TEMPLATE = """// Copyright {year} The Rust Project Developers. See the COPYRIGHT
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// This file was auto-generated using 'src/etc/generate-keyword-span-tests.py'
// This file was auto-generated using 'src/etc/generate-deriving-span-tests.py'
#![feature(struct_variant)]
extern crate rand;
@ -117,8 +117,10 @@ traits = {
for (trait, supers, errs) in [('Rand', [], 1),
('Clone', [], 1),
('Eq', [], 2), ('Ord', [], 8),
('TotalEq', [], 1), ('TotalOrd', ['TotalEq'], 1),
('PartialEq', [], 2),
('PartialOrd', ['PartialEq'], 8),
('TotalEq', ['PartialEq'], 1),
('TotalOrd', ['TotalEq', 'PartialOrd', 'PartialEq'], 1),
('Show', [], 1),
('Hash', [], 1)]:
traits[trait] = (ALL, supers, errs)

6
src/liballoc/owned.rs
View file

@ -12,7 +12,7 @@
use core::any::{Any, AnyRefExt};
use core::clone::Clone;
use core::cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering};
use core::cmp::{PartialEq, PartialOrd, TotalEq, TotalOrd, Ordering};
use core::default::Default;
use core::fmt;
use core::intrinsics;
@ -51,13 +51,13 @@ impl<T: Clone> Clone for Box<T> {
}
// box pointers
impl<T:Eq> Eq for Box<T> {
impl<T:PartialEq> PartialEq for Box<T> {
#[inline]
fn eq(&self, other: &Box<T>) -> bool { *(*self) == *(*other) }
#[inline]
fn ne(&self, other: &Box<T>) -> bool { *(*self) != *(*other) }
}
impl<T:Ord> Ord for Box<T> {
impl<T:PartialOrd> PartialOrd for Box<T> {
#[inline]
fn lt(&self, other: &Box<T>) -> bool { *(*self) < *(*other) }
#[inline]

6
src/liballoc/rc.rs
View file

@ -26,7 +26,7 @@ pointers, and then storing the parent pointers as `Weak` pointers.
use core::mem::transmute;
use core::cell::Cell;
use core::clone::Clone;
use core::cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering};
use core::cmp::{PartialEq, PartialOrd, TotalEq, TotalOrd, Ordering};
use core::kinds::marker;
use core::ops::{Deref, Drop};
use core::option::{Option, Some, None};
@ -150,7 +150,7 @@ impl<T> Clone for Rc<T> {
}
}
impl<T: Eq> Eq for Rc<T> {
impl<T: PartialEq> PartialEq for Rc<T> {
#[inline(always)]
fn eq(&self, other: &Rc<T>) -> bool { **self == **other }
#[inline(always)]
@ -159,7 +159,7 @@ impl<T: Eq> Eq for Rc<T> {
impl<T: TotalEq> TotalEq for Rc<T> {}
impl<T: Ord> Ord for Rc<T> {
impl<T: PartialOrd> PartialOrd for Rc<T> {
#[inline(always)]
fn lt(&self, other: &Rc<T>) -> bool { **self < **other }

2
src/libarena/lib.rs
View file

@ -43,7 +43,7 @@ use std::rt::heap::allocate;
// The way arena uses arrays is really deeply awful. The arrays are
// allocated, and have capacities reserved, but the fill for the array
// will always stay at 0.
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
struct Chunk {
data: Rc<RefCell<Vec<u8> >>,
fill: Cell<uint>,

2
src/libcollections/bitv.rs
View file

@ -796,7 +796,7 @@ impl BitvSet {
}
}
impl cmp::Eq for BitvSet {
impl cmp::PartialEq for BitvSet {
fn eq(&self, other: &BitvSet) -> bool {
if self.size != other.size {
return false;

24
src/libcollections/btree.rs
View file

@ -92,7 +92,7 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for BTree<K, V> {
}
}
impl<K: TotalOrd, V: TotalEq> Eq for BTree<K, V> {
impl<K: TotalOrd, V: TotalEq> PartialEq for BTree<K, V> {
fn eq(&self, other: &BTree<K, V>) -> bool {
self.root.cmp(&other.root) == Equal
}
@ -100,7 +100,7 @@ impl<K: TotalOrd, V: TotalEq> Eq for BTree<K, V> {
impl<K: TotalOrd, V: TotalEq> TotalEq for BTree<K, V> {}
impl<K: TotalOrd, V: TotalEq> Ord for BTree<K, V> {
impl<K: TotalOrd, V: TotalEq> PartialOrd for BTree<K, V> {
fn lt(&self, other: &BTree<K, V>) -> bool {
self.cmp(other) == Less
}
@ -198,7 +198,7 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for Node<K, V> {
}
}
impl<K: TotalOrd, V: TotalEq> Eq for Node<K, V> {
impl<K: TotalOrd, V: TotalEq> PartialEq for Node<K, V> {
fn eq(&self, other: &Node<K, V>) -> bool {
match *self{
BranchNode(ref branch) => {
@ -222,7 +222,7 @@ impl<K: TotalOrd, V: TotalEq> Eq for Node<K, V> {
impl<K: TotalOrd, V: TotalEq> TotalEq for Node<K, V> {}
impl<K: TotalOrd, V: TotalEq> Ord for Node<K, V> {
impl<K: TotalOrd, V: TotalEq> PartialOrd for Node<K, V> {
fn lt(&self, other: &Node<K, V>) -> bool {
self.cmp(other) == Less
}
@ -393,7 +393,7 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for Leaf<K, V> {
}
}
impl<K: TotalOrd, V: TotalEq> Eq for Leaf<K, V> {
impl<K: TotalOrd, V: TotalEq> PartialEq for Leaf<K, V> {
fn eq(&self, other: &Leaf<K, V>) -> bool {
self.elts == other.elts
}
@ -401,7 +401,7 @@ impl<K: TotalOrd, V: TotalEq> Eq for Leaf<K, V> {
impl<K: TotalOrd, V: TotalEq> TotalEq for Leaf<K, V> {}
impl<K: TotalOrd, V: TotalEq> Ord for Leaf<K, V> {
impl<K: TotalOrd, V: TotalEq> PartialOrd for Leaf<K, V> {
fn lt(&self, other: &Leaf<K, V>) -> bool {
self.cmp(other) == Less
}
@ -623,7 +623,7 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for Branch<K, V> {
}
}
impl<K: TotalOrd, V: TotalEq> Eq for Branch<K, V> {
impl<K: TotalOrd, V: TotalEq> PartialEq for Branch<K, V> {
fn eq(&self, other: &Branch<K, V>) -> bool {
self.elts == other.elts
}
@ -631,7 +631,7 @@ impl<K: TotalOrd, V: TotalEq> Eq for Branch<K, V> {
impl<K: TotalOrd, V: TotalEq> TotalEq for Branch<K, V> {}
impl<K: TotalOrd, V: TotalEq> Ord for Branch<K, V> {
impl<K: TotalOrd, V: TotalEq> PartialOrd for Branch<K, V> {
fn lt(&self, other: &Branch<K, V>) -> bool {
self.cmp(other) == Less
}
@ -691,7 +691,7 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for LeafElt<K, V> {
}
}
impl<K: TotalOrd, V: TotalEq> Eq for LeafElt<K, V> {
impl<K: TotalOrd, V: TotalEq> PartialEq for LeafElt<K, V> {
fn eq(&self, other: &LeafElt<K, V>) -> bool {
self.key == other.key && self.value == other.value
}
@ -699,7 +699,7 @@ impl<K: TotalOrd, V: TotalEq> Eq for LeafElt<K, V> {
impl<K: TotalOrd, V: TotalEq> TotalEq for LeafElt<K, V> {}
impl<K: TotalOrd, V: TotalEq> Ord for LeafElt<K, V> {
impl<K: TotalOrd, V: TotalEq> PartialOrd for LeafElt<K, V> {
fn lt(&self, other: &LeafElt<K, V>) -> bool {
self.cmp(other) == Less
}
@ -740,7 +740,7 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for BranchElt<K, V> {
}
}
impl<K: TotalOrd, V: TotalEq> Eq for BranchElt<K, V>{
impl<K: TotalOrd, V: TotalEq> PartialEq for BranchElt<K, V>{
fn eq(&self, other: &BranchElt<K, V>) -> bool {
self.key == other.key && self.value == other.value
}
@ -748,7 +748,7 @@ impl<K: TotalOrd, V: TotalEq> Eq for BranchElt<K, V>{
impl<K: TotalOrd, V: TotalEq> TotalEq for BranchElt<K, V>{}
impl<K: TotalOrd, V: TotalEq> Ord for BranchElt<K, V> {
impl<K: TotalOrd, V: TotalEq> PartialOrd for BranchElt<K, V> {
fn lt(&self, other: &BranchElt<K, V>) -> bool {
self.cmp(other) == Less
}

4
src/libcollections/dlist.rs
View file

@ -572,7 +572,7 @@ impl<A> Extendable<A> for DList<A> {
}
}
impl<A: Eq> Eq for DList<A> {
impl<A: PartialEq> PartialEq for DList<A> {
fn eq(&self, other: &DList<A>) -> bool {
self.len() == other.len() &&
iter::order::eq(self.iter(), other.iter())
@ -584,7 +584,7 @@ impl<A: Eq> Eq for DList<A> {
}
}
impl<A: Ord> Ord for DList<A> {
impl<A: PartialOrd> PartialOrd for DList<A> {
fn lt(&self, other: &DList<A>) -> bool {
iter::order::lt(self.iter(), other.iter())
}

4
src/libcollections/enum_set.rs
View file

@ -15,7 +15,7 @@
use std::num::Bitwise;
#[deriving(Clone, Eq, TotalEq, Hash, Show)]
#[deriving(Clone, PartialEq, TotalEq, Hash, Show)]
/// A specialized Set implementation to use enum types.
pub struct EnumSet<E> {
// We must maintain the invariant that no bits are set
@ -141,7 +141,7 @@ mod test {
use enum_set::{EnumSet, CLike};
#[deriving(Eq, Show)]
#[deriving(PartialEq, Show)]
#[repr(uint)]
enum Foo {
A, B, C

18
src/libcollections/hashmap.rs
View file

@ -12,7 +12,7 @@
use std::container::{Container, Mutable, Map, MutableMap, Set, MutableSet};
use std::clone::Clone;
use std::cmp::{Eq, TotalEq, Equiv, max};
use std::cmp::{PartialEq, TotalEq, Equiv, max};
use std::default::Default;
use std::fmt;
use std::fmt::Show;
@ -32,7 +32,7 @@ use std::slice::ImmutableVector;
mod table {
use std::clone::Clone;
use std::cmp;
use std::cmp::Eq;
use std::cmp::PartialEq;
use std::hash::{Hash, Hasher};
use std::kinds::marker;
use std::num::{CheckedMul, is_power_of_two};
@ -145,7 +145,7 @@ mod table {
/// A hash that is not zero, since we use a hash of zero to represent empty
/// buckets.
#[deriving(Eq)]
#[deriving(PartialEq)]
pub struct SafeHash {
hash: u64,
}
@ -661,8 +661,8 @@ static INITIAL_LOAD_FACTOR: Fraction = (9, 10);
/// denial-of-service attacks (Hash DoS). This behaviour can be
/// overridden with one of the constructors.
///
/// It is required that the keys implement the `Eq` and `Hash` traits, although
/// this can frequently be achieved by using `#[deriving(Eq, Hash)]`.
/// It is required that the keys implement the `PartialEq` and `Hash` traits, although
/// this can frequently be achieved by using `#[deriving(PartialEq, Hash)]`.
///
/// Relevant papers/articles:
///
@ -1402,7 +1402,7 @@ impl<K: TotalEq + Hash<S>, V: Clone, S, H: Hasher<S>> HashMap<K, V, H> {
}
}
impl<K: TotalEq + Hash<S>, V: Eq, S, H: Hasher<S>> Eq for HashMap<K, V, H> {
impl<K: TotalEq + Hash<S>, V: PartialEq, S, H: Hasher<S>> PartialEq for HashMap<K, V, H> {
fn eq(&self, other: &HashMap<K, V, H>) -> bool {
if self.len() != other.len() { return false; }
@ -1480,13 +1480,13 @@ pub type SetMoveItems<K> =
/// An implementation of a hash set using the underlying representation of a
/// HashMap where the value is (). As with the `HashMap` type, a `HashSet`
/// requires that the elements implement the `Eq` and `Hash` traits.
/// requires that the elements implement the `PartialEq` and `Hash` traits.
#[deriving(Clone)]
pub struct HashSet<T, H = sip::SipHasher> {
map: HashMap<T, (), H>
}
impl<T: TotalEq + Hash<S>, S, H: Hasher<S>> Eq for HashSet<T, H> {
impl<T: TotalEq + Hash<S>, S, H: Hasher<S>> PartialEq for HashSet<T, H> {
fn eq(&self, other: &HashSet<T, H>) -> bool {
if self.len() != other.len() { return false; }
@ -1691,7 +1691,7 @@ mod test_map {
local_data_key!(drop_vector: RefCell<Vec<int>>)
#[deriving(Hash, Eq, TotalEq)]
#[deriving(Hash, PartialEq, TotalEq)]
struct Dropable {
k: uint
}

4
src/libcollections/lru_cache.rs
View file

@ -67,7 +67,7 @@ impl<S, K: Hash<S>> Hash<S> for KeyRef<K> {
}
}
impl<K: Eq> Eq for KeyRef<K> {
impl<K: PartialEq> PartialEq for KeyRef<K> {
fn eq(&self, other: &KeyRef<K>) -> bool {
unsafe{ (*self.k).eq(&*other.k) }
}
@ -253,7 +253,7 @@ impl<K, V> Drop for LruCache<K, V> {
mod tests {
use super::LruCache;
fn assert_opt_eq<V: Eq>(opt: Option<&V>, v: V) {
fn assert_opt_eq<V: PartialEq>(opt: Option<&V>, v: V) {
assert!(opt.is_some());
assert!(opt.unwrap() == &v);
}

12
src/libcollections/ringbuf.rs
View file

@ -364,7 +364,7 @@ fn raw_index(lo: uint, len: uint, index: uint) -> uint {
}
}
impl<A: Eq> Eq for RingBuf<A> {
impl<A: PartialEq> PartialEq for RingBuf<A> {
fn eq(&self, other: &RingBuf<A>) -> bool {
self.nelts == other.nelts &&
self.iter().zip(other.iter()).all(|(a, b)| a.eq(b))
@ -397,7 +397,7 @@ mod tests {
use self::test::Bencher;
use deque::Deque;
use std::clone::Clone;
use std::cmp::Eq;
use std::cmp::PartialEq;
use std::fmt::Show;
use super::RingBuf;
@ -483,7 +483,7 @@ mod tests {
}
#[cfg(test)]
fn test_parameterized<T:Clone + Eq + Show>(a: T, b: T, c: T, d: T) {
fn test_parameterized<T:Clone + PartialEq + Show>(a: T, b: T, c: T, d: T) {
let mut deq = RingBuf::new();
assert_eq!(deq.len(), 0);
deq.push_front(a.clone());
@ -568,21 +568,21 @@ mod tests {
})
}
#[deriving(Clone, Eq, Show)]
#[deriving(Clone, PartialEq, Show)]
enum Taggy {
One(int),
Two(int, int),
Three(int, int, int),
}
#[deriving(Clone, Eq, Show)]
#[deriving(Clone, PartialEq, Show)]
enum Taggypar<T> {
Onepar(int),
Twopar(int, int),
Threepar(int, int, int),
}
#[deriving(Clone, Eq, Show)]
#[deriving(Clone, PartialEq, Show)]
struct RecCy {
x: int,
y: int,

12
src/libcollections/treemap.rs
View file

@ -43,7 +43,7 @@ pub struct TreeMap<K, V> {
length: uint
}
impl<K: Eq + TotalOrd, V: Eq> Eq for TreeMap<K, V> {
impl<K: PartialEq + TotalOrd, V: PartialEq> PartialEq for TreeMap<K, V> {
fn eq(&self, other: &TreeMap<K, V>) -> bool {
self.len() == other.len() &&
self.iter().zip(other.iter()).all(|(a, b)| a == b)
@ -51,7 +51,7 @@ impl<K: Eq + TotalOrd, V: Eq> Eq for TreeMap<K, V> {
}
// Lexicographical comparison
fn lt<K: Ord + TotalOrd, V: Ord>(a: &TreeMap<K, V>,
fn lt<K: PartialOrd + TotalOrd, V: PartialOrd>(a: &TreeMap<K, V>,
b: &TreeMap<K, V>) -> bool {
// the Zip iterator is as long as the shortest of a and b.
for ((key_a, value_a), (key_b, value_b)) in a.iter().zip(b.iter()) {
@ -64,7 +64,7 @@ fn lt<K: Ord + TotalOrd, V: Ord>(a: &TreeMap<K, V>,
a.len() < b.len()
}
impl<K: Ord + TotalOrd, V: Ord> Ord for TreeMap<K, V> {
impl<K: PartialOrd + TotalOrd, V: PartialOrd> PartialOrd for TreeMap<K, V> {
#[inline]
fn lt(&self, other: &TreeMap<K, V>) -> bool { lt(self, other) }
}
@ -552,12 +552,12 @@ pub struct TreeSet<T> {
map: TreeMap<T, ()>
}
impl<T: Eq + TotalOrd> Eq for TreeSet<T> {
impl<T: PartialEq + TotalOrd> PartialEq for TreeSet<T> {
#[inline]
fn eq(&self, other: &TreeSet<T>) -> bool { self.map == other.map }
}
impl<T: Ord + TotalOrd> Ord for TreeSet<T> {
impl<T: PartialOrd + TotalOrd> PartialOrd for TreeSet<T> {
#[inline]
fn lt(&self, other: &TreeSet<T>) -> bool { self.map < other.map }
}
@ -1070,7 +1070,7 @@ mod test_treemap {
assert_eq!(m.find(&k1), Some(&v1));
}
fn check_equal<K: Eq + TotalOrd, V: Eq>(ctrl: &[(K, V)],
fn check_equal<K: PartialEq + TotalOrd, V: PartialEq>(ctrl: &[(K, V)],
map: &TreeMap<K, V>) {
assert_eq!(ctrl.is_empty(), map.is_empty());
for x in ctrl.iter() {

2
src/libcore/any.rs
View file

@ -121,7 +121,7 @@ mod tests {
use realstd::owned::{Box, AnyOwnExt};
use realstd::str::Str;
#[deriving(Eq, Show)]
#[deriving(PartialEq, Show)]
struct Test;
static TEST: &'static str = "Test";

6
src/libcore/cell.rs
View file

@ -160,7 +160,7 @@
// FIXME: Relationship to Atomic types and RWLock
use clone::Clone;
use cmp::Eq;
use cmp::PartialEq;
use kinds::{marker, Copy};
use ops::{Deref, DerefMut, Drop};
use option::{None, Option, Some};
@ -202,7 +202,7 @@ impl<T:Copy> Clone for Cell<T> {
}
}
impl<T:Eq + Copy> Eq for Cell<T> {
impl<T:PartialEq + Copy> PartialEq for Cell<T> {
fn eq(&self, other: &Cell<T>) -> bool {
self.get() == other.get()
}
@ -308,7 +308,7 @@ impl<T: Clone> Clone for RefCell<T> {
}
}
impl<T: Eq> Eq for RefCell<T> {
impl<T: PartialEq> PartialEq for RefCell<T> {
fn eq(&self, other: &RefCell<T>) -> bool {
*self.borrow() == *other.borrow()
}

64
src/libcore/cmp.rs
View file

@ -8,14 +8,14 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//! Defines the `Ord` and `Eq` comparison traits.
//! Defines the `PartialOrd` and `PartialEq` comparison traits.
//!
//! This module defines both `Ord` and `Eq` traits which are used by the
//! This module defines both `PartialOrd` and `PartialEq` traits which are used by the
//! compiler to implement comparison operators. Rust programs may implement
//!`Ord` to overload the `<`, `<=`, `>`, and `>=` operators, and may implement
//! `Eq` to overload the `==` and `!=` operators.
//!`PartialOrd` to overload the `<`, `<=`, `>`, and `>=` operators, and may implement
//! `PartialEq` to overload the `==` and `!=` operators.
//!
//! For example, to define a type with a customized definition for the Eq
//! For example, to define a type with a customized definition for the PartialEq
//! operators, you could do the following:
//!
//! ```rust
@ -24,8 +24,8 @@
//! num : int
//! }
//!
//! // Our implementation of `Eq` to support `==` and `!=`.
//! impl Eq for SketchyNum {
//! // Our implementation of `PartialEq` to support `==` and `!=`.
//! impl PartialEq for SketchyNum {
//! // Our custom eq allows numbers which are near each other to be equal! :D
//! fn eq(&self, other: &SketchyNum) -> bool {
//! (self.num - other.num).abs() < 5
@ -37,9 +37,6 @@
//! assert!(SketchyNum {num: 25} != SketchyNum {num: 57});
//! ```
pub use PartialEq = cmp::Eq;
pub use PartialOrd = cmp::Ord;
/// Trait for values that can be compared for equality and inequality.
///
/// This trait allows partial equality, where types can be unordered instead of
@ -47,13 +44,13 @@ pub use PartialOrd = cmp::Ord;
/// types `a == b` and `a != b` will both evaluate to false if either `a` or
/// `b` is NaN (cf. IEEE 754-2008 section 5.11).
///
/// Eq only requires the `eq` method to be implemented; `ne` is its negation by
/// PartialEq only requires the `eq` method to be implemented; `ne` is its negation by
/// default.
///
/// Eventually, this will be implemented by default for types that implement
/// `TotalEq`.
#[lang="eq"]
pub trait Eq {
pub trait PartialEq {
/// This method tests for `self` and `other` values to be equal, and is used by `==`.
fn eq(&self, other: &Self) -> bool;
@ -71,7 +68,7 @@ pub trait Eq {
/// - reflexive: `a == a`;
/// - symmetric: `a == b` implies `b == a`; and
/// - transitive: `a == b` and `b == c` implies `a == c`.
pub trait TotalEq: Eq {
pub trait TotalEq: PartialEq {
// FIXME #13101: this method is used solely by #[deriving] to
// assert that every component of a type implements #[deriving]
// itself, the current deriving infrastructure means doing this
@ -85,7 +82,7 @@ pub trait TotalEq: Eq {
}
/// An ordering is, e.g, a result of a comparison between two values.
#[deriving(Clone, Eq, Show)]
#[deriving(Clone, PartialEq, Show)]
pub enum Ordering {
/// An ordering where a compared value is less [than another].
Less = -1,
@ -104,7 +101,7 @@ pub enum Ordering {
/// true; and
/// - transitive, `a < b` and `b < c` implies `a < c`. The same must hold for
/// both `==` and `>`.
pub trait TotalOrd: TotalEq + Ord {
pub trait TotalOrd: TotalEq + PartialOrd {
/// This method returns an ordering between `self` and `other` values.
///
/// By convention, `self.cmp(&other)` returns the ordering matching
@ -127,7 +124,7 @@ impl TotalOrd for Ordering {
}
}
impl Ord for Ordering {
impl PartialOrd for Ordering {
#[inline]
fn lt(&self, other: &Ordering) -> bool { (*self as int) < (*other as int) }
}
@ -147,14 +144,14 @@ pub fn lexical_ordering(o1: Ordering, o2: Ordering) -> Ordering {
/// Trait for values that can be compared for a sort-order.
///
/// Ord only requires implementation of the `lt` method,
/// PartialOrd only requires implementation of the `lt` method,
/// with the others generated from default implementations.
///
/// However it remains possible to implement the others separately,
/// for compatibility with floating-point NaN semantics
/// (cf. IEEE 754-2008 section 5.11).
#[lang="ord"]
pub trait Ord: Eq {
pub trait PartialOrd: PartialEq {
/// This method tests less than (for `self` and `other`) and is used by the `<` operator.
fn lt(&self, other: &Self) -> bool;
@ -192,14 +189,15 @@ pub fn max<T: TotalOrd>(v1: T, v2: T) -> T {
if v1 > v2 { v1 } else { v2 }
}
// Implementation of Eq, TotalEq, Ord and TotalOrd for primitive types
// Implementation of PartialEq, TotalEq, PartialOrd and TotalOrd for primitive types
#[cfg(not(test))]
mod impls {
use cmp::{Ord, TotalOrd, Eq, TotalEq, Ordering, Less, Greater, Equal};
use cmp::{PartialOrd, TotalOrd, PartialEq, TotalEq, Ordering,
Less, Greater, Equal};
macro_rules! eq_impl(
($($t:ty)*) => ($(
impl Eq for $t {
impl PartialEq for $t {
#[inline]
fn eq(&self, other: &$t) -> bool { (*self) == (*other) }
#[inline]
@ -208,7 +206,7 @@ mod impls {
)*)
)
impl Eq for () {
impl PartialEq for () {
#[inline]
fn eq(&self, _other: &()) -> bool { true }
#[inline]
@ -227,7 +225,7 @@ mod impls {
macro_rules! ord_impl(
($($t:ty)*) => ($(
impl Ord for $t {
impl PartialOrd for $t {
#[inline]
fn lt(&self, other: &$t) -> bool { (*self) < (*other) }
#[inline]
@ -240,12 +238,12 @@ mod impls {
)*)
)
impl Ord for () {
impl PartialOrd for () {
#[inline]
fn lt(&self, _other: &()) -> bool { false }
}
impl Ord for bool {
impl PartialOrd for bool {
#[inline]
fn lt(&self, other: &bool) -> bool {
(*self as u8) < (*other as u8)
@ -282,13 +280,13 @@ mod impls {
totalord_impl!(char uint u8 u16 u32 u64 int i8 i16 i32 i64)
// & pointers
impl<'a, T: Eq> Eq for &'a T {
impl<'a, T: PartialEq> PartialEq for &'a T {
#[inline]
fn eq(&self, other: & &'a T) -> bool { *(*self) == *(*other) }
#[inline]
fn ne(&self, other: & &'a T) -> bool { *(*self) != *(*other) }
}
impl<'a, T: Ord> Ord for &'a T {
impl<'a, T: PartialOrd> PartialOrd for &'a T {
#[inline]
fn lt(&self, other: & &'a T) -> bool { *(*self) < *(*other) }
#[inline]
@ -305,13 +303,13 @@ mod impls {
impl<'a, T: TotalEq> TotalEq for &'a T {}
// &mut pointers
impl<'a, T: Eq> Eq for &'a mut T {
impl<'a, T: PartialEq> PartialEq for &'a mut T {
#[inline]
fn eq(&self, other: &&'a mut T) -> bool { **self == *(*other) }
#[inline]
fn ne(&self, other: &&'a mut T) -> bool { **self != *(*other) }
}
impl<'a, T: Ord> Ord for &'a mut T {
impl<'a, T: PartialOrd> PartialOrd for &'a mut T {
#[inline]
fn lt(&self, other: &&'a mut T) -> bool { **self < **other }
#[inline]
@ -328,13 +326,13 @@ mod impls {
impl<'a, T: TotalEq> TotalEq for &'a mut T {}
// @ pointers
impl<T:Eq> Eq for @T {
impl<T:PartialEq> PartialEq for @T {
#[inline]
fn eq(&self, other: &@T) -> bool { *(*self) == *(*other) }
#[inline]
fn ne(&self, other: &@T) -> bool { *(*self) != *(*other) }
}
impl<T:Ord> Ord for @T {
impl<T:PartialOrd> PartialOrd for @T {
#[inline]
fn lt(&self, other: &@T) -> bool { *(*self) < *(*other) }
#[inline]
@ -400,8 +398,8 @@ mod test {
num : int
}
// Our implementation of `Eq` to support `==` and `!=`.
impl Eq for SketchyNum {
// Our implementation of `PartialEq` to support `==` and `!=`.
impl PartialEq for SketchyNum {
// Our custom eq allows numbers which are near each other to be equal! :D
fn eq(&self, other: &SketchyNum) -> bool {
(self.num - other.num).abs() < 5

12
src/libcore/fmt/num.rs
View file

@ -65,23 +65,23 @@ trait GenericRadix {
}
/// A binary (base 2) radix
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
struct Binary;
/// An octal (base 8) radix
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
struct Octal;
/// A decimal (base 10) radix
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
struct Decimal;
/// A hexadecimal (base 16) radix, formatted with lower-case characters
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
struct LowerHex;
/// A hexadecimal (base 16) radix, formatted with upper-case characters
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub struct UpperHex;
macro_rules! radix {
@ -108,7 +108,7 @@ radix!(UpperHex, 16, "0x", x @ 0 .. 9 => '0' as u8 + x,
x @ 10 ..15 => 'A' as u8 + (x - 10))
/// A radix with in the range of `2..36`.
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub struct Radix {
base: u8,
}

2
src/libcore/fmt/rt.rs
View file

@ -40,7 +40,7 @@ pub struct FormatSpec {
pub width: Count,
}
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum Alignment {
AlignLeft,
AlignRight,

2
src/libcore/intrinsics.rs
View file

@ -550,7 +550,7 @@ extern "rust-intrinsic" {
/// `TypeId` represents a globally unique identifier for a type
#[lang="type_id"] // This needs to be kept in lockstep with the code in trans/intrinsic.rs and
// middle/lang_items.rs
#[deriving(Eq, TotalEq, Show)]
#[deriving(PartialEq, TotalEq, Show)]
#[cfg(not(test))]
pub struct TypeId {
t: u64,

60
src/libcore/iter.rs
View file

@ -68,7 +68,7 @@ use cmp;
use num::{Zero, One, CheckedAdd, CheckedSub, Saturating, ToPrimitive, Int};
use option::{Option, Some, None};
use ops::{Add, Mul, Sub};
use cmp::{Eq, Ord, TotalOrd};
use cmp::{PartialEq, PartialOrd, TotalOrd};
use clone::Clone;
use uint;
use mem;
@ -847,7 +847,7 @@ impl<A: Mul<A, A> + One, T: Iterator<A>> MultiplicativeIterator<A> for T {
}
/// A trait for iterators over elements which can be compared to one another.
/// The type of each element must ascribe to the `Ord` trait.
/// The type of each element must ascribe to the `PartialOrd` trait.
pub trait OrdIterator<A> {
/// Consumes the entire iterator to return the maximum element.
///
@ -971,7 +971,7 @@ impl<A: TotalOrd, T: Iterator<A>> OrdIterator<A> for T {
}
/// `MinMaxResult` is an enum returned by `min_max`. See `OrdIterator::min_max` for more detail.
#[deriving(Clone, Eq, Show)]
#[deriving(Clone, PartialEq, Show)]
pub enum MinMaxResult<T> {
/// Empty iterator
NoElements,
@ -1945,12 +1945,12 @@ pub struct Range<A> {
/// Return an iterator over the range [start, stop)
#[inline]
pub fn range<A: Add<A, A> + Ord + Clone + One>(start: A, stop: A) -> Range<A> {
pub fn range<A: Add<A, A> + PartialOrd + Clone + One>(start: A, stop: A) -> Range<A> {
Range{state: start, stop: stop, one: One::one()}
}
// FIXME: #10414: Unfortunate type bound
impl<A: Add<A, A> + Ord + Clone + ToPrimitive> Iterator<A> for Range<A> {
impl<A: Add<A, A> + PartialOrd + Clone + ToPrimitive> Iterator<A> for Range<A> {
#[inline]
fn next(&mut self) -> Option<A> {
if self.state < self.stop {
@ -1997,7 +1997,7 @@ impl<A: Add<A, A> + Ord + Clone + ToPrimitive> Iterator<A> for Range<A> {
/// `Int` is required to ensure the range will be the same regardless of
/// the direction it is consumed.
impl<A: Int + Ord + Clone + ToPrimitive> DoubleEndedIterator<A> for Range<A> {
impl<A: Int + PartialOrd + Clone + ToPrimitive> DoubleEndedIterator<A> for Range<A> {
#[inline]
fn next_back(&mut self) -> Option<A> {
if self.stop > self.state {
@ -2018,12 +2018,12 @@ pub struct RangeInclusive<A> {
/// Return an iterator over the range [start, stop]
#[inline]
pub fn range_inclusive<A: Add<A, A> + Ord + Clone + One>(start: A, stop: A)
pub fn range_inclusive<A: Add<A, A> + PartialOrd + Clone + One>(start: A, stop: A)
-> RangeInclusive<A> {
RangeInclusive{range: range(start, stop), done: false}
}
impl<A: Add<A, A> + Ord + Clone + ToPrimitive> Iterator<A> for RangeInclusive<A> {
impl<A: Add<A, A> + PartialOrd + Clone + ToPrimitive> Iterator<A> for RangeInclusive<A> {
#[inline]
fn next(&mut self) -> Option<A> {
match self.range.next() {
@ -2055,7 +2055,7 @@ impl<A: Add<A, A> + Ord + Clone + ToPrimitive> Iterator<A> for RangeInclusive<A>
}
}
impl<A: Sub<A, A> + Int + Ord + Clone + ToPrimitive> DoubleEndedIterator<A>
impl<A: Sub<A, A> + Int + PartialOrd + Clone + ToPrimitive> DoubleEndedIterator<A>
for RangeInclusive<A> {
#[inline]
fn next_back(&mut self) -> Option<A> {
@ -2083,12 +2083,12 @@ pub struct RangeStep<A> {
/// Return an iterator over the range [start, stop) by `step`. It handles overflow by stopping.
#[inline]
pub fn range_step<A: CheckedAdd + Ord + Clone + Zero>(start: A, stop: A, step: A) -> RangeStep<A> {
pub fn range_step<A: CheckedAdd + PartialOrd + Clone + Zero>(start: A, stop: A, step: A) -> RangeStep<A> {
let rev = step < Zero::zero();
RangeStep{state: start, stop: stop, step: step, rev: rev}
}
impl<A: CheckedAdd + Ord + Clone> Iterator<A> for RangeStep<A> {
impl<A: CheckedAdd + PartialOrd + Clone> Iterator<A> for RangeStep<A> {
#[inline]
fn next(&mut self) -> Option<A> {
if (self.rev && self.state > self.stop) || (!self.rev && self.state < self.stop) {
@ -2116,13 +2116,13 @@ pub struct RangeStepInclusive<A> {
/// Return an iterator over the range [start, stop] by `step`. It handles overflow by stopping.
#[inline]
pub fn range_step_inclusive<A: CheckedAdd + Ord + Clone + Zero>(start: A, stop: A,
pub fn range_step_inclusive<A: CheckedAdd + PartialOrd + Clone + Zero>(start: A, stop: A,
step: A) -> RangeStepInclusive<A> {
let rev = step < Zero::zero();
RangeStepInclusive{state: start, stop: stop, step: step, rev: rev, done: false}
}
impl<A: CheckedAdd + Ord + Clone + Eq> Iterator<A> for RangeStepInclusive<A> {
impl<A: CheckedAdd + PartialOrd + Clone + PartialEq> Iterator<A> for RangeStepInclusive<A> {
#[inline]
fn next(&mut self) -> Option<A> {
if !self.done && ((self.rev && self.state >= self.stop) ||
@ -2175,13 +2175,13 @@ impl<A: Clone> RandomAccessIterator<A> for Repeat<A> {
/// Functions for lexicographical ordering of sequences.
///
/// Lexicographical ordering through `<`, `<=`, `>=`, `>` requires
/// that the elements implement both `Eq` and `Ord`.
/// that the elements implement both `PartialEq` and `PartialOrd`.
///
/// If two sequences are equal up until the point where one ends,
/// the shorter sequence compares less.
pub mod order {
use cmp;
use cmp::{TotalEq, TotalOrd, Ord, Eq};
use cmp::{TotalEq, TotalOrd, PartialOrd, PartialEq};
use option::{Some, None};
use super::Iterator;
@ -2211,8 +2211,8 @@ pub mod order {
}
}
/// Compare `a` and `b` for equality (Using partial equality, `Eq`)
pub fn eq<A: Eq, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
/// Compare `a` and `b` for equality (Using partial equality, `PartialEq`)
pub fn eq<A: PartialEq, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
loop {
match (a.next(), b.next()) {
(None, None) => return true,
@ -2222,8 +2222,8 @@ pub mod order {
}
}
/// Compare `a` and `b` for nonequality (Using partial equality, `Eq`)
pub fn ne<A: Eq, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
/// Compare `a` and `b` for nonequality (Using partial equality, `PartialEq`)
pub fn ne<A: PartialEq, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
loop {
match (a.next(), b.next()) {
(None, None) => return false,
@ -2233,8 +2233,8 @@ pub mod order {
}
}
/// Return `a` < `b` lexicographically (Using partial order, `Ord`)
pub fn lt<A: Ord, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
/// Return `a` < `b` lexicographically (Using partial order, `PartialOrd`)
pub fn lt<A: PartialOrd, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
loop {
match (a.next(), b.next()) {
(None, None) => return false,
@ -2245,8 +2245,8 @@ pub mod order {
}
}
/// Return `a` <= `b` lexicographically (Using partial order, `Ord`)
pub fn le<A: Ord, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
/// Return `a` <= `b` lexicographically (Using partial order, `PartialOrd`)
pub fn le<A: PartialOrd, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
loop {
match (a.next(), b.next()) {
(None, None) => return true,
@ -2257,8 +2257,8 @@ pub mod order {
}
}
/// Return `a` > `b` lexicographically (Using partial order, `Ord`)
pub fn gt<A: Ord, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
/// Return `a` > `b` lexicographically (Using partial order, `PartialOrd`)
pub fn gt<A: PartialOrd, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
loop {
match (a.next(), b.next()) {
(None, None) => return false,
@ -2269,8 +2269,8 @@ pub mod order {
}
}
/// Return `a` >= `b` lexicographically (Using partial order, `Ord`)
pub fn ge<A: Ord, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
/// Return `a` >= `b` lexicographically (Using partial order, `PartialOrd`)
pub fn ge<A: PartialOrd, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
loop {
match (a.next(), b.next()) {
(None, None) => return true,
@ -2849,7 +2849,7 @@ mod tests {
#[cfg(test)]
fn check_randacc_iter<A: Eq, T: Clone + RandomAccessIterator<A>>(a: T, len: uint)
fn check_randacc_iter<A: PartialEq, T: Clone + RandomAccessIterator<A>>(a: T, len: uint)
{
let mut b = a.clone();
assert_eq!(len, b.indexable());
@ -3009,13 +3009,13 @@ mod tests {
}
}
impl Eq for Foo {
impl PartialEq for Foo {
fn eq(&self, _: &Foo) -> bool {
true
}
}
impl Ord for Foo {
impl PartialOrd for Foo {
fn lt(&self, _: &Foo) -> bool {
false
}

20
src/libcore/kinds.rs
View file

@ -133,7 +133,7 @@ pub mod marker {
/// (for example, `S<&'static int>` is a subtype of `S<&'a int>`
/// for some lifetime `'a`, but not the other way around).
#[lang="covariant_type"]
#[deriving(Eq,Clone)]
#[deriving(PartialEq,Clone)]
pub struct CovariantType<T>;
/// A marker type whose type parameter `T` is considered to be
@ -176,7 +176,7 @@ pub mod marker {
/// function requires arguments of type `T`, it must also accept
/// arguments of type `U`, hence such a conversion is safe.
#[lang="contravariant_type"]
#[deriving(Eq,Clone)]
#[deriving(PartialEq,Clone)]
pub struct ContravariantType<T>;
/// A marker type whose type parameter `T` is considered to be
@ -201,7 +201,7 @@ pub mod marker {
/// never written, but in fact `Cell` uses unsafe code to achieve
/// interior mutability.
#[lang="invariant_type"]
#[deriving(Eq,Clone)]
#[deriving(PartialEq,Clone)]
pub struct InvariantType<T>;
/// As `CovariantType`, but for lifetime parameters. Using
@ -221,7 +221,7 @@ pub mod marker {
/// For more information about variance, refer to this Wikipedia
/// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
#[lang="covariant_lifetime"]
#[deriving(Eq,Clone)]
#[deriving(PartialEq,Clone)]
pub struct CovariantLifetime<'a>;
/// As `ContravariantType`, but for lifetime parameters. Using
@ -237,7 +237,7 @@ pub mod marker {
/// For more information about variance, refer to this Wikipedia
/// article <http://en.wikipedia.org/wiki/Variance_%28computer_science%29>.
#[lang="contravariant_lifetime"]
#[deriving(Eq,Clone)]
#[deriving(PartialEq,Clone)]
pub struct ContravariantLifetime<'a>;
/// As `InvariantType`, but for lifetime parameters. Using
@ -248,7 +248,7 @@ pub mod marker {
/// and this pointer is itself stored in an inherently mutable
/// location (such as a `Cell`).
#[lang="invariant_lifetime"]
#[deriving(Eq,Clone)]
#[deriving(PartialEq,Clone)]
pub struct InvariantLifetime<'a>;
/// A type which is considered "not sendable", meaning that it cannot
@ -256,26 +256,26 @@ pub mod marker {
/// typically embedded in other types, such as `Gc`, to ensure that
/// their instances remain thread-local.
#[lang="no_send_bound"]
#[deriving(Eq,Clone)]
#[deriving(PartialEq,Clone)]
pub struct NoSend;
/// A type which is considered "not POD", meaning that it is not
/// implicitly copyable. This is typically embedded in other types to
/// ensure that they are never copied, even if they lack a destructor.
#[lang="no_copy_bound"]
#[deriving(Eq,Clone)]
#[deriving(PartialEq,Clone)]
pub struct NoCopy;
/// A type which is considered "not shareable", meaning that
/// its contents are not threadsafe, hence they cannot be
/// shared between tasks.
#[lang="no_share_bound"]
#[deriving(Eq,Clone)]
#[deriving(PartialEq,Clone)]
pub struct NoShare;
/// A type which is considered managed by the GC. This is typically
/// embedded in other types.
#[lang="managed_bound"]
#[deriving(Eq,Clone)]
#[deriving(PartialEq,Clone)]
pub struct Managed;
}

10
src/libcore/num/mod.rs
View file

@ -17,7 +17,7 @@ use {int, i8, i16, i32, i64};
use {uint, u8, u16, u32, u64};
use {f32, f64};
use clone::Clone;
use cmp::{Eq, Ord};
use cmp::{PartialEq, PartialOrd};
use kinds::Copy;
use mem::size_of;
use ops::{Add, Sub, Mul, Div, Rem, Neg};
@ -25,7 +25,7 @@ use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr};
use option::{Option, Some, None};
/// The base trait for numeric types
pub trait Num: Eq + Zero + One
pub trait Num: PartialEq + Zero + One
+ Neg<Self>
+ Add<Self,Self>
+ Sub<Self,Self>
@ -495,7 +495,7 @@ pub trait Primitive: Copy
+ Clone
+ Num
+ NumCast
+ Ord
+ PartialOrd
+ Bounded {}
trait_impl!(Primitive for uint u8 u16 u32 u64 int i8 i16 i32 i64 f32 f64)
@ -1043,7 +1043,7 @@ pub trait Saturating {
fn saturating_sub(self, v: Self) -> Self;
}
impl<T: CheckedAdd + CheckedSub + Zero + Ord + Bounded> Saturating for T {
impl<T: CheckedAdd + CheckedSub + Zero + PartialOrd + Bounded> Saturating for T {
#[inline]
fn saturating_add(self, v: T) -> T {
match self.checked_add(&v) {
@ -1238,7 +1238,7 @@ pub fn test_num<T:Num + NumCast + ::std::fmt::Show>(ten: T, two: T) {
}
/// Used for representing the classification of floating point numbers
#[deriving(Eq, Show)]
#[deriving(PartialEq, Show)]
pub enum FPCategory {
/// "Not a Number", often obtained by dividing by zero
FPNaN,

4
src/libcore/option.rs
View file

@ -141,14 +141,14 @@
//! }
//! ```
use cmp::{Eq, TotalEq, TotalOrd};
use cmp::{PartialEq, TotalEq, TotalOrd};
use default::Default;
use iter::{Iterator, DoubleEndedIterator, FromIterator, ExactSize};
use mem;
use slice;
/// The `Option`
#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd, Show)]
#[deriving(Clone, PartialEq, PartialOrd, TotalEq, TotalOrd, Show)]
pub enum Option<T> {
/// No value
None,

3
src/libcore/prelude.rs
View file

@ -45,7 +45,8 @@ pub use mem::drop;
pub use char::Char;
pub use clone::Clone;
pub use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater, Equiv};
pub use cmp::{PartialEq, PartialOrd, TotalEq, TotalOrd};
pub use cmp::{Ordering, Less, Equal, Greater, Equiv};
pub use container::{Container, Mutable, Map, MutableMap, Set, MutableSet};
pub use iter::{FromIterator, Extendable};
pub use iter::{Iterator, DoubleEndedIterator, RandomAccessIterator, CloneableIterator};

16
src/libcore/ptr.rs
View file

@ -93,7 +93,7 @@ use intrinsics;
use iter::{range, Iterator};
use option::{Some, None, Option};
#[cfg(not(test))] use cmp::{Eq, TotalEq, Ord, Equiv};
#[cfg(not(test))] use cmp::{PartialEq, TotalEq, PartialOrd, Equiv};
/// Return the offset of the first null pointer in `buf`.
#[inline]
@ -386,7 +386,7 @@ impl<T> RawPtr<T> for *mut T {
// Equality for pointers
#[cfg(not(test))]
impl<T> Eq for *T {
impl<T> PartialEq for *T {
#[inline]
fn eq(&self, other: &*T) -> bool {
*self == *other
@ -399,7 +399,7 @@ impl<T> Eq for *T {
impl<T> TotalEq for *T {}
#[cfg(not(test))]
impl<T> Eq for *mut T {
impl<T> PartialEq for *mut T {
#[inline]
fn eq(&self, other: &*mut T) -> bool {
*self == *other
@ -430,9 +430,9 @@ impl<T> Equiv<*T> for *mut T {
#[cfg(not(test))]
mod externfnpointers {
use mem;
use cmp::Eq;
use cmp::PartialEq;
impl<_R> Eq for extern "C" fn() -> _R {
impl<_R> PartialEq for extern "C" fn() -> _R {
#[inline]
fn eq(&self, other: &extern "C" fn() -> _R) -> bool {
let self_: *() = unsafe { mem::transmute(*self) };
@ -442,7 +442,7 @@ mod externfnpointers {
}
macro_rules! fnptreq(
($($p:ident),*) => {
impl<_R,$($p),*> Eq for extern "C" fn($($p),*) -> _R {
impl<_R,$($p),*> PartialEq for extern "C" fn($($p),*) -> _R {
#[inline]
fn eq(&self, other: &extern "C" fn($($p),*) -> _R) -> bool {
let self_: *() = unsafe { mem::transmute(*self) };
@ -461,13 +461,13 @@ mod externfnpointers {
// Comparison for pointers
#[cfg(not(test))]
impl<T> Ord for *T {
impl<T> PartialOrd for *T {
#[inline]
fn lt(&self, other: &*T) -> bool { *self < *other }
}
#[cfg(not(test))]
impl<T> Ord for *mut T {
impl<T> PartialOrd for *mut T {
#[inline]
fn lt(&self, other: &*mut T) -> bool { *self < *other }
}

4
src/libcore/result.rs
View file

@ -275,7 +275,7 @@
//! will not resume after failure, that failure is catastrophic.
use clone::Clone;
use cmp::Eq;
use cmp::PartialEq;
use std::fmt::Show;
use iter::{Iterator, FromIterator};
use option::{None, Option, Some};
@ -283,7 +283,7 @@ use option::{None, Option, Some};
/// `Result` is a type that represents either success (`Ok`) or failure (`Err`).
///
/// See the [`std::result`](index.html) module documentation for details.
#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd, Show)]
#[deriving(Clone, PartialEq, PartialOrd, TotalEq, TotalOrd, Show)]
#[must_use]
pub enum Result<T, E> {
/// Contains the success value

22
src/libcore/slice.rs
View file

@ -15,7 +15,7 @@
use mem::transmute;
use clone::Clone;
use container::Container;
use cmp::{Eq, TotalOrd, Ordering, Less, Equal, Greater};
use cmp::{PartialEq, TotalOrd, Ordering, Less, Equal, Greater};
use cmp;
use default::Default;
use iter::*;
@ -249,11 +249,11 @@ impl<'a, T> RandomAccessIterator<&'a [T]> for Chunks<'a, T> {
pub mod traits {
use super::*;
use cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Equiv};
use cmp::{PartialEq, PartialOrd, TotalEq, TotalOrd, Ordering, Equiv};
use iter::{order, Iterator};
use container::Container;
impl<'a,T:Eq> Eq for &'a [T] {
impl<'a,T:PartialEq> PartialEq for &'a [T] {
fn eq(&self, other: & &'a [T]) -> bool {
self.len() == other.len() &&
order::eq(self.iter(), other.iter())
@ -264,7 +264,7 @@ pub mod traits {
}
}
impl<T:Eq> Eq for ~[T] {
impl<T:PartialEq> PartialEq for ~[T] {
#[inline]
fn eq(&self, other: &~[T]) -> bool { self.as_slice() == *other }
#[inline]
@ -275,12 +275,12 @@ pub mod traits {
impl<T:TotalEq> TotalEq for ~[T] {}
impl<'a,T:Eq, V: Vector<T>> Equiv<V> for &'a [T] {
impl<'a,T:PartialEq, V: Vector<T>> Equiv<V> for &'a [T] {
#[inline]
fn equiv(&self, other: &V) -> bool { self.as_slice() == other.as_slice() }
}
impl<'a,T:Eq, V: Vector<T>> Equiv<V> for ~[T] {
impl<'a,T:PartialEq, V: Vector<T>> Equiv<V> for ~[T] {
#[inline]
fn equiv(&self, other: &V) -> bool { self.as_slice() == other.as_slice() }
}
@ -296,7 +296,7 @@ pub mod traits {
fn cmp(&self, other: &~[T]) -> Ordering { self.as_slice().cmp(&other.as_slice()) }
}
impl<'a, T: Ord> Ord for &'a [T] {
impl<'a, T: PartialOrd> PartialOrd for &'a [T] {
fn lt(&self, other: & &'a [T]) -> bool {
order::lt(self.iter(), other.iter())
}
@ -314,7 +314,7 @@ pub mod traits {
}
}
impl<T: Ord> Ord for ~[T] {
impl<T: PartialOrd> PartialOrd for ~[T] {
#[inline]
fn lt(&self, other: &~[T]) -> bool { self.as_slice() < other.as_slice() }
#[inline]
@ -692,8 +692,8 @@ impl<'a,T> ImmutableVector<'a, T> for &'a [T] {
}
}
/// Extension methods for vectors contain `Eq` elements.
pub trait ImmutableEqVector<T:Eq> {
/// Extension methods for vectors contain `PartialEq` elements.
pub trait ImmutableEqVector<T:PartialEq> {
/// Find the first index containing a matching value
fn position_elem(&self, t: &T) -> Option<uint>;
@ -710,7 +710,7 @@ pub trait ImmutableEqVector<T:Eq> {
fn ends_with(&self, needle: &[T]) -> bool;
}
impl<'a,T:Eq> ImmutableEqVector<T> for &'a [T] {
impl<'a,T:PartialEq> ImmutableEqVector<T> for &'a [T] {
#[inline]
fn position_elem(&self, x: &T) -> Option<uint> {
self.iter().position(|y| *x == *y)

10
src/libcore/str.rs
View file

@ -16,7 +16,7 @@ use mem;
use char;
use clone::Clone;
use cmp;
use cmp::{Eq, TotalEq};
use cmp::{PartialEq, TotalEq};
use container::Container;
use default::Default;
use iter::{Filter, Map, Iterator};
@ -696,7 +696,7 @@ pub struct Utf16Items<'a> {
iter: slice::Items<'a, u16>
}
/// The possibilities for values decoded from a `u16` stream.
#[deriving(Eq, TotalEq, Clone, Show)]
#[deriving(PartialEq, TotalEq, Clone, Show)]
pub enum Utf16Item {
/// A valid codepoint.
ScalarValue(char),
@ -930,7 +930,7 @@ Section: Trait implementations
#[allow(missing_doc)]
pub mod traits {
use container::Container;
use cmp::{TotalOrd, Ordering, Less, Equal, Greater, Eq, Ord, Equiv, TotalEq};
use cmp::{TotalOrd, Ordering, Less, Equal, Greater, PartialEq, PartialOrd, Equiv, TotalEq};
use iter::Iterator;
use option::{Some, None};
use str::{Str, StrSlice, eq_slice};
@ -950,7 +950,7 @@ pub mod traits {
}
}
impl<'a> Eq for &'a str {
impl<'a> PartialEq for &'a str {
#[inline]
fn eq(&self, other: & &'a str) -> bool {
eq_slice((*self), (*other))
@ -961,7 +961,7 @@ pub mod traits {
impl<'a> TotalEq for &'a str {}
impl<'a> Ord for &'a str {
impl<'a> PartialOrd for &'a str {
#[inline]
fn lt(&self, other: & &'a str) -> bool { self.cmp(other) == Less }
}

12
src/libcore/tuple.rs
View file

@ -27,9 +27,9 @@
//! traits, then a tuple itself also implements it.
//!
//! * `Clone`
//! * `Eq`
//! * `PartialEq`
//! * `TotalEq`
//! * `Ord`
//! * `PartialOrd`
//! * `TotalOrd`
//! * `Default`
//!
@ -109,7 +109,7 @@ macro_rules! tuple_impls {
}
#[cfg(not(test))]
impl<$($T:Eq),+> Eq for ($($T,)+) {
impl<$($T:PartialEq),+> PartialEq for ($($T,)+) {
#[inline]
fn eq(&self, other: &($($T,)+)) -> bool {
$(*self.$refN() == *other.$refN())&&+
@ -124,7 +124,7 @@ macro_rules! tuple_impls {
impl<$($T:TotalEq),+> TotalEq for ($($T,)+) {}
#[cfg(not(test))]
impl<$($T:Ord + Eq),+> Ord for ($($T,)+) {
impl<$($T:PartialOrd + PartialEq),+> PartialOrd for ($($T,)+) {
#[inline]
fn lt(&self, other: &($($T,)+)) -> bool {
lexical_ord!(lt, $(self.$refN(), other.$refN()),+)
@ -335,13 +335,13 @@ mod tests {
let nan = 0.0/0.0;
// Eq
// PartialEq
assert_eq!(small, small);
assert_eq!(big, big);
assert!(small != big);
assert!(big != small);
// Ord
// PartialOrd
assert!(small < big);
assert!(!(small < small));
assert!(!(big < small));

24
src/libfmt_macros/lib.rs
View file

@ -26,7 +26,7 @@ use std::str;
/// A piece is a portion of the format string which represents the next part
/// to emit. These are emitted as a stream by the `Parser` class.
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum Piece<'a> {
/// A literal string which should directly be emitted
String(&'a str),
@ -39,7 +39,7 @@ pub enum Piece<'a> {
}
/// Representation of an argument specification.
#[deriving(Eq)]
#[deriving(PartialEq)]
pub struct Argument<'a> {
/// Where to find this argument
pub position: Position<'a>,
@ -50,7 +50,7 @@ pub struct Argument<'a> {
}
/// Specification for the formatting of an argument in the format string.
#[deriving(Eq)]
#[deriving(PartialEq)]
pub struct FormatSpec<'a> {
/// Optionally specified character to fill alignment with
pub fill: Option<char>,
@ -69,7 +69,7 @@ pub struct FormatSpec<'a> {
}
/// Enum describing where an argument for a format can be located.
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum Position<'a> {
/// The argument will be in the next position. This is the default.
ArgumentNext,
@ -80,7 +80,7 @@ pub enum Position<'a> {
}
/// Enum of alignments which are supported.
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum Alignment {
/// The value will be aligned to the left.
AlignLeft,
@ -92,7 +92,7 @@ pub enum Alignment {
/// Various flags which can be applied to format strings. The meaning of these
/// flags is defined by the formatters themselves.
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum Flag {
/// A `+` will be used to denote positive numbers.
FlagSignPlus,
@ -108,7 +108,7 @@ pub enum Flag {
/// A count is used for the precision and width parameters of an integer, and
/// can reference either an argument or a literal integer.
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum Count<'a> {
/// The count is specified explicitly.
CountIs(uint),
@ -124,7 +124,7 @@ pub enum Count<'a> {
/// Enum describing all of the possible methods which the formatting language
/// currently supports.
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum Method<'a> {
/// A plural method selects on an integer over a list of either integer or
/// keyword-defined clauses. The meaning of the keywords is defined by the
@ -146,7 +146,7 @@ pub enum Method<'a> {
}
/// A selector for what pluralization a plural method should take
#[deriving(Eq, TotalEq, Hash)]
#[deriving(PartialEq, TotalEq, Hash)]
pub enum PluralSelector {
/// One of the plural keywords should be used
Keyword(PluralKeyword),
@ -155,7 +155,7 @@ pub enum PluralSelector {
}
/// Structure representing one "arm" of the `plural` function.
#[deriving(Eq)]
#[deriving(PartialEq)]
pub struct PluralArm<'a> {
/// A selector can either be specified by a keyword or with an integer
/// literal.
@ -168,7 +168,7 @@ pub struct PluralArm<'a> {
/// is specially placed in the `Plural` variant of `Method`.
///
/// http://www.icu-project.org/apiref/icu4c/classicu_1_1PluralRules.html
#[deriving(Eq, TotalEq, Hash, Show)]
#[deriving(PartialEq, TotalEq, Hash, Show)]
#[allow(missing_doc)]
pub enum PluralKeyword {
/// The plural form for zero objects.
@ -184,7 +184,7 @@ pub enum PluralKeyword {
}
/// Structure representing one "arm" of the `select` function.
#[deriving(Eq)]
#[deriving(PartialEq)]
pub struct SelectArm<'a> {
/// String selector which guards this arm
pub selector: &'a str,

20
src/libgetopts/lib.rs
View file

@ -92,13 +92,13 @@
#[cfg(test)] extern crate debug;
#[cfg(test)] #[phase(syntax, link)] extern crate log;
use std::cmp::Eq;
use std::cmp::PartialEq;
use std::result::{Err, Ok};
use std::result;
use std::string::String;
/// Name of an option. Either a string or a single char.
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub enum Name {
/// A string representing the long name of an option.
/// For example: "help"
@ -109,7 +109,7 @@ pub enum Name {
}
/// Describes whether an option has an argument.
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub enum HasArg {
/// The option requires an argument.
Yes,
@ -120,7 +120,7 @@ pub enum HasArg {
}
/// Describes how often an option may occur.
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub enum Occur {
/// The option occurs once.
Req,
@ -131,7 +131,7 @@ pub enum Occur {
}
/// A description of a possible option.
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub struct Opt {
/// Name of the option
pub name: Name,
@ -145,7 +145,7 @@ pub struct Opt {
/// One group of options, e.g., both -h and --help, along with
/// their shared description and properties.
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub struct OptGroup {
/// Short Name of the `OptGroup`
pub short_name: String,
@ -162,7 +162,7 @@ pub struct OptGroup {
}
/// Describes wether an option is given at all or has a value.
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
enum Optval {
Val(String),
Given,
@ -170,7 +170,7 @@ enum Optval {
/// The result of checking command line arguments. Contains a vector
/// of matches and a vector of free strings.
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub struct Matches {
/// Options that matched
opts: Vec<Opt> ,
@ -183,7 +183,7 @@ pub struct Matches {
/// The type returned when the command line does not conform to the
/// expected format. Call the `to_err_msg` method to retrieve the
/// error as a string.
#[deriving(Clone, Eq, Show)]
#[deriving(Clone, PartialEq, Show)]
pub enum Fail_ {
/// The option requires an argument but none was passed.
ArgumentMissing(String),
@ -198,7 +198,7 @@ pub enum Fail_ {
}
/// The type of failure that occurred.
#[deriving(Eq)]
#[deriving(PartialEq)]
#[allow(missing_doc)]
pub enum FailType {
ArgumentMissing_,

10
src/libglob/lib.rs
View file

@ -198,12 +198,12 @@ fn list_dir_sorted(path: &Path) -> Option<Vec<Path>> {
/**
* A compiled Unix shell style pattern.
*/
#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Hash, Default)]
#[deriving(Clone, PartialEq, TotalEq, PartialOrd, TotalOrd, Hash, Default)]
pub struct Pattern {
tokens: Vec<PatternToken>,
}
#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Hash)]
#[deriving(Clone, PartialEq, TotalEq, PartialOrd, TotalOrd, Hash)]
enum PatternToken {
Char(char),
AnyChar,
@ -212,13 +212,13 @@ enum PatternToken {
AnyExcept(Vec<CharSpecifier> )
}
#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Hash)]
#[deriving(Clone, PartialEq, TotalEq, PartialOrd, TotalOrd, Hash)]
enum CharSpecifier {
SingleChar(char),
CharRange(char, char)
}
#[deriving(Eq)]
#[deriving(PartialEq)]
enum MatchResult {
Match,
SubPatternDoesntMatch,
@ -596,7 +596,7 @@ fn chars_eq(a: char, b: char, case_sensitive: bool) -> bool {
/**
* Configuration options to modify the behaviour of `Pattern::matches_with(..)`
*/
#[deriving(Clone, Eq, TotalEq, Ord, TotalOrd, Hash, Default)]
#[deriving(Clone, PartialEq, TotalEq, PartialOrd, TotalOrd, Hash, Default)]
pub struct MatchOptions {
/**

2
src/libgreen/sched.rs
View file

@ -105,7 +105,7 @@ pub struct Scheduler {
/// An indication of how hard to work on a given operation, the difference
/// mainly being whether memory is synchronized or not
#[deriving(Eq)]
#[deriving(PartialEq)]
enum EffortLevel {
DontTryTooHard,
GiveItYourBest

2
src/liblog/lib.rs
View file

@ -172,7 +172,7 @@ struct DefaultLogger {
}
/// Wraps the log level with fmt implementations.
#[deriving(Eq, Ord)]
#[deriving(PartialEq, PartialOrd)]
pub struct LogLevel(pub u32);
impl fmt::Show for LogLevel {

10
src/libnum/bigint.rs
View file

@ -83,7 +83,7 @@ pub struct BigUint {
data: Vec<BigDigit>
}
impl Eq for BigUint {
impl PartialEq for BigUint {
#[inline]
fn eq(&self, other: &BigUint) -> bool {
match self.cmp(other) { Equal => true, _ => false }
@ -91,7 +91,7 @@ impl Eq for BigUint {
}
impl TotalEq for BigUint {}
impl Ord for BigUint {
impl PartialOrd for BigUint {
#[inline]
fn lt(&self, other: &BigUint) -> bool {
match self.cmp(other) { Less => true, _ => false}
@ -786,7 +786,7 @@ fn get_radix_base(radix: uint) -> (DoubleBigDigit, uint) {
}
/// A Sign is a `BigInt`'s composing element.
#[deriving(Eq, Ord, TotalEq, TotalOrd, Clone, Show)]
#[deriving(PartialEq, PartialOrd, TotalEq, TotalOrd, Clone, Show)]
pub enum Sign { Minus, Zero, Plus }
impl Neg<Sign> for Sign {
@ -808,7 +808,7 @@ pub struct BigInt {
data: BigUint
}
impl Eq for BigInt {
impl PartialEq for BigInt {
#[inline]
fn eq(&self, other: &BigInt) -> bool {
match self.cmp(other) { Equal => true, _ => false }
@ -817,7 +817,7 @@ impl Eq for BigInt {
impl TotalEq for BigInt {}
impl Ord for BigInt {
impl PartialOrd for BigInt {
#[inline]
fn lt(&self, other: &BigInt) -> bool {
match self.cmp(other) { Less => true, _ => false}

6
src/libnum/complex.rs
View file

@ -18,7 +18,7 @@ use std::num::{Zero,One,ToStrRadix};
// probably doesn't map to C's _Complex correctly.
/// A complex number in Cartesian form.
#[deriving(Eq,Clone)]
#[deriving(PartialEq,Clone)]
pub struct Complex<T> {
/// Real portion of the complex number
pub re: T,
@ -164,7 +164,7 @@ impl<T: Clone + Num> One for Complex<T> {
}
/* string conversions */
impl<T: fmt::Show + Num + Ord> fmt::Show for Complex<T> {
impl<T: fmt::Show + Num + PartialOrd> fmt::Show for Complex<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if self.im < Zero::zero() {
write!(f, "{}-{}i", self.re, -self.im)
@ -174,7 +174,7 @@ impl<T: fmt::Show + Num + Ord> fmt::Show for Complex<T> {
}
}
impl<T: ToStrRadix + Num + Ord> ToStrRadix for Complex<T> {
impl<T: ToStrRadix + Num + PartialOrd> ToStrRadix for Complex<T> {
fn to_str_radix(&self, radix: uint) -> String {
if self.im < Zero::zero() {
format!("{}-{}i",

2
src/libnum/lib.rs
View file

@ -60,7 +60,7 @@ pub mod bigint;
pub mod rational;
pub mod complex;
pub trait Integer: Num + Ord
pub trait Integer: Num + PartialOrd
+ Div<Self, Self>
+ Rem<Self, Self> {
/// Simultaneous truncated integer division and modulus

24
src/libnum/rational.rs
View file

@ -34,7 +34,7 @@ pub type Rational64 = Ratio<i64>;
/// Alias for arbitrary precision rationals.
pub type BigRational = Ratio<BigInt>;
impl<T: Clone + Integer + Ord>
impl<T: Clone + Integer + PartialOrd>
Ratio<T> {
/// Create a ratio representing the integer `t`.
#[inline]
@ -192,14 +192,14 @@ macro_rules! cmp_impl {
}
};
}
cmp_impl!(impl Eq, eq, ne)
cmp_impl!(impl Ord, lt, gt, le, ge)
cmp_impl!(impl PartialEq, eq, ne)
cmp_impl!(impl PartialOrd, lt, gt, le, ge)
cmp_impl!(impl TotalEq, )
cmp_impl!(impl TotalOrd, cmp -> cmp::Ordering)
/* Arithmetic */
// a/b * c/d = (a*c)/(b*d)
impl<T: Clone + Integer + Ord>
impl<T: Clone + Integer + PartialOrd>
Mul<Ratio<T>,Ratio<T>> for Ratio<T> {
#[inline]
fn mul(&self, rhs: &Ratio<T>) -> Ratio<T> {
@ -208,7 +208,7 @@ impl<T: Clone + Integer + Ord>
}
// (a/b) / (c/d) = (a*d)/(b*c)
impl<T: Clone + Integer + Ord>
impl<T: Clone + Integer + PartialOrd>
Div<Ratio<T>,Ratio<T>> for Ratio<T> {
#[inline]
fn div(&self, rhs: &Ratio<T>) -> Ratio<T> {
@ -219,7 +219,7 @@ impl<T: Clone + Integer + Ord>
// Abstracts the a/b `op` c/d = (a*d `op` b*d) / (b*d) pattern
macro_rules! arith_impl {
(impl $imp:ident, $method:ident) => {
impl<T: Clone + Integer + Ord>
impl<T: Clone + Integer + PartialOrd>
$imp<Ratio<T>,Ratio<T>> for Ratio<T> {
#[inline]
fn $method(&self, rhs: &Ratio<T>) -> Ratio<T> {
@ -239,7 +239,7 @@ arith_impl!(impl Sub, sub)
// a/b % c/d = (a*d % b*c)/(b*d)
arith_impl!(impl Rem, rem)
impl<T: Clone + Integer + Ord>
impl<T: Clone + Integer + PartialOrd>
Neg<Ratio<T>> for Ratio<T> {
#[inline]
fn neg(&self) -> Ratio<T> {
@ -248,7 +248,7 @@ impl<T: Clone + Integer + Ord>
}
/* Constants */
impl<T: Clone + Integer + Ord>
impl<T: Clone + Integer + PartialOrd>
Zero for Ratio<T> {
#[inline]
fn zero() -> Ratio<T> {
@ -261,7 +261,7 @@ impl<T: Clone + Integer + Ord>
}
}
impl<T: Clone + Integer + Ord>
impl<T: Clone + Integer + PartialOrd>
One for Ratio<T> {
#[inline]
fn one() -> Ratio<T> {
@ -269,7 +269,7 @@ impl<T: Clone + Integer + Ord>
}
}
impl<T: Clone + Integer + Ord>
impl<T: Clone + Integer + PartialOrd>
Num for Ratio<T> {}
/* String conversions */
@ -288,7 +288,7 @@ impl<T: ToStrRadix> ToStrRadix for Ratio<T> {
}
}
impl<T: FromStr + Clone + Integer + Ord>
impl<T: FromStr + Clone + Integer + PartialOrd>
FromStr for Ratio<T> {
/// Parses `numer/denom`.
fn from_str(s: &str) -> Option<Ratio<T>> {
@ -305,7 +305,7 @@ impl<T: FromStr + Clone + Integer + Ord>
})
}
}
impl<T: FromStrRadix + Clone + Integer + Ord>
impl<T: FromStrRadix + Clone + Integer + PartialOrd>
FromStrRadix for Ratio<T> {
/// Parses `numer/denom` where the numbers are in base `radix`.
fn from_str_radix(s: &str, radix: uint) -> Option<Ratio<T>> {

2
src/librand/distributions/mod.rs
View file

@ -260,7 +260,7 @@ mod tests {
use {Rng, Rand};
use super::{RandSample, WeightedChoice, Weighted, Sample, IndependentSample};
#[deriving(Eq, Show)]
#[deriving(PartialEq, Show)]
struct ConstRand(uint);
impl Rand for ConstRand {
fn rand<R: Rng>(_: &mut R) -> ConstRand {

2
src/librand/distributions/range.rs
View file

@ -54,7 +54,7 @@ pub struct Range<X> {
accept_zone: X
}
impl<X: SampleRange + Ord> Range<X> {
impl<X: SampleRange + PartialOrd> Range<X> {
/// Create a new `Range` instance that samples uniformly from
/// `[low, high)`. Fails if `low >= high`.
pub fn new(low: X, high: X) -> Range<X> {

2
src/librand/lib.rs
View file

@ -182,7 +182,7 @@ pub trait Rng {
/// let m: f64 = rng.gen_range(-40.0, 1.3e5);
/// println!("{}", m);
/// ```
fn gen_range<T: Ord + SampleRange>(&mut self, low: T, high: T) -> T {
fn gen_range<T: PartialOrd + SampleRange>(&mut self, low: T, high: T) -> T {
assert!(low < high, "Rng.gen_range called with low >= high");
Range::new(low, high).ind_sample(self)
}

2
src/libregex/parse/mod.rs
View file

@ -67,7 +67,7 @@ pub enum Ast {
Rep(Box<Ast>, Repeater, Greed),
}
#[deriving(Show, Eq, Clone)]
#[deriving(Show, PartialEq, Clone)]
pub enum Repeater {
ZeroOne,
ZeroMore,

2
src/librustc/back/link.rs
View file

@ -45,7 +45,7 @@ use syntax::attr::AttrMetaMethods;
use syntax::crateid::CrateId;
use syntax::parse::token;
#[deriving(Clone, Eq, Ord, TotalOrd, TotalEq)]
#[deriving(Clone, PartialEq, PartialOrd, TotalOrd, TotalEq)]
pub enum OutputType {
OutputTypeBitcode,
OutputTypeAssembly,

2
src/librustc/back/svh.rs
View file

@ -53,7 +53,7 @@ use std::iter::range_step;
use syntax::ast;
use syntax::visit;
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub struct Svh {
hash: String,
}

8
src/librustc/driver/config.rs
View file

@ -46,7 +46,7 @@ pub struct Config {
pub uint_type: UintTy,
}
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub enum OptLevel {
No, // -O0
Less, // -O1
@ -54,7 +54,7 @@ pub enum OptLevel {
Aggressive // -O3
}
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub enum DebugInfoLevel {
NoDebugInfo,
LimitedDebugInfo,
@ -125,14 +125,14 @@ pub fn basic_options() -> Options {
// users can have their own entry
// functions that don't start a
// scheduler
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum EntryFnType {
EntryMain,
EntryStart,
EntryNone,
}
#[deriving(Eq, Ord, Clone, TotalOrd, TotalEq, Hash)]
#[deriving(PartialEq, PartialOrd, Clone, TotalOrd, TotalEq, Hash)]
pub enum CrateType {
CrateTypeExecutable,
CrateTypeDylib,

6
src/librustc/lib/llvm.rs
View file

@ -29,7 +29,7 @@ pub static False: Bool = 0 as Bool;
// Consts for the LLVM CallConv type, pre-cast to uint.
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum CallConv {
CCallConv = 0,
FastCallConv = 8,
@ -156,7 +156,7 @@ pub enum RealPredicate {
// The LLVM TypeKind type - must stay in sync with the def of
// LLVMTypeKind in llvm/include/llvm-c/Core.h
#[deriving(Eq)]
#[deriving(PartialEq)]
#[repr(C)]
pub enum TypeKind {
Void = 0,
@ -226,7 +226,7 @@ pub enum AsmDialect {
AD_Intel = 1
}
#[deriving(Eq)]
#[deriving(PartialEq)]
#[repr(C)]
pub enum CodeGenOptLevel {
CodeGenLevelNone = 0,

2
src/librustc/metadata/common.rs
View file

@ -114,7 +114,7 @@ pub static tag_items_data_item_reexport_def_id: uint = 0x39;
pub static tag_items_data_item_reexport_name: uint = 0x3a;
// used to encode crate_ctxt side tables
#[deriving(Eq)]
#[deriving(PartialEq)]
#[repr(uint)]
pub enum astencode_tag { // Reserves 0x40 -- 0x5f
tag_ast = 0x40,

6
src/librustc/metadata/cstore.rs
View file

@ -45,13 +45,13 @@ pub struct crate_metadata {
pub span: Span,
}
#[deriving(Show, Eq, Clone)]
#[deriving(Show, PartialEq, Clone)]
pub enum LinkagePreference {
RequireDynamic,
RequireStatic,
}
#[deriving(Eq, FromPrimitive)]
#[deriving(PartialEq, FromPrimitive)]
pub enum NativeLibaryKind {
NativeStatic, // native static library (.a archive)
NativeFramework, // OSX-specific
@ -60,7 +60,7 @@ pub enum NativeLibaryKind {
// Where a crate came from on the local filesystem. One of these two options
// must be non-None.
#[deriving(Eq, Clone)]
#[deriving(PartialEq, Clone)]
pub struct CrateSource {
pub dylib: Option<Path>,
pub rlib: Option<Path>,

2
src/librustc/metadata/decoder.rs
View file

@ -103,7 +103,7 @@ fn lookup_item<'a>(item_id: ast::NodeId, data: &'a [u8]) -> ebml::Doc<'a> {
find_item(item_id, items)
}
#[deriving(Eq)]
#[deriving(PartialEq)]
enum Family {
ImmStatic, // c
MutStatic, // b

2
src/librustc/middle/borrowck/check_loans.rs
View file

@ -82,7 +82,7 @@ pub fn check_loans(bccx: &BorrowckCtxt,
clcx.visit_block(body, ());
}
#[deriving(Eq)]
#[deriving(PartialEq)]
enum MoveError {
MoveOk,
MoveWhileBorrowed(/*loan*/Rc<LoanPath>, /*loan*/Span)

12
src/librustc/middle/borrowck/mod.rs
View file

@ -166,7 +166,7 @@ pub struct BorrowStats {
pub type BckResult<T> = Result<T, BckError>;
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum PartialTotal {
Partial, // Loan affects some portion
Total // Loan affects entire path
@ -188,13 +188,13 @@ pub struct Loan {
cause: euv::LoanCause,
}
#[deriving(Eq, TotalEq, Hash)]
#[deriving(PartialEq, TotalEq, Hash)]
pub enum LoanPath {
LpVar(ast::NodeId), // `x` in doc.rs
LpExtend(Rc<LoanPath>, mc::MutabilityCategory, LoanPathElem)
}
#[deriving(Eq, TotalEq, Hash)]
#[deriving(PartialEq, TotalEq, Hash)]
pub enum LoanPathElem {
LpDeref(mc::PointerKind), // `*LV` in doc.rs
LpInterior(mc::InteriorKind) // `LV.f` in doc.rs
@ -267,7 +267,7 @@ pub struct Restriction {
set: RestrictionSet
}
#[deriving(Eq)]
#[deriving(PartialEq)]
pub struct RestrictionSet {
bits: u32
}
@ -305,7 +305,7 @@ impl Repr for RestrictionSet {
// Errors
// Errors that can occur
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum bckerr_code {
err_mutbl,
err_out_of_scope(ty::Region, ty::Region), // superscope, subscope
@ -315,7 +315,7 @@ pub enum bckerr_code {
// Combination of an error code and the categorization of the expression
// that caused it
#[deriving(Eq)]
#[deriving(PartialEq)]
pub struct BckError {
span: Span,
cause: euv::LoanCause,

4
src/librustc/middle/borrowck/move_data.rs
View file

@ -65,7 +65,7 @@ pub struct FlowedMoveData<'a> {
}
/// Index into `MoveData.paths`, used like a pointer
#[deriving(Eq)]
#[deriving(PartialEq)]
pub struct MovePathIndex(uint);
impl MovePathIndex {
@ -84,7 +84,7 @@ static InvalidMovePathIndex: MovePathIndex =
MovePathIndex(uint::MAX);
/// Index into `MoveData.moves`, used like a pointer
#[deriving(Eq)]
#[deriving(PartialEq)]
pub struct MoveIndex(uint);
impl MoveIndex {

2
src/librustc/middle/check_loop.rs
View file

@ -15,7 +15,7 @@ use syntax::codemap::Span;
use syntax::visit::Visitor;
use syntax::visit;
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
enum Context {
Normal, Loop, Closure
}

2
src/librustc/middle/check_match.rs
View file

@ -215,7 +215,7 @@ enum useful {
not_useful,
}
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
enum ctor {
single,
variant(DefId),

4
src/librustc/middle/const_eval.rs
View file

@ -288,7 +288,7 @@ pub fn process_crate(krate: &ast::Crate,
// FIXME (#33): this doesn't handle big integer/float literals correctly
// (nor does the rest of our literal handling).
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub enum const_val {
const_float(f64),
const_int(i64),
@ -514,7 +514,7 @@ pub fn lit_to_const(lit: &Lit) -> const_val {
}
}
fn compare_vals<T: Ord>(a: T, b: T) -> Option<int> {
fn compare_vals<T: PartialOrd>(a: T, b: T) -> Option<int> {
Some(if a == b { 0 } else if a < b { -1 } else { 1 })
}
pub fn compare_const_vals(a: &const_val, b: &const_val) -> Option<int> {

2
src/librustc/middle/effect.rs
View file

@ -20,7 +20,7 @@ use syntax::codemap::Span;
use syntax::visit;
use syntax::visit::Visitor;
#[deriving(Eq)]
#[deriving(PartialEq)]
enum UnsafeContext {
SafeContext,
UnsafeFn,

6
src/librustc/middle/expr_use_visitor.rs
View file

@ -68,7 +68,7 @@ pub trait Delegate {
mode: MutateMode);
}
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum LoanCause {
ClosureCapture(Span),
AddrOf,
@ -78,13 +78,13 @@ pub enum LoanCause {
ClosureInvocation
}
#[deriving(Eq,Show)]
#[deriving(PartialEq,Show)]
pub enum ConsumeMode {
Copy, // reference to x where x has a type that copies
Move, // reference to x where x has a type that moves
}
#[deriving(Eq,Show)]
#[deriving(PartialEq,Show)]
pub enum MutateMode {
JustWrite, // x = y
WriteAndRead, // x += y

6
src/librustc/middle/graph.rs
View file

@ -55,11 +55,11 @@ pub struct Edge<E> {
pub data: E,
}
#[deriving(Eq)]
#[deriving(PartialEq)]
pub struct NodeIndex(pub uint);
pub static InvalidNodeIndex: NodeIndex = NodeIndex(uint::MAX);
#[deriving(Eq)]
#[deriving(PartialEq)]
pub struct EdgeIndex(pub uint);
pub static InvalidEdgeIndex: EdgeIndex = EdgeIndex(uint::MAX);
@ -356,7 +356,7 @@ mod test {
});
}
fn test_adjacent_edges<N:Eq,E:Eq>(graph: &Graph<N,E>,
fn test_adjacent_edges<N:PartialEq,E:PartialEq>(graph: &Graph<N,E>,
start_index: NodeIndex,
start_data: N,
expected_incoming: &[(E,N)],

2
src/librustc/middle/lang_items.rs
View file

@ -42,7 +42,7 @@ macro_rules! lets_do_this {
$( $variant:ident, $name:expr, $method:ident; )*
) => {
#[deriving(FromPrimitive, Eq, TotalEq, Hash)]
#[deriving(FromPrimitive, PartialEq, TotalEq, Hash)]
pub enum LangItem {
$($variant),*
}

10
src/librustc/middle/lint.rs
View file

@ -72,7 +72,7 @@ use syntax::parse::token;
use syntax::visit::Visitor;
use syntax::{ast, ast_util, visit};
#[deriving(Clone, Show, Eq, Ord, TotalEq, TotalOrd, Hash)]
#[deriving(Clone, Show, PartialEq, PartialOrd, TotalEq, TotalOrd, Hash)]
pub enum Lint {
CTypes,
UnusedImports,
@ -135,12 +135,12 @@ pub fn level_to_str(lv: Level) -> &'static str {
}
}
#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd)]
#[deriving(Clone, PartialEq, PartialOrd, TotalEq, TotalOrd)]
pub enum Level {
Allow, Warn, Deny, Forbid
}
#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd)]
#[deriving(Clone, PartialEq, PartialOrd, TotalEq, TotalOrd)]
pub struct LintSpec {
pub default: Level,
pub lint: Lint,
@ -150,7 +150,7 @@ pub struct LintSpec {
pub type LintDict = HashMap<&'static str, LintSpec>;
// this is public for the lints that run in trans
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum LintSource {
Node(Span),
Default,
@ -836,7 +836,7 @@ fn check_type_limits(cx: &Context, e: &ast::Expr) {
_ => ()
};
fn is_valid<T:cmp::Ord>(binop: ast::BinOp, v: T,
fn is_valid<T:cmp::PartialOrd>(binop: ast::BinOp, v: T,
min: T, max: T) -> bool {
match binop {
ast::BiLt => v > min && v <= max,

6
src/librustc/middle/liveness.rs
View file

@ -123,9 +123,9 @@ use syntax::print::pprust::{expr_to_str, block_to_str};
use syntax::{visit, ast_util};
use syntax::visit::{Visitor, FnKind};
#[deriving(Eq)]
#[deriving(PartialEq)]
struct Variable(uint);
#[deriving(Eq)]
#[deriving(PartialEq)]
struct LiveNode(uint);
impl Variable {
@ -142,7 +142,7 @@ impl Clone for LiveNode {
}
}
#[deriving(Eq)]
#[deriving(PartialEq)]
enum LiveNodeKind {
FreeVarNode(Span),
ExprNode(Span),

16
src/librustc/middle/mem_categorization.rs
View file

@ -76,7 +76,7 @@ use syntax::parse::token;
use std::cell::RefCell;
use std::rc::Rc;
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub enum categorization {
cat_rvalue(ty::Region), // temporary val, argument is its scope
cat_static_item,
@ -92,14 +92,14 @@ pub enum categorization {
// (*1) downcast is only required if the enum has more than one variant
}
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub struct CopiedUpvar {
pub upvar_id: ast::NodeId,
pub onceness: ast::Onceness,
}
// different kinds of pointers:
#[deriving(Clone, Eq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
pub enum PointerKind {
OwnedPtr,
GcPtr,
@ -109,26 +109,26 @@ pub enum PointerKind {
// We use the term "interior" to mean "something reachable from the
// base without a pointer dereference", e.g. a field
#[deriving(Clone, Eq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
pub enum InteriorKind {
InteriorField(FieldName),
InteriorElement(ElementKind),
}
#[deriving(Clone, Eq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
pub enum FieldName {
NamedField(ast::Name),
PositionalField(uint)
}
#[deriving(Clone, Eq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
pub enum ElementKind {
VecElement,
StrElement,
OtherElement,
}
#[deriving(Clone, Eq, TotalEq, Hash, Show)]
#[deriving(Clone, PartialEq, TotalEq, Hash, Show)]
pub enum MutabilityCategory {
McImmutable, // Immutable.
McDeclared, // Directly declared as mutable.
@ -149,7 +149,7 @@ pub enum MutabilityCategory {
// dereference, but its type is the type *before* the dereference
// (`@T`). So use `cmt.type` to find the type of the value in a consistent
// fashion. For more details, see the method `cat_pattern`
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub struct cmt_ {
pub id: ast::NodeId, // id of expr/pat producing this value
pub span: Span, // span of same expr/pat

16
src/librustc/middle/resolve.rs
View file

@ -87,7 +87,7 @@ pub enum PrivateDep {
}
// How an import is used.
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum ImportUse {
Unused, // The import is not used.
Used, // The import is used.
@ -102,20 +102,20 @@ impl LastPrivate {
}
}
#[deriving(Eq)]
#[deriving(PartialEq)]
enum PatternBindingMode {
RefutableMode,
LocalIrrefutableMode,
ArgumentIrrefutableMode,
}
#[deriving(Eq, TotalEq, Hash)]
#[deriving(PartialEq, TotalEq, Hash)]
enum Namespace {
TypeNS,
ValueNS
}
#[deriving(Eq)]
#[deriving(PartialEq)]
enum NamespaceError {
NoError,
ModuleError,
@ -288,7 +288,7 @@ enum ModulePrefixResult {
PrefixFound(Rc<Module>, uint)
}
#[deriving(Eq)]
#[deriving(PartialEq)]
enum NameSearchType {
/// We're doing a name search in order to resolve a `use` directive.
ImportSearch,
@ -306,7 +306,7 @@ enum BareIdentifierPatternResolution {
// Specifies how duplicates should be handled when adding a child item if
// another item exists with the same name in some namespace.
#[deriving(Eq)]
#[deriving(PartialEq)]
enum DuplicateCheckingMode {
ForbidDuplicateModules,
ForbidDuplicateTypes,
@ -435,7 +435,7 @@ enum ParentLink {
}
/// The type of module this is.
#[deriving(Eq)]
#[deriving(PartialEq)]
enum ModuleKind {
NormalModuleKind,
ExternModuleKind,
@ -4900,7 +4900,7 @@ impl<'a> Resolver<'a> {
}
fn find_fallback_in_self_type(&mut self, name: Name) -> FallbackSuggestion {
#[deriving(Eq)]
#[deriving(PartialEq)]
enum FallbackChecks {
Everything,
OnlyTraitAndStatics

4
src/librustc/middle/trans/_match.rs
View file

@ -240,7 +240,7 @@ enum Lit {
ConstLit(ast::DefId), // the def ID of the constant
}
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum VecLenOpt {
vec_len_eq,
vec_len_ge(/* length of prefix */uint)
@ -1215,7 +1215,7 @@ fn pick_col(m: &[Match]) -> uint {
return best_col;
}
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum branch_kind { no_branch, single, switch, compare, compare_vec_len, }
// Compiles a comparison between two things.

2
src/librustc/middle/trans/cabi.rs
View file

@ -18,7 +18,7 @@ use middle::trans::cabi_mips;
use middle::trans::type_::Type;
use syntax::abi::{X86, X86_64, Arm, Mips};
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub enum ArgKind {
/// Pass the argument directly using the normal converted
/// LLVM type or by coercing to another specified type

2
src/librustc/middle/trans/cabi_x86_64.rs
View file

@ -22,7 +22,7 @@ use middle::trans::type_::Type;
use std::cmp;
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
enum RegClass {
NoClass,
Int,

2
src/librustc/middle/trans/cleanup.rs
View file

@ -55,7 +55,7 @@ pub enum CleanupScopeKind<'a> {
LoopScopeKind(ast::NodeId, [&'a Block<'a>, ..EXIT_MAX])
}
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum EarlyExitLabel {
UnwindExit,
ReturnExit,

2
src/librustc/middle/trans/common.rs
View file

@ -722,7 +722,7 @@ pub fn expr_ty_adjusted(bcx: &Block, ex: &ast::Expr) -> ty::t {
}
// Key used to lookup values supplied for type parameters in an expr.
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum ExprOrMethodCall {
// Type parameters for a path like `None::<int>`
ExprId(ast::NodeId),

2
src/librustc/middle/trans/datum.rs
View file

@ -82,7 +82,7 @@ impl Drop for Rvalue {
fn drop(&mut self) { }
}
#[deriving(Eq, TotalEq, Hash)]
#[deriving(PartialEq, TotalEq, Hash)]
pub enum RvalueMode {
/// `val` is a pointer to the actual value (and thus has type *T)
ByRef,

2
src/librustc/middle/trans/debuginfo.rs
View file

@ -2403,7 +2403,7 @@ fn type_metadata(cx: &CrateContext,
type_metadata
}
#[deriving(Eq)]
#[deriving(PartialEq)]
enum DebugLocation {
KnownLocation { scope: DIScope, line: uint, col: uint },
UnknownLocation

4
src/librustc/middle/trans/expr.rs
View file

@ -79,7 +79,7 @@ use syntax::print::pprust::{expr_to_str};
// These are passed around by the code generating functions to track the
// destination of a computation's value.
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum Dest {
SaveIn(ValueRef),
Ignore,
@ -1497,7 +1497,7 @@ fn float_cast(bcx: &Block,
} else { llsrc };
}
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum cast_kind {
cast_pointer,
cast_integral,

4
src/librustc/middle/trans/monomorphize.rs
View file

@ -312,14 +312,14 @@ pub fn monomorphic_fn(ccx: &CrateContext,
}
// Used to identify cached monomorphized functions and vtables
#[deriving(Eq, TotalEq, Hash)]
#[deriving(PartialEq, TotalEq, Hash)]
pub struct MonoParamId {
pub subst: ty::t,
// Do we really need the vtables to be hashed? Isn't the type enough?
pub vtables: Vec<MonoId>
}
#[deriving(Eq, TotalEq, Hash)]
#[deriving(PartialEq, TotalEq, Hash)]
pub struct MonoId {
pub def: ast::DefId,
pub params: Vec<MonoParamId>

2
src/librustc/middle/trans/type_.rs
View file

@ -23,7 +23,7 @@ use std::mem;
use libc::{c_uint};
#[deriving(Clone, Eq, Show)]
#[deriving(Clone, PartialEq, Show)]
pub struct Type {
rf: TypeRef
}

70
src/librustc/middle/ty.rs
View file

@ -65,7 +65,7 @@ pub static INITIAL_DISCRIMINANT_VALUE: Disr = 0;
// Data types
#[deriving(Eq, TotalEq, Hash)]
#[deriving(PartialEq, TotalEq, Hash)]
pub struct field {
pub ident: ast::Ident,
pub mt: mt
@ -121,13 +121,13 @@ impl Method {
}
}
#[deriving(Clone, Eq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
pub struct mt {
pub ty: t,
pub mutbl: ast::Mutability,
}
#[deriving(Clone, Eq, TotalEq, Hash, Encodable, Decodable, Show)]
#[deriving(Clone, PartialEq, TotalEq, Hash, Encodable, Decodable, Show)]
pub enum TraitStore {
/// Box<Trait>
UniqTraitStore,
@ -145,7 +145,7 @@ pub struct field_ty {
// Contains information needed to resolve types and (in the future) look up
// the types of AST nodes.
#[deriving(Eq, TotalEq, Hash)]
#[deriving(PartialEq, TotalEq, Hash)]
pub struct creader_cache_key {
pub cnum: CrateNum,
pub pos: uint,
@ -158,10 +158,10 @@ pub struct intern_key {
sty: *sty,
}
// NB: Do not replace this with #[deriving(Eq)]. The automatically-derived
// NB: Do not replace this with #[deriving(PartialEq)]. The automatically-derived
// implementation will not recurse through sty and you will get stack
// exhaustion.
impl cmp::Eq for intern_key {
impl cmp::PartialEq for intern_key {
fn eq(&self, other: &intern_key) -> bool {
unsafe {
*self.sty == *other.sty
@ -185,14 +185,14 @@ pub enum ast_ty_to_ty_cache_entry {
atttce_resolved(t) /* resolved to a type, irrespective of region */
}
#[deriving(Clone, Eq, Decodable, Encodable)]
#[deriving(Clone, PartialEq, Decodable, Encodable)]
pub struct ItemVariances {
pub self_param: Option<Variance>,
pub type_params: OwnedSlice<Variance>,
pub region_params: OwnedSlice<Variance>
}
#[deriving(Clone, Eq, Decodable, Encodable, Show)]
#[deriving(Clone, PartialEq, Decodable, Encodable, Show)]
pub enum Variance {
Covariant, // T<A> <: T<B> iff A <: B -- e.g., function return type
Invariant, // T<A> <: T<B> iff B == A -- e.g., type of mutable cell
@ -216,7 +216,7 @@ pub struct AutoDerefRef {
pub autoref: Option<AutoRef>
}
#[deriving(Clone, Decodable, Encodable, Eq, Show)]
#[deriving(Clone, Decodable, Encodable, PartialEq, Show)]
pub enum AutoRef {
/// Convert from T to &T
AutoPtr(Region, ast::Mutability),
@ -387,7 +387,7 @@ pub struct t_box_ {
enum t_opaque {}
#[allow(raw_pointer_deriving)]
#[deriving(Clone, Eq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
pub struct t { inner: *t_opaque }
impl fmt::Show for t {
@ -415,14 +415,14 @@ pub fn type_needs_infer(t: t) -> bool {
}
pub fn type_id(t: t) -> uint { get(t).id }
#[deriving(Clone, Eq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
pub struct BareFnTy {
pub fn_style: ast::FnStyle,
pub abi: abi::Abi,
pub sig: FnSig,
}
#[deriving(Clone, Eq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
pub struct ClosureTy {
pub fn_style: ast::FnStyle,
pub onceness: ast::Onceness,
@ -443,7 +443,7 @@ pub struct ClosureTy {
* - `output` is the return type.
* - `variadic` indicates whether this is a varidic function. (only true for foreign fns)
*/
#[deriving(Clone, Eq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
pub struct FnSig {
pub binder_id: ast::NodeId,
pub inputs: Vec<t>,
@ -451,14 +451,14 @@ pub struct FnSig {
pub variadic: bool
}
#[deriving(Clone, Eq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
pub struct param_ty {
pub idx: uint,
pub def_id: DefId
}
/// Representation of regions:
#[deriving(Clone, Eq, TotalEq, Hash, Encodable, Decodable, Show)]
#[deriving(Clone, PartialEq, TotalEq, Hash, Encodable, Decodable, Show)]
pub enum Region {
// Region bound in a type or fn declaration which will be
// substituted 'early' -- that is, at the same time when type
@ -499,13 +499,13 @@ pub enum Region {
* the original var id (that is, the root variable that is referenced
* by the upvar) and the id of the closure expression.
*/
#[deriving(Clone, Eq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
pub struct UpvarId {
pub var_id: ast::NodeId,
pub closure_expr_id: ast::NodeId,
}
#[deriving(Clone, Eq, TotalEq, Hash, Show)]
#[deriving(Clone, PartialEq, TotalEq, Hash, Show)]
pub enum BorrowKind {
/// Data must be immutable and is aliasable.
ImmBorrow,
@ -600,7 +600,7 @@ pub enum BorrowKind {
* the closure, so sometimes it is necessary for them to be larger
* than the closure lifetime itself.
*/
#[deriving(Eq, Clone)]
#[deriving(PartialEq, Clone)]
pub struct UpvarBorrow {
pub kind: BorrowKind,
pub region: ty::Region,
@ -618,13 +618,13 @@ impl Region {
}
}
#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd, Hash, Encodable, Decodable, Show)]
#[deriving(Clone, PartialEq, PartialOrd, TotalEq, TotalOrd, Hash, Encodable, Decodable, Show)]
pub struct FreeRegion {
pub scope_id: NodeId,
pub bound_region: BoundRegion
}
#[deriving(Clone, Eq, Ord, TotalEq, TotalOrd, Hash, Encodable, Decodable, Show)]
#[deriving(Clone, PartialEq, PartialOrd, TotalEq, TotalOrd, Hash, Encodable, Decodable, Show)]
pub enum BoundRegion {
/// An anonymous region parameter for a given fn (&T)
BrAnon(uint),
@ -643,7 +643,7 @@ pub enum BoundRegion {
* Represents the values to use when substituting lifetime parameters.
* If the value is `ErasedRegions`, then this subst is occurring during
* trans, and all region parameters will be replaced with `ty::ReStatic`. */
#[deriving(Clone, Eq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
pub enum RegionSubsts {
ErasedRegions,
NonerasedRegions(OwnedSlice<ty::Region>)
@ -666,7 +666,7 @@ pub enum RegionSubsts {
* - `self_ty` is the type to which `self` should be remapped, if any. The
* `self` type is rather funny in that it can only appear on traits and is
* always substituted away to the implementing type for a trait. */
#[deriving(Clone, Eq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
pub struct substs {
pub self_ty: Option<ty::t>,
pub tps: Vec<t>,
@ -722,7 +722,7 @@ mod primitives {
// NB: If you change this, you'll probably want to change the corresponding
// AST structure in libsyntax/ast.rs as well.
#[deriving(Clone, Eq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
pub enum sty {
ty_nil,
ty_bot,
@ -754,7 +754,7 @@ pub enum sty {
// on non-useful type error messages)
}
#[deriving(Clone, Eq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
pub struct TyTrait {
pub def_id: DefId,
pub substs: substs,
@ -762,13 +762,13 @@ pub struct TyTrait {
pub bounds: BuiltinBounds
}
#[deriving(Eq, TotalEq, Hash)]
#[deriving(PartialEq, TotalEq, Hash)]
pub struct TraitRef {
pub def_id: DefId,
pub substs: substs
}
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub enum IntVarValue {
IntType(ast::IntTy),
UintType(ast::UintTy),
@ -822,7 +822,7 @@ pub enum type_err {
terr_variadic_mismatch(expected_found<bool>)
}
#[deriving(Eq, TotalEq, Hash)]
#[deriving(PartialEq, TotalEq, Hash)]
pub struct ParamBounds {
pub builtin_bounds: BuiltinBounds,
pub trait_bounds: Vec<Rc<TraitRef>>
@ -830,7 +830,7 @@ pub struct ParamBounds {
pub type BuiltinBounds = EnumSet<BuiltinBound>;
#[deriving(Clone, Encodable, Eq, TotalEq, Decodable, Hash, Show)]
#[deriving(Clone, Encodable, PartialEq, TotalEq, Decodable, Hash, Show)]
#[repr(uint)]
pub enum BuiltinBound {
BoundStatic,
@ -862,21 +862,21 @@ impl CLike for BuiltinBound {
}
}
#[deriving(Clone, Eq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
pub struct TyVid(pub uint);
#[deriving(Clone, Eq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
pub struct IntVid(pub uint);
#[deriving(Clone, Eq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
pub struct FloatVid(pub uint);
#[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
pub struct RegionVid {
pub id: uint
}
#[deriving(Clone, Eq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
pub enum InferTy {
TyVar(TyVid),
IntVar(IntVid),
@ -889,7 +889,7 @@ pub enum InferRegion {
ReSkolemized(uint, BoundRegion)
}
impl cmp::Eq for InferRegion {
impl cmp::PartialEq for InferRegion {
fn eq(&self, other: &InferRegion) -> bool {
match ((*self), *other) {
(ReVar(rva), ReVar(rvb)) => {
@ -2402,7 +2402,7 @@ pub fn is_instantiable(cx: &ctxt, r_ty: t) -> bool {
/// distinguish between types that are recursive with themselves and types that
/// contain a different recursive type. These cases can therefore be treated
/// differently when reporting errors.
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum Representability {
Representable,
SelfRecursive,

2
src/librustc/middle/typeck/check/_match.rs
View file

@ -758,7 +758,7 @@ pub fn check_pointer_pat(pcx: &pat_ctxt,
}
}
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum PointerKind {
Send,
Borrowed,

6
src/librustc/middle/typeck/check/method.rs
View file

@ -106,19 +106,19 @@ use syntax::codemap::Span;
use syntax::parse::token;
use syntax::owned_slice::OwnedSlice;
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum CheckTraitsFlag {
CheckTraitsOnly,
CheckTraitsAndInherentMethods,
}
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum AutoderefReceiverFlag {
AutoderefReceiver,
DontAutoderefReceiver,
}
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum StaticMethodsFlag {
ReportStaticMethods,
IgnoreStaticMethods,

2
src/librustc/middle/typeck/check/mod.rs
View file

@ -213,7 +213,7 @@ impl FnStyleState {
/// Whether `check_binop` is part of an assignment or not.
/// Used to know wether we allow user overloads and to print
/// better messages on error.
#[deriving(Eq)]
#[deriving(PartialEq)]
enum IsBinopAssignment{
SimpleBinop,
BinopAssignment,

20
src/librustc/middle/typeck/infer/lattice.rs
View file

@ -72,19 +72,19 @@ impl LatticeValue for ty::t {
pub trait CombineFieldsLatticeMethods {
fn var_sub_var<T:Clone + InferStr + LatticeValue,
V:Clone + Eq + ToStr + Vid + UnifyVid<Bounds<T>>>(&self,
V:Clone + PartialEq + ToStr + Vid + UnifyVid<Bounds<T>>>(&self,
a_id: V,
b_id: V)
-> ures;
/// make variable a subtype of T
fn var_sub_t<T:Clone + InferStr + LatticeValue,
V:Clone + Eq + ToStr + Vid + UnifyVid<Bounds<T>>>(
V:Clone + PartialEq + ToStr + Vid + UnifyVid<Bounds<T>>>(
&self,
a_id: V,
b: T)
-> ures;
fn t_sub_var<T:Clone + InferStr + LatticeValue,
V:Clone + Eq + ToStr + Vid + UnifyVid<Bounds<T>>>(
V:Clone + PartialEq + ToStr + Vid + UnifyVid<Bounds<T>>>(
&self,
a: T,
b_id: V)
@ -96,7 +96,7 @@ pub trait CombineFieldsLatticeMethods {
lattice_op: LatticeOp<T>)
-> cres<Bound<T>>;
fn set_var_to_merged_bounds<T:Clone + InferStr + LatticeValue,
V:Clone+Eq+ToStr+Vid+UnifyVid<Bounds<T>>>(
V:Clone+PartialEq+ToStr+Vid+UnifyVid<Bounds<T>>>(
&self,
v_id: V,
a: &Bounds<T>,
@ -112,7 +112,7 @@ pub trait CombineFieldsLatticeMethods {
impl<'f> CombineFieldsLatticeMethods for CombineFields<'f> {
fn var_sub_var<T:Clone + InferStr + LatticeValue,
V:Clone + Eq + ToStr + Vid + UnifyVid<Bounds<T>>>(
V:Clone + PartialEq + ToStr + Vid + UnifyVid<Bounds<T>>>(
&self,
a_id: V,
b_id: V)
@ -165,7 +165,7 @@ impl<'f> CombineFieldsLatticeMethods for CombineFields<'f> {
/// make variable a subtype of T
fn var_sub_t<T:Clone + InferStr + LatticeValue,
V:Clone + Eq + ToStr + Vid + UnifyVid<Bounds<T>>>(
V:Clone + PartialEq + ToStr + Vid + UnifyVid<Bounds<T>>>(
&self,
a_id: V,
b: T)
@ -189,7 +189,7 @@ impl<'f> CombineFieldsLatticeMethods for CombineFields<'f> {
}
fn t_sub_var<T:Clone + InferStr + LatticeValue,
V:Clone + Eq + ToStr + Vid + UnifyVid<Bounds<T>>>(
V:Clone + PartialEq + ToStr + Vid + UnifyVid<Bounds<T>>>(
&self,
a: T,
b_id: V)
@ -238,7 +238,7 @@ impl<'f> CombineFieldsLatticeMethods for CombineFields<'f> {
}
fn set_var_to_merged_bounds<T:Clone + InferStr + LatticeValue,
V:Clone+Eq+ToStr+Vid+UnifyVid<Bounds<T>>>(
V:Clone+PartialEq+ToStr+Vid+UnifyVid<Bounds<T>>>(
&self,
v_id: V,
a: &Bounds<T>,
@ -432,7 +432,7 @@ pub enum LatticeVarResult<V,T> {
* return. */
pub fn lattice_vars<L:LatticeDir + Combine,
T:Clone + InferStr + LatticeValue,
V:Clone + Eq + ToStr + Vid + UnifyVid<Bounds<T>>>(
V:Clone + PartialEq + ToStr + Vid + UnifyVid<Bounds<T>>>(
this: &L, // defines whether we want LUB or GLB
a_vid: V, // first variable
b_vid: V, // second variable
@ -478,7 +478,7 @@ pub fn lattice_vars<L:LatticeDir + Combine,
pub fn lattice_var_and_t<L:LatticeDir + Combine,
T:Clone + InferStr + LatticeValue,
V:Clone + Eq + ToStr + Vid + UnifyVid<Bounds<T>>>(
V:Clone + PartialEq + ToStr + Vid + UnifyVid<Bounds<T>>>(
this: &L,
a_id: V,
b: &T,

2
src/librustc/middle/typeck/infer/mod.rs
View file

@ -456,7 +456,7 @@ trait CresCompare<T> {
fn compare(&self, t: T, f: || -> ty::type_err) -> cres<T>;
}
impl<T:Clone + Eq> CresCompare<T> for cres<T> {
impl<T:Clone + PartialEq> CresCompare<T> for cres<T> {
fn compare(&self, t: T, f: || -> ty::type_err) -> cres<T> {
(*self).clone().and_then(|s| {
if s == t {

6
src/librustc/middle/typeck/infer/region_inference/mod.rs
View file

@ -31,7 +31,7 @@ use syntax::ast;
mod doc;
#[deriving(Eq, TotalEq, Hash)]
#[deriving(PartialEq, TotalEq, Hash)]
pub enum Constraint {
ConstrainVarSubVar(RegionVid, RegionVid),
ConstrainRegSubVar(Region, RegionVid),
@ -39,7 +39,7 @@ pub enum Constraint {
ConstrainRegSubReg(Region, Region),
}
#[deriving(Eq, TotalEq, Hash)]
#[deriving(PartialEq, TotalEq, Hash)]
pub struct TwoRegions {
a: Region,
b: Region,
@ -759,7 +759,7 @@ impl<'a> RegionVarBindings<'a> {
// ______________________________________________________________________
#[deriving(Eq, Show)]
#[deriving(PartialEq, Show)]
enum Classification { Expanding, Contracting }
pub enum VarValue { NoValue, Value(Region), ErrorValue }

22
src/librustc/middle/typeck/infer/unify.rs
View file

@ -52,7 +52,7 @@ pub trait UnifyVid<T> {
pub trait UnifyInferCtxtMethods {
fn get<T:Clone,
V:Clone + Eq + Vid + UnifyVid<T>>(
V:Clone + PartialEq + Vid + UnifyVid<T>>(
&self,
vid: V)
-> Node<V, T>;
@ -71,7 +71,7 @@ pub trait UnifyInferCtxtMethods {
impl<'a> UnifyInferCtxtMethods for InferCtxt<'a> {
fn get<T:Clone,
V:Clone + Eq + Vid + UnifyVid<T>>(
V:Clone + PartialEq + Vid + UnifyVid<T>>(
&self,
vid: V)
-> Node<V, T> {
@ -86,7 +86,7 @@ impl<'a> UnifyInferCtxtMethods for InferCtxt<'a> {
let vb = UnifyVid::appropriate_vals_and_bindings(self);
return helper(tcx, &mut *vb.borrow_mut(), vid);
fn helper<T:Clone, V:Clone+Eq+Vid>(
fn helper<T:Clone, V:Clone+PartialEq+Vid>(
tcx: &ty::ctxt,
vb: &mut ValsAndBindings<V,T>,
vid: V) -> Node<V, T>
@ -191,15 +191,15 @@ pub fn mk_err<T:SimplyUnifiable>(a_is_expected: bool,
}
pub trait InferCtxtMethods {
fn simple_vars<T:Clone + Eq + InferStr + SimplyUnifiable,
V:Clone + Eq + Vid + ToStr + UnifyVid<Option<T>>>(
fn simple_vars<T:Clone + PartialEq + InferStr + SimplyUnifiable,
V:Clone + PartialEq + Vid + ToStr + UnifyVid<Option<T>>>(
&self,
a_is_expected: bool,
a_id: V,
b_id: V)
-> ures;
fn simple_var_t<T:Clone + Eq + InferStr + SimplyUnifiable,
V:Clone + Eq + Vid + ToStr + UnifyVid<Option<T>>>(
fn simple_var_t<T:Clone + PartialEq + InferStr + SimplyUnifiable,
V:Clone + PartialEq + Vid + ToStr + UnifyVid<Option<T>>>(
&self,
a_is_expected: bool,
a_id: V,
@ -208,8 +208,8 @@ pub trait InferCtxtMethods {
}
impl<'a> InferCtxtMethods for InferCtxt<'a> {
fn simple_vars<T:Clone + Eq + InferStr + SimplyUnifiable,
V:Clone + Eq + Vid + ToStr + UnifyVid<Option<T>>>(
fn simple_vars<T:Clone + PartialEq + InferStr + SimplyUnifiable,
V:Clone + PartialEq + Vid + ToStr + UnifyVid<Option<T>>>(
&self,
a_is_expected: bool,
a_id: V,
@ -248,8 +248,8 @@ impl<'a> InferCtxtMethods for InferCtxt<'a> {
return uok();
}
fn simple_var_t<T:Clone + Eq + InferStr + SimplyUnifiable,
V:Clone + Eq + Vid + ToStr + UnifyVid<Option<T>>>(
fn simple_var_t<T:Clone + PartialEq + InferStr + SimplyUnifiable,
V:Clone + PartialEq + Vid + ToStr + UnifyVid<Option<T>>>(
&self,
a_is_expected: bool,
a_id: V,

4
src/librustc/middle/typeck/mod.rs
View file

@ -84,7 +84,7 @@ pub mod collect;
pub mod coherence;
pub mod variance;
#[deriving(Clone, Encodable, Decodable, Eq, Ord)]
#[deriving(Clone, Encodable, Decodable, PartialEq, PartialOrd)]
pub enum param_index {
param_numbered(uint),
param_self
@ -147,7 +147,7 @@ pub struct MethodCallee {
pub substs: ty::substs
}
#[deriving(Clone, Eq, TotalEq, Hash, Show)]
#[deriving(Clone, PartialEq, TotalEq, Hash, Show)]
pub struct MethodCall {
pub expr_id: ast::NodeId,
pub autoderef: u32

6
src/librustdoc/clean/mod.rs
View file

@ -490,7 +490,7 @@ impl Clean<Option<Vec<TyParamBound>>> for ty::substs {
}
}
#[deriving(Clone, Encodable, Decodable, Eq)]
#[deriving(Clone, Encodable, Decodable, PartialEq)]
pub struct Lifetime(String);
impl Lifetime {
@ -631,7 +631,7 @@ impl Clean<Item> for ast::TypeMethod {
}
}
#[deriving(Clone, Encodable, Decodable, Eq)]
#[deriving(Clone, Encodable, Decodable, PartialEq)]
pub enum SelfTy {
SelfStatic,
SelfValue,
@ -1458,7 +1458,7 @@ impl Clean<Item> for doctree::Static {
}
}
#[deriving(Show, Clone, Encodable, Decodable, Eq)]
#[deriving(Show, Clone, Encodable, Decodable, PartialEq)]
pub enum Mutability {
Mutable,
Immutable,

2
src/librustdoc/html/item_type.rs
View file

@ -19,7 +19,7 @@ use clean;
/// discriminants. JavaScript then is used to decode them into the original value.
/// Consequently, every change to this type should be synchronized to
/// the `itemTypes` mapping table in `static/main.js`.
#[deriving(Eq, Clone)]
#[deriving(PartialEq, Clone)]
pub enum ItemType {
Module = 0,
Struct = 1,

6
src/librustdoc/html/toc.rs
View file

@ -14,7 +14,7 @@ use std::fmt;
use std::string::String;
/// A (recursive) table of contents
#[deriving(Eq)]
#[deriving(PartialEq)]
pub struct Toc {
/// The levels are strictly decreasing, i.e.
///
@ -36,7 +36,7 @@ impl Toc {
}
}
#[deriving(Eq)]
#[deriving(PartialEq)]
pub struct TocEntry {
level: u32,
sec_number: String,
@ -46,7 +46,7 @@ pub struct TocEntry {
}
/// Progressive construction of a table of contents.
#[deriving(Eq)]
#[deriving(PartialEq)]
pub struct TocBuilder {
top_level: Toc,
/// The current heirachy of parent headings, the levels are

4
src/librustuv/timeout.rs
View file

@ -34,14 +34,14 @@ pub struct Guard<'a> {
pub can_timeout: bool,
}
#[deriving(Eq)]
#[deriving(PartialEq)]
enum TimeoutState {
NoTimeout,
TimeoutPending(ClientState),
TimedOut,
}
#[deriving(Eq)]
#[deriving(PartialEq)]
enum ClientState {
NoWaiter,
AccessPending,

8
src/librustuv/uvll.rs
View file

@ -254,7 +254,7 @@ pub type uv_shutdown_cb = extern "C" fn(req: *uv_shutdown_t, status: c_int);
#[cfg(windows)] pub type uv_gid_t = libc::c_uchar;
#[repr(C)]
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum uv_handle_type {
UV_UNKNOWN_HANDLE,
UV_ASYNC,
@ -279,7 +279,7 @@ pub enum uv_handle_type {
#[repr(C)]
#[cfg(unix)]
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum uv_req_type {
UV_UNKNOWN_REQ,
UV_REQ,
@ -297,7 +297,7 @@ pub enum uv_req_type {
// See UV_REQ_TYPE_PRIVATE at libuv/include/uv-win.h
#[repr(C)]
#[cfg(windows)]
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum uv_req_type {
UV_UNKNOWN_REQ,
UV_REQ,
@ -320,7 +320,7 @@ pub enum uv_req_type {
}
#[repr(C)]
#[deriving(Eq)]
#[deriving(PartialEq)]
pub enum uv_membership {
UV_LEAVE_GROUP,
UV_JOIN_GROUP

8
src/libsemver/lib.rs
View file

@ -46,14 +46,14 @@ use std::string::String;
/// An identifier in the pre-release or build metadata. If the identifier can
/// be parsed as a decimal value, it will be represented with `Numeric`.
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
#[allow(missing_doc)]
pub enum Identifier {
Numeric(uint),
AlphaNumeric(String)
}
impl cmp::Ord for Identifier {
impl cmp::PartialOrd for Identifier {
#[inline]
fn lt(&self, other: &Identifier) -> bool {
match (self, other) {
@ -115,7 +115,7 @@ impl fmt::Show for Version {
}
}
impl cmp::Eq for Version {
impl cmp::PartialEq for Version {
#[inline]
fn eq(&self, other: &Version) -> bool {
// We should ignore build metadata here, otherwise versions v1 and v2
@ -128,7 +128,7 @@ impl cmp::Eq for Version {
}
}
impl cmp::Ord for Version {
impl cmp::PartialOrd for Version {
#[inline]
fn lt(&self, other: &Version) -> bool {

12
src/libserialize/collection_impls.rs
View file

@ -76,8 +76,8 @@ impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for RingBuf<T> {
impl<
E,
S: Encoder<E>,
K: Encodable<S, E> + Eq + TotalOrd,
V: Encodable<S, E> + Eq
K: Encodable<S, E> + PartialEq + TotalOrd,
V: Encodable<S, E> + PartialEq
> Encodable<S, E> for TreeMap<K, V> {
fn encode(&self, e: &mut S) -> Result<(), E> {
e.emit_map(self.len(), |e| {
@ -95,8 +95,8 @@ impl<
impl<
E,
D: Decoder<E>,
K: Decodable<D, E> + Eq + TotalOrd,
V: Decodable<D, E> + Eq
K: Decodable<D, E> + PartialEq + TotalOrd,
V: Decodable<D, E> + PartialEq
> Decodable<D, E> for TreeMap<K, V> {
fn decode(d: &mut D) -> Result<TreeMap<K, V>, E> {
d.read_map(|d, len| {
@ -114,7 +114,7 @@ impl<
impl<
E,
S: Encoder<E>,
T: Encodable<S, E> + Eq + TotalOrd
T: Encodable<S, E> + PartialEq + TotalOrd
> Encodable<S, E> for TreeSet<T> {
fn encode(&self, s: &mut S) -> Result<(), E> {
s.emit_seq(self.len(), |s| {
@ -131,7 +131,7 @@ impl<
impl<
E,
D: Decoder<E>,
T: Decodable<D, E> + Eq + TotalOrd
T: Decodable<D, E> + PartialEq + TotalOrd
> Decodable<D, E> for TreeSet<T> {
fn decode(d: &mut D) -> Result<TreeSet<T>, E> {
d.read_seq(|d, len| {

24
src/libserialize/json.rs
View file

@ -249,7 +249,7 @@ use Encodable;
use collections::{HashMap, TreeMap};
/// Represents a json value
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub enum Json {
Number(f64),
String(String),
@ -263,7 +263,7 @@ pub type List = Vec<Json>;
pub type Object = TreeMap<String, Json>;
/// The errors that can arise while parsing a JSON stream.
#[deriving(Clone, Eq)]
#[deriving(Clone, PartialEq)]
pub enum ErrorCode {
InvalidSyntax,
InvalidNumber,
@ -283,7 +283,7 @@ pub enum ErrorCode {
NotUtf8,
}
#[deriving(Clone, Eq, Show)]
#[deriving(Clone, PartialEq, Show)]
pub enum ParserError {
/// msg, line, col
SyntaxError(ErrorCode, uint, uint),
@ -293,7 +293,7 @@ pub enum ParserError {
// Builder and Parser have the same errors.
pub type BuilderError = ParserError;
#[deriving(Clone, Eq, Show)]
#[deriving(Clone, PartialEq, Show)]
pub enum DecoderError {
ParseError(ParserError),
ExpectedError(String, String),
@ -975,7 +975,7 @@ impl Json {
}
/// The output of the streaming parser.
#[deriving(Eq, Clone, Show)]
#[deriving(PartialEq, Clone, Show)]
pub enum JsonEvent {
ObjectStart,
ObjectEnd,
@ -988,7 +988,7 @@ pub enum JsonEvent {
Error(ParserError),
}
#[deriving(Eq, Show)]
#[deriving(PartialEq, Show)]
enum ParserState {
// Parse a value in a list, true means first element.
ParseList(bool),
@ -1017,7 +1017,7 @@ pub struct Stack {
/// StackElements compose a Stack.
/// For example, Key("foo"), Key("bar"), Index(3) and Key("x") are the
/// StackElements compositing the stack that represents foo.bar[3].x
#[deriving(Eq, Clone, Show)]
#[deriving(PartialEq, Clone, Show)]
pub enum StackElement<'l> {
Index(u32),
Key(&'l str),
@ -1025,7 +1025,7 @@ pub enum StackElement<'l> {
// Internally, Key elements are stored as indices in a buffer to avoid
// allocating a string for every member of an object.
#[deriving(Eq, Clone, Show)]
#[deriving(PartialEq, Clone, Show)]
enum InternalStackElement {
InternalIndex(u32),
InternalKey(u16, u16), // start, size
@ -2082,7 +2082,7 @@ impl ::Decoder<DecoderError> for Decoder {
}
/// Test if two json values are less than one another
impl Ord for Json {
impl PartialOrd for Json {
fn lt(&self, other: &Json) -> bool {
match *self {
Number(f0) => {
@ -2288,20 +2288,20 @@ mod tests {
use std::io;
use collections::TreeMap;
#[deriving(Eq, Encodable, Decodable, Show)]
#[deriving(PartialEq, Encodable, Decodable, Show)]
enum Animal {
Dog,
Frog(String, int)
}
#[deriving(Eq, Encodable, Decodable, Show)]
#[deriving(PartialEq, Encodable, Decodable, Show)]
struct Inner {
a: (),
b: uint,
c: Vec<String>,
}
#[deriving(Eq, Encodable, Decodable, Show)]
#[deriving(PartialEq, Encodable, Decodable, Show)]
struct Outer {
inner: Vec<Inner>,
}

2
src/libstd/ascii.rs
View file

@ -23,7 +23,7 @@ use to_str::{IntoStr};
use vec::Vec;
/// Datatype to hold one ascii character. It wraps a `u8`, with the highest bit always zero.
#[deriving(Clone, Eq, Ord, TotalOrd, TotalEq, Hash)]
#[deriving(Clone, PartialEq, PartialOrd, TotalOrd, TotalEq, Hash)]
pub struct Ascii { chr: u8 }
impl Ascii {

4
src/libstd/bitflags.rs
View file

@ -78,7 +78,7 @@
//!
//! # Derived traits
//!
//! The `Eq` and `Clone` traits are automatically derived for the `struct` using
//! The `PartialEq` and `Clone` traits are automatically derived for the `struct` using
//! the `deriving` attribute. Additional traits can be derived by providing an
//! explicit `deriving` attribute on `flags`.
//!
@ -112,7 +112,7 @@ macro_rules! bitflags(
($(#[$attr:meta])* flags $BitFlags:ident: $T:ty {
$($(#[$Flag_attr:meta])* static $Flag:ident = $value:expr),+
}) => (
#[deriving(Eq, TotalEq, Clone)]
#[deriving(PartialEq, TotalEq, Clone)]
$(#[$attr])*
pub struct $BitFlags {
bits: $T,

4
src/libstd/c_str.rs
View file

@ -66,7 +66,7 @@ fn main() {
*/
use clone::Clone;
use cmp::Eq;
use cmp::PartialEq;
use container::Container;
use iter::{Iterator, range};
use kinds::marker;
@ -109,7 +109,7 @@ impl Clone for CString {
}
}
impl Eq for CString {
impl PartialEq for CString {
fn eq(&self, other: &CString) -> bool {
if self.buf as uint == other.buf as uint {
true

4
src/libstd/comm/mod.rs
View file

@ -360,7 +360,7 @@ pub struct SyncSender<T> {
/// This enumeration is the list of the possible reasons that try_recv could not
/// return data when called.
#[deriving(Eq, Clone, Show)]
#[deriving(PartialEq, Clone, Show)]
pub enum TryRecvError {
/// This channel is currently empty, but the sender(s) have not yet
/// disconnected, so data may yet become available.
@ -372,7 +372,7 @@ pub enum TryRecvError {
/// This enumeration is the list of the possible error outcomes for the
/// `SyncSender::try_send` method.
#[deriving(Eq, Clone, Show)]
#[deriving(PartialEq, Clone, Show)]
pub enum TrySendError<T> {
/// The data could not be sent on the channel because it would require that
/// the callee block to send the data.

2
src/libstd/io/buffered.rs
View file

@ -378,7 +378,7 @@ mod test {
/// A type, free to create, primarily intended for benchmarking creation of
/// wrappers that, just for construction, don't need a Reader/Writer that
/// does anything useful. Is equivalent to `/dev/null` in semantics.
#[deriving(Clone,Eq,Ord)]
#[deriving(Clone,PartialEq,PartialOrd)]
pub struct NullStream;
impl Reader for NullStream {

8
src/libstd/io/mod.rs
View file

@ -285,7 +285,7 @@ pub type IoResult<T> = Result<T, IoError>;
/// # FIXME
///
/// Is something like this sufficient? It's kind of archaic
#[deriving(Eq, Clone)]
#[deriving(PartialEq, Clone)]
pub struct IoError {
/// An enumeration which can be matched against for determining the flavor
/// of error.
@ -395,7 +395,7 @@ impl fmt::Show for IoError {
}
/// A list specifying general categories of I/O error.
#[deriving(Eq, Clone, Show)]
#[deriving(PartialEq, Clone, Show)]
pub enum IoErrorKind {
/// Any I/O error not part of this list.
OtherIoError,
@ -1582,7 +1582,7 @@ pub enum FileAccess {
}
/// Different kinds of files which can be identified by a call to stat
#[deriving(Eq, Show, Hash)]
#[deriving(PartialEq, Show, Hash)]
pub enum FileType {
/// This is a normal file, corresponding to `S_IFREG`
TypeFile,
@ -1726,7 +1726,7 @@ mod tests {
use prelude::*;
use uint;
#[deriving(Clone, Eq, Show)]
#[deriving(Clone, PartialEq, Show)]
enum BadReaderBehavior {
GoodBehavior(uint),
BadBehavior(uint)

4
src/libstd/io/net/ip.rs
View file

@ -25,7 +25,7 @@ use slice::{MutableCloneableVector, ImmutableVector, MutableVector};
pub type Port = u16;
#[deriving(Eq, TotalEq, Clone, Hash)]
#[deriving(PartialEq, TotalEq, Clone, Hash)]
pub enum IpAddr {
Ipv4Addr(u8, u8, u8, u8),
Ipv6Addr(u16, u16, u16, u16, u16, u16, u16, u16)
@ -56,7 +56,7 @@ impl fmt::Show for IpAddr {
}
}
#[deriving(Eq, TotalEq, Clone, Hash)]
#[deriving(PartialEq, TotalEq, Clone, Hash)]
pub struct SocketAddr {
pub ip: IpAddr,
pub port: Port,

4
src/libstd/io/process.rs
View file

@ -317,7 +317,7 @@ impl fmt::Show for Command {
}
/// The output of a finished process.
#[deriving(Eq, TotalEq, Clone)]
#[deriving(PartialEq, TotalEq, Clone)]
pub struct ProcessOutput {
/// The status (exit code) of the process.
pub status: ProcessExit,
@ -348,7 +348,7 @@ pub enum StdioContainer {
/// Describes the result of a process after it has terminated.
/// Note that Windows have no signals, so the result is usually ExitStatus.
#[deriving(Eq, TotalEq, Clone)]
#[deriving(PartialEq, TotalEq, Clone)]
pub enum ProcessExit {
/// Normal termination with an exit status.
ExitStatus(int),

Some files were not shown because too many files have changed in this diff Show more