OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

std: Drop Total from Total{Eq,Ord} 

This completes the last stage of the renaming of the comparison hierarchy of
traits. This change renames TotalEq to Eq and TotalOrd to Ord.

In the future the new Eq/Ord will be filled out with their appropriate methods,
but for now this change is purely a renaming change.

[breaking-change]
This commit is contained in:
Alex Crichton 2014-05-31 10:43:52 -07:00
parent c605c2b57b
commit bba701c59d
83 changed files with 436 additions and 431 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/liballoc/owned.rs
View File

@ -12,7 +12,7 @@
use core::any::{Any, AnyRefExt};
use core::clone::Clone;
use core::cmp::{PartialEq, PartialOrd, TotalEq, TotalOrd, Ordering};
use core::cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering};
use core::default::Default;
use core::fmt;
use core::intrinsics;
@ -67,11 +67,11 @@ impl<T:PartialOrd> PartialOrd for Box<T> {
#[inline]
fn gt(&self, other: &Box<T>) -> bool { *(*self) > *(*other) }
}
impl<T: TotalOrd> TotalOrd for Box<T> {
impl<T: Ord> Ord for Box<T> {
#[inline]
fn cmp(&self, other: &Box<T>) -> Ordering { (**self).cmp(*other) }
}
impl<T: TotalEq> TotalEq for Box<T> {}
impl<T: Eq> Eq for Box<T> {}
/// Extension methods for an owning `Any` trait object
pub trait AnyOwnExt {

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::{PartialEq, PartialOrd, TotalEq, TotalOrd, Ordering};
use core::cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering};
use core::kinds::marker;
use core::ops::{Deref, Drop};
use core::option::{Option, Some, None};
@ -157,7 +157,7 @@ impl<T: PartialEq> PartialEq for Rc<T> {
fn ne(&self, other: &Rc<T>) -> bool { **self != **other }
}
impl<T: TotalEq> TotalEq for Rc<T> {}
impl<T: Eq> Eq for Rc<T> {}
impl<T: PartialOrd> PartialOrd for Rc<T> {
#[inline(always)]
@ -173,7 +173,7 @@ impl<T: PartialOrd> PartialOrd for Rc<T> {
fn ge(&self, other: &Rc<T>) -> bool { **self >= **other }
}
impl<T: TotalOrd> TotalOrd for Rc<T> {
impl<T: Ord> Ord for Rc<T> {
#[inline]
fn cmp(&self, other: &Rc<T>) -> Ordering { (**self).cmp(&**other) }
}

96
src/libcollections/btree.rs
View File

@ -29,7 +29,7 @@ pub struct BTree<K, V> {
upper_bound: uint
}
impl<K: TotalOrd, V> BTree<K, V> {
impl<K: Ord, V> BTree<K, V> {
///Returns new BTree with root node (leaf) and user-supplied lower bound
///The lower bound applies to every node except the root node.
@ -59,7 +59,7 @@ impl<K: TotalOrd, V> BTree<K, V> {
//We would probably want to remove the dependence on the Clone trait in the future.
//It is here as a crutch to ensure values can be passed around through the tree's nodes
//especially during insertions and deletions.
impl<K: Clone + TotalOrd, V: Clone> BTree<K, V> {
impl<K: Clone + Ord, V: Clone> BTree<K, V> {
///Returns the value of a given key, which may not exist in the tree.
///Calls the root node's get method.
pub fn get(self, k: K) -> Option<V> {
@ -84,7 +84,7 @@ impl<K: Clone + TotalOrd, V: Clone> BTree<K, V> {
}
}
impl<K: Clone + TotalOrd, V: Clone> Clone for BTree<K, V> {
impl<K: Clone + Ord, V: Clone> Clone for BTree<K, V> {
///Implements the Clone trait for the BTree.
///Uses a helper function/constructor to produce a new BTree.
fn clone(&self) -> BTree<K, V> {
@ -92,28 +92,28 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for BTree<K, V> {
}
}
impl<K: TotalOrd, V: TotalEq> PartialEq for BTree<K, V> {
impl<K: Ord, V: Eq> PartialEq for BTree<K, V> {
fn eq(&self, other: &BTree<K, V>) -> bool {
self.root.cmp(&other.root) == Equal
}
}
impl<K: TotalOrd, V: TotalEq> TotalEq for BTree<K, V> {}
impl<K: Ord, V: Eq> Eq for BTree<K, V> {}
impl<K: TotalOrd, V: TotalEq> PartialOrd for BTree<K, V> {
impl<K: Ord, V: Eq> PartialOrd for BTree<K, V> {
fn lt(&self, other: &BTree<K, V>) -> bool {
self.cmp(other) == Less
}
}
impl<K: TotalOrd, V: TotalEq> TotalOrd for BTree<K, V> {
impl<K: Ord, V: Eq> Ord for BTree<K, V> {
///Returns an ordering based on the root nodes of each BTree.
fn cmp(&self, other: &BTree<K, V>) -> Ordering {
self.root.cmp(&other.root)
}
}
impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for BTree<K, V> {
impl<K: fmt::Show + Ord, V: fmt::Show> fmt::Show for BTree<K, V> {
///Returns a string representation of the BTree
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
self.root.fmt(f)
@ -133,7 +133,7 @@ enum Node<K, V> {
//Node functions/methods
impl<K: TotalOrd, V> Node<K, V> {
impl<K: Ord, V> Node<K, V> {
///Creates a new leaf node given a vector of elements.
fn new_leaf(vec: Vec<LeafElt<K, V>>) -> Node<K,V> {
LeafNode(Leaf::new(vec))
@ -164,7 +164,7 @@ impl<K: TotalOrd, V> Node<K, V> {
}
}
impl<K: Clone + TotalOrd, V: Clone> Node<K, V> {
impl<K: Clone + Ord, V: Clone> Node<K, V> {
///Returns the corresponding value to the provided key.
///get() is called in different ways on a branch or a leaf.
fn get(&self, k: K) -> Option<V> {
@ -183,7 +183,7 @@ impl<K: Clone + TotalOrd, V: Clone> Node<K, V> {
}
}
impl<K: Clone + TotalOrd, V: Clone> Clone for Node<K, V> {
impl<K: Clone + Ord, V: Clone> Clone for Node<K, V> {
///Returns a new node based on whether or not it is a branch or a leaf.
fn clone(&self) -> Node<K, V> {
match *self {
@ -198,7 +198,7 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for Node<K, V> {
}
}
impl<K: TotalOrd, V: TotalEq> PartialEq for Node<K, V> {
impl<K: Ord, V: Eq> PartialEq for Node<K, V> {
fn eq(&self, other: &Node<K, V>) -> bool {
match *self{
BranchNode(ref branch) => {
@ -220,16 +220,16 @@ impl<K: TotalOrd, V: TotalEq> PartialEq for Node<K, V> {
}
}
impl<K: TotalOrd, V: TotalEq> TotalEq for Node<K, V> {}
impl<K: Ord, V: Eq> Eq for Node<K, V> {}
impl<K: TotalOrd, V: TotalEq> PartialOrd for Node<K, V> {
impl<K: Ord, V: Eq> PartialOrd for Node<K, V> {
fn lt(&self, other: &Node<K, V>) -> bool {
self.cmp(other) == Less
}
}
impl<K: TotalOrd, V: TotalEq> TotalOrd for Node<K, V> {
///Implementation of TotalOrd for Nodes.
impl<K: Ord, V: Eq> Ord for Node<K, V> {
///Implementation of Ord for Nodes.
fn cmp(&self, other: &Node<K, V>) -> Ordering {
match *self {
LeafNode(ref leaf) => {
@ -248,7 +248,7 @@ impl<K: TotalOrd, V: TotalEq> TotalOrd for Node<K, V> {
}
}
impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for Node<K, V> {
impl<K: fmt::Show + Ord, V: fmt::Show> fmt::Show for Node<K, V> {
///Returns a string representation of a Node.
///Will iterate over the Node and show "Key: x, value: y, child: () // "
///for all elements in the Node. "Child" only exists if the Node contains
@ -275,7 +275,7 @@ struct Branch<K, V> {
}
impl<K: TotalOrd, V> Leaf<K, V> {
impl<K: Ord, V> Leaf<K, V> {
///Creates a new Leaf from a vector of LeafElts.
fn new(vec: Vec<LeafElt<K, V>>) -> Leaf<K, V> {
Leaf {
@ -335,7 +335,7 @@ impl<K: TotalOrd, V> Leaf<K, V> {
}
impl<K: Clone + TotalOrd, V: Clone> Leaf<K, V> {
impl<K: Clone + Ord, V: Clone> Leaf<K, V> {
///Returns the corresponding value to the supplied key.
fn get(&self, k: K) -> Option<V> {
for s in self.elts.iter() {
@ -386,28 +386,28 @@ impl<K: Clone + TotalOrd, V: Clone> Leaf<K, V> {
}
}
impl<K: Clone + TotalOrd, V: Clone> Clone for Leaf<K, V> {
impl<K: Clone + Ord, V: Clone> Clone for Leaf<K, V> {
///Returns a new Leaf with the same elts.
fn clone(&self) -> Leaf<K, V> {
Leaf::new(self.elts.clone())
}
}
impl<K: TotalOrd, V: TotalEq> PartialEq for Leaf<K, V> {
impl<K: Ord, V: Eq> PartialEq for Leaf<K, V> {
fn eq(&self, other: &Leaf<K, V>) -> bool {
self.elts == other.elts
}
}
impl<K: TotalOrd, V: TotalEq> TotalEq for Leaf<K, V> {}
impl<K: Ord, V: Eq> Eq for Leaf<K, V> {}
impl<K: TotalOrd, V: TotalEq> PartialOrd for Leaf<K, V> {
impl<K: Ord, V: Eq> PartialOrd for Leaf<K, V> {
fn lt(&self, other: &Leaf<K, V>) -> bool {
self.cmp(other) == Less
}
}
impl<K: TotalOrd, V: TotalEq> TotalOrd for Leaf<K, V> {
impl<K: Ord, V: Eq> Ord for Leaf<K, V> {
///Returns an ordering based on the first element of each Leaf.
fn cmp(&self, other: &Leaf<K, V>) -> Ordering {
if self.elts.len() > other.elts.len() {
@ -421,7 +421,7 @@ impl<K: TotalOrd, V: TotalEq> TotalOrd for Leaf<K, V> {
}
impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for Leaf<K, V> {
impl<K: fmt::Show + Ord, V: fmt::Show> fmt::Show for Leaf<K, V> {
///Returns a string representation of a Leaf.
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for (i, s) in self.elts.iter().enumerate() {
@ -433,7 +433,7 @@ impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for Leaf<K, V> {
}
impl<K: TotalOrd, V> Branch<K, V> {
impl<K: Ord, V> Branch<K, V> {
///Creates a new Branch from a vector of BranchElts and a rightmost child (a node).
fn new(vec: Vec<BranchElt<K, V>>, right: Box<Node<K, V>>)
-> Branch<K, V> {
@ -492,7 +492,7 @@ impl<K: TotalOrd, V> Branch<K, V> {
}
}
impl<K: Clone + TotalOrd, V: Clone> Branch<K, V> {
impl<K: Clone + Ord, V: Clone> Branch<K, V> {
///Returns the corresponding value to the supplied key.
///If the key is not there, find the child that might hold it.
fn get(&self, k: K) -> Option<V> {
@ -616,28 +616,28 @@ impl<K: Clone + TotalOrd, V: Clone> Branch<K, V> {
}
}
impl<K: Clone + TotalOrd, V: Clone> Clone for Branch<K, V> {
impl<K: Clone + Ord, V: Clone> Clone for Branch<K, V> {
///Returns a new branch using the clone methods of the Branch's internal variables.
fn clone(&self) -> Branch<K, V> {
Branch::new(self.elts.clone(), self.rightmost_child.clone())
}
}
impl<K: TotalOrd, V: TotalEq> PartialEq for Branch<K, V> {
impl<K: Ord, V: Eq> PartialEq for Branch<K, V> {
fn eq(&self, other: &Branch<K, V>) -> bool {
self.elts == other.elts
}
}
impl<K: TotalOrd, V: TotalEq> TotalEq for Branch<K, V> {}
impl<K: Ord, V: Eq> Eq for Branch<K, V> {}
impl<K: TotalOrd, V: TotalEq> PartialOrd for Branch<K, V> {
impl<K: Ord, V: Eq> PartialOrd for Branch<K, V> {
fn lt(&self, other: &Branch<K, V>) -> bool {
self.cmp(other) == Less
}
}
impl<K: TotalOrd, V: TotalEq> TotalOrd for Branch<K, V> {
impl<K: Ord, V: Eq> Ord for Branch<K, V> {
///Compares the first elements of two branches to determine an ordering
fn cmp(&self, other: &Branch<K, V>) -> Ordering {
if self.elts.len() > other.elts.len() {
@ -650,7 +650,7 @@ impl<K: TotalOrd, V: TotalEq> TotalOrd for Branch<K, V> {
}
}
impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for Branch<K, V> {
impl<K: fmt::Show + Ord, V: fmt::Show> fmt::Show for Branch<K, V> {
///Returns a string representation of a Branch.
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for (i, s) in self.elts.iter().enumerate() {
@ -674,7 +674,7 @@ struct BranchElt<K, V> {
value: V
}
impl<K: TotalOrd, V> LeafElt<K, V> {
impl<K: Ord, V> LeafElt<K, V> {
///Creates a new LeafElt from a supplied key-value pair.
fn new(k: K, v: V) -> LeafElt<K, V> {
LeafElt {
@ -684,42 +684,42 @@ impl<K: TotalOrd, V> LeafElt<K, V> {
}
}
impl<K: Clone + TotalOrd, V: Clone> Clone for LeafElt<K, V> {
impl<K: Clone + Ord, V: Clone> Clone for LeafElt<K, V> {
///Returns a new LeafElt by cloning the key and value.
fn clone(&self) -> LeafElt<K, V> {
LeafElt::new(self.key.clone(), self.value.clone())
}
}
impl<K: TotalOrd, V: TotalEq> PartialEq for LeafElt<K, V> {
impl<K: Ord, V: Eq> PartialEq for LeafElt<K, V> {
fn eq(&self, other: &LeafElt<K, V>) -> bool {
self.key == other.key && self.value == other.value
}
}
impl<K: TotalOrd, V: TotalEq> TotalEq for LeafElt<K, V> {}
impl<K: Ord, V: Eq> Eq for LeafElt<K, V> {}
impl<K: TotalOrd, V: TotalEq> PartialOrd for LeafElt<K, V> {
impl<K: Ord, V: Eq> PartialOrd for LeafElt<K, V> {
fn lt(&self, other: &LeafElt<K, V>) -> bool {
self.cmp(other) == Less
}
}
impl<K: TotalOrd, V: TotalEq> TotalOrd for LeafElt<K, V> {
impl<K: Ord, V: Eq> Ord for LeafElt<K, V> {
///Returns an ordering based on the keys of the LeafElts.
fn cmp(&self, other: &LeafElt<K, V>) -> Ordering {
self.key.cmp(&other.key)
}
}
impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for LeafElt<K, V> {
impl<K: fmt::Show + Ord, V: fmt::Show> fmt::Show for LeafElt<K, V> {
///Returns a string representation of a LeafElt.
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Key: {}, value: {};", self.key, self.value)
}
}
impl<K: TotalOrd, V> BranchElt<K, V> {
impl<K: Ord, V> BranchElt<K, V> {
///Creates a new BranchElt from a supplied key, value, and left child.
fn new(k: K, v: V, n: Box<Node<K, V>>) -> BranchElt<K, V> {
BranchElt {
@ -731,7 +731,7 @@ impl<K: TotalOrd, V> BranchElt<K, V> {
}
impl<K: Clone + TotalOrd, V: Clone> Clone for BranchElt<K, V> {
impl<K: Clone + Ord, V: Clone> Clone for BranchElt<K, V> {
///Returns a new BranchElt by cloning the key, value, and left child.
fn clone(&self) -> BranchElt<K, V> {
BranchElt::new(self.key.clone(),
@ -740,28 +740,28 @@ impl<K: Clone + TotalOrd, V: Clone> Clone for BranchElt<K, V> {
}
}
impl<K: TotalOrd, V: TotalEq> PartialEq for BranchElt<K, V>{
impl<K: Ord, V: Eq> PartialEq for BranchElt<K, V>{
fn eq(&self, other: &BranchElt<K, V>) -> bool {
self.key == other.key && self.value == other.value
}
}
impl<K: TotalOrd, V: TotalEq> TotalEq for BranchElt<K, V>{}
impl<K: Ord, V: Eq> Eq for BranchElt<K, V>{}
impl<K: TotalOrd, V: TotalEq> PartialOrd for BranchElt<K, V> {
impl<K: Ord, V: Eq> PartialOrd for BranchElt<K, V> {
fn lt(&self, other: &BranchElt<K, V>) -> bool {
self.cmp(other) == Less
}
}
impl<K: TotalOrd, V: TotalEq> TotalOrd for BranchElt<K, V> {
///Fulfills TotalOrd for BranchElts
impl<K: Ord, V: Eq> Ord for BranchElt<K, V> {
///Fulfills Ord for BranchElts
fn cmp(&self, other: &BranchElt<K, V>) -> Ordering {
self.key.cmp(&other.key)
}
}
impl<K: fmt::Show + TotalOrd, V: fmt::Show> fmt::Show for BranchElt<K, V> {
impl<K: fmt::Show + Ord, V: fmt::Show> fmt::Show for BranchElt<K, V> {
/// Returns string containing key, value, and child (which should recur to a
/// leaf) Consider changing in future to be more readable.
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

2
src/libcollections/dlist.rs
View File

@ -388,7 +388,7 @@ impl<T> DList<T> {
}
}
impl<T: TotalOrd> DList<T> {
impl<T: Ord> DList<T> {
/// Insert `elt` sorted in ascending order
///
/// O(N)

2
src/libcollections/enum_set.rs
View File

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

52
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::{PartialEq, TotalEq, Equiv, max};
use std::cmp::{PartialEq, Eq, Equiv, max};
use std::default::Default;
use std::fmt;
use std::fmt::Show;
@ -733,7 +733,7 @@ fn grow_at(capacity: uint, load_factor: Fraction) -> uint {
fraction_mul(capacity, load_factor)
}
impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
/// Get the number of elements which will force the capacity to shrink.
/// When size == self.shrink_at(), we halve the capacity.
fn shrink_at(&self) -> uint {
@ -925,12 +925,12 @@ impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
}
}
impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S>> Container for HashMap<K, V, H> {
impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> Container for HashMap<K, V, H> {
/// Return the number of elements in the map
fn len(&self) -> uint { self.table.size() }
}
impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S>> Mutable for HashMap<K, V, H> {
impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> Mutable for HashMap<K, V, H> {
/// Clear the map, removing all key-value pairs.
fn clear(&mut self) {
self.minimum_capacity = self.table.size();
@ -945,7 +945,7 @@ impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S>> Mutable for HashMap<K, V, H> {
}
impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S>> Map<K, V> for HashMap<K, V, H> {
impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> Map<K, V> for HashMap<K, V, H> {
fn find<'a>(&'a self, k: &K) -> Option<&'a V> {
self.search(k).map(|idx| {
let (_, v) = self.table.read(&idx);
@ -958,7 +958,7 @@ impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S>> Map<K, V> for HashMap<K, V, H> {
}
}
impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S>> MutableMap<K, V> for HashMap<K, V, H> {
impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> MutableMap<K, V> for HashMap<K, V, H> {
fn find_mut<'a>(&'a mut self, k: &K) -> Option<&'a mut V> {
match self.search(k) {
None => None,
@ -1027,7 +1027,7 @@ impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S>> MutableMap<K, V> for HashMap<K, V
}
impl<K: Hash + TotalEq, V> HashMap<K, V, sip::SipHasher> {
impl<K: Hash + Eq, V> HashMap<K, V, sip::SipHasher> {
/// Create an empty HashMap.
pub fn new() -> HashMap<K, V, sip::SipHasher> {
HashMap::with_capacity(INITIAL_CAPACITY)
@ -1042,7 +1042,7 @@ impl<K: Hash + TotalEq, V> HashMap<K, V, sip::SipHasher> {
}
}
impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
pub fn with_hasher(hasher: H) -> HashMap<K, V, H> {
HashMap::with_capacity_and_hasher(INITIAL_CAPACITY, hasher)
}
@ -1390,7 +1390,7 @@ impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
}
}
impl<K: TotalEq + Hash<S>, V: Clone, S, H: Hasher<S>> HashMap<K, V, H> {
impl<K: Eq + Hash<S>, V: Clone, S, H: Hasher<S>> HashMap<K, V, H> {
/// Like `find`, but returns a copy of the value.
pub fn find_copy(&self, k: &K) -> Option<V> {
self.find(k).map(|v| (*v).clone())
@ -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: PartialEq, S, H: Hasher<S>> PartialEq for HashMap<K, V, H> {
impl<K: Eq + 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; }
@ -1416,7 +1416,7 @@ impl<K: TotalEq + Hash<S>, V: PartialEq, S, H: Hasher<S>> PartialEq for HashMap<
}
}
impl<K: TotalEq + Hash<S> + Show, V: Show, S, H: Hasher<S>> Show for HashMap<K, V, H> {
impl<K: Eq + Hash<S> + Show, V: Show, S, H: Hasher<S>> Show for HashMap<K, V, H> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(write!(f, r"\{"));
@ -1429,7 +1429,7 @@ impl<K: TotalEq + Hash<S> + Show, V: Show, S, H: Hasher<S>> Show for HashMap<K,
}
}
impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S> + Default> Default for HashMap<K, V, H> {
impl<K: Eq + Hash<S>, V, S, H: Hasher<S> + Default> Default for HashMap<K, V, H> {
fn default() -> HashMap<K, V, H> {
HashMap::with_hasher(Default::default())
}
@ -1453,7 +1453,7 @@ pub type Keys<'a, K, V> =
pub type Values<'a, K, V> =
iter::Map<'static, (&'a K, &'a V), &'a V, Entries<'a, K, V>>;
impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S> + Default> FromIterator<(K, V)> for HashMap<K, V, H> {
impl<K: Eq + Hash<S>, V, S, H: Hasher<S> + Default> FromIterator<(K, V)> for HashMap<K, V, H> {
fn from_iter<T: Iterator<(K, V)>>(iter: T) -> HashMap<K, V, H> {
let (lower, _) = iter.size_hint();
let mut map = HashMap::with_capacity_and_hasher(lower, Default::default());
@ -1462,7 +1462,7 @@ impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S> + Default> FromIterator<(K, V)> fo
}
}
impl<K: TotalEq + Hash<S>, V, S, H: Hasher<S> + Default> Extendable<(K, V)> for HashMap<K, V, H> {
impl<K: Eq + Hash<S>, V, S, H: Hasher<S> + Default> Extendable<(K, V)> for HashMap<K, V, H> {
fn extend<T: Iterator<(K, V)>>(&mut self, mut iter: T) {
for (k, v) in iter {
self.insert(k, v);
@ -1486,7 +1486,7 @@ pub struct HashSet<T, H = sip::SipHasher> {
map: HashMap<T, (), H>
}
impl<T: TotalEq + Hash<S>, S, H: Hasher<S>> PartialEq for HashSet<T, H> {
impl<T: Eq + 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; }
@ -1494,15 +1494,15 @@ impl<T: TotalEq + Hash<S>, S, H: Hasher<S>> PartialEq for HashSet<T, H> {
}
}
impl<T: TotalEq + Hash<S>, S, H: Hasher<S>> Container for HashSet<T, H> {
impl<T: Eq + Hash<S>, S, H: Hasher<S>> Container for HashSet<T, H> {
fn len(&self) -> uint { self.map.len() }
}
impl<T: TotalEq + Hash<S>, S, H: Hasher<S>> Mutable for HashSet<T, H> {
impl<T: Eq + Hash<S>, S, H: Hasher<S>> Mutable for HashSet<T, H> {
fn clear(&mut self) { self.map.clear() }
}
impl<T: TotalEq + Hash<S>, S, H: Hasher<S>> Set<T> for HashSet<T, H> {
impl<T: Eq + Hash<S>, S, H: Hasher<S>> Set<T> for HashSet<T, H> {
fn contains(&self, value: &T) -> bool { self.map.contains_key(value) }
fn is_disjoint(&self, other: &HashSet<T, H>) -> bool {
@ -1514,13 +1514,13 @@ impl<T: TotalEq + Hash<S>, S, H: Hasher<S>> Set<T> for HashSet<T, H> {
}
}
impl<T: TotalEq + Hash<S>, S, H: Hasher<S>> MutableSet<T> for HashSet<T, H> {
impl<T: Eq + Hash<S>, S, H: Hasher<S>> MutableSet<T> for HashSet<T, H> {
fn insert(&mut self, value: T) -> bool { self.map.insert(value, ()) }
fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
}
impl<T: Hash + TotalEq> HashSet<T, sip::SipHasher> {
impl<T: Hash + Eq> HashSet<T, sip::SipHasher> {
/// Create an empty HashSet
pub fn new() -> HashSet<T, sip::SipHasher> {
HashSet::with_capacity(INITIAL_CAPACITY)
@ -1533,7 +1533,7 @@ impl<T: Hash + TotalEq> HashSet<T, sip::SipHasher> {
}
}
impl<T: TotalEq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
impl<T: Eq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
pub fn with_hasher(hasher: H) -> HashSet<T, H> {
HashSet::with_capacity_and_hasher(INITIAL_CAPACITY, hasher)
}
@ -1603,7 +1603,7 @@ impl<T: TotalEq + Hash<S>, S, H: Hasher<S>> HashSet<T, H> {
}
}
impl<T: TotalEq + Hash<S> + fmt::Show, S, H: Hasher<S>> fmt::Show for HashSet<T, H> {
impl<T: Eq + Hash<S> + fmt::Show, S, H: Hasher<S>> fmt::Show for HashSet<T, H> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(write!(f, r"\{"));
@ -1616,7 +1616,7 @@ impl<T: TotalEq + Hash<S> + fmt::Show, S, H: Hasher<S>> fmt::Show for HashSet<T,
}
}
impl<T: TotalEq + Hash<S>, S, H: Hasher<S> + Default> FromIterator<T> for HashSet<T, H> {
impl<T: Eq + Hash<S>, S, H: Hasher<S> + Default> FromIterator<T> for HashSet<T, H> {
fn from_iter<I: Iterator<T>>(iter: I) -> HashSet<T, H> {
let (lower, _) = iter.size_hint();
let mut set = HashSet::with_capacity_and_hasher(lower, Default::default());
@ -1625,7 +1625,7 @@ impl<T: TotalEq + Hash<S>, S, H: Hasher<S> + Default> FromIterator<T> for HashSe
}
}
impl<T: TotalEq + Hash<S>, S, H: Hasher<S> + Default> Extendable<T> for HashSet<T, H> {
impl<T: Eq + Hash<S>, S, H: Hasher<S> + Default> Extendable<T> for HashSet<T, H> {
fn extend<I: Iterator<T>>(&mut self, mut iter: I) {
for k in iter {
self.insert(k);
@ -1633,7 +1633,7 @@ impl<T: TotalEq + Hash<S>, S, H: Hasher<S> + Default> Extendable<T> for HashSet<
}
}
impl<T: TotalEq + Hash> Default for HashSet<T, sip::SipHasher> {
impl<T: Eq + Hash> Default for HashSet<T, sip::SipHasher> {
fn default() -> HashSet<T> { HashSet::new() }
}
@ -1691,7 +1691,7 @@ mod test_map {
local_data_key!(drop_vector: RefCell<Vec<int>>)
#[deriving(Hash, PartialEq, TotalEq)]
#[deriving(Hash, PartialEq, Eq)]
struct Dropable {
k: uint
}

10
src/libcollections/lru_cache.rs
View File

@ -73,7 +73,7 @@ impl<K: PartialEq> PartialEq for KeyRef<K> {
}
}
impl<K: TotalEq> TotalEq for KeyRef<K> {}
impl<K: Eq> Eq for KeyRef<K> {}
impl<K, V> LruEntry<K, V> {
fn new(k: K, v: V) -> LruEntry<K, V> {
@ -86,7 +86,7 @@ impl<K, V> LruEntry<K, V> {
}
}
impl<K: Hash + TotalEq, V> LruCache<K, V> {
impl<K: Hash + Eq, V> LruCache<K, V> {
/// Create an LRU Cache that holds at most `capacity` items.
pub fn new(capacity: uint) -> LruCache<K, V> {
let cache = LruCache {
@ -201,7 +201,7 @@ impl<K: Hash + TotalEq, V> LruCache<K, V> {
}
}
impl<A: fmt::Show + Hash + TotalEq, B: fmt::Show> fmt::Show for LruCache<A, B> {
impl<A: fmt::Show + Hash + Eq, B: fmt::Show> fmt::Show for LruCache<A, B> {
/// Return a string that lists the key-value pairs from most-recently
/// used to least-recently used.
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@ -222,14 +222,14 @@ impl<A: fmt::Show + Hash + TotalEq, B: fmt::Show> fmt::Show for LruCache<A, B> {
}
}
impl<K: Hash + TotalEq, V> Container for LruCache<K, V> {
impl<K: Hash + Eq, V> Container for LruCache<K, V> {
/// Return the number of key-value pairs in the cache.
fn len(&self) -> uint {
self.map.len()
}
}
impl<K: Hash + TotalEq, V> Mutable for LruCache<K, V> {
impl<K: Hash + Eq, V> Mutable for LruCache<K, V> {
/// Clear the cache of all key-value pairs.
fn clear(&mut self) {
self.map.clear();

10
src/libcollections/priority_queue.rs
View File

@ -22,17 +22,17 @@ pub struct PriorityQueue<T> {
data: Vec<T>,
}
impl<T: TotalOrd> Container for PriorityQueue<T> {
impl<T: Ord> Container for PriorityQueue<T> {
/// Returns the length of the queue
fn len(&self) -> uint { self.data.len() }
}
impl<T: TotalOrd> Mutable for PriorityQueue<T> {
impl<T: Ord> Mutable for PriorityQueue<T> {
/// Drop all items from the queue
fn clear(&mut self) { self.data.truncate(0) }
}
impl<T: TotalOrd> PriorityQueue<T> {
impl<T: Ord> PriorityQueue<T> {
/// An iterator visiting all values in underlying vector, in
/// arbitrary order.
pub fn iter<'a>(&'a self) -> Items<'a, T> {
@ -214,7 +214,7 @@ impl<'a, T> Iterator<&'a T> for Items<'a, T> {
fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
}
impl<T: TotalOrd> FromIterator<T> for PriorityQueue<T> {
impl<T: Ord> FromIterator<T> for PriorityQueue<T> {
fn from_iter<Iter: Iterator<T>>(iter: Iter) -> PriorityQueue<T> {
let mut q = PriorityQueue::new();
q.extend(iter);
@ -222,7 +222,7 @@ impl<T: TotalOrd> FromIterator<T> for PriorityQueue<T> {
}
}
impl<T: TotalOrd> Extendable<T> for PriorityQueue<T> {
impl<T: Ord> Extendable<T> for PriorityQueue<T> {
fn extend<Iter: Iterator<T>>(&mut self, mut iter: Iter) {
let (lower, _) = iter.size_hint();

80
src/libcollections/treemap.rs
View File

@ -10,7 +10,7 @@
//! An ordered map and set implemented as self-balancing binary search
//! trees. The only requirement for the types is that the key implements
//! `TotalOrd`.
//! `Ord`.
use std::cmp::Ordering;
use std::fmt::Show;
@ -43,7 +43,7 @@ pub struct TreeMap<K, V> {
length: uint
}
impl<K: PartialEq + TotalOrd, V: PartialEq> PartialEq for TreeMap<K, V> {
impl<K: PartialEq + Ord, 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: PartialEq + TotalOrd, V: PartialEq> PartialEq for TreeMap<K, V> {
}
// Lexicographical comparison
fn lt<K: PartialOrd + TotalOrd, V: PartialOrd>(a: &TreeMap<K, V>,
fn lt<K: PartialOrd + Ord, 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,12 +64,12 @@ fn lt<K: PartialOrd + TotalOrd, V: PartialOrd>(a: &TreeMap<K, V>,
a.len() < b.len()
}
impl<K: PartialOrd + TotalOrd, V: PartialOrd> PartialOrd for TreeMap<K, V> {
impl<K: PartialOrd + Ord, V: PartialOrd> PartialOrd for TreeMap<K, V> {
#[inline]
fn lt(&self, other: &TreeMap<K, V>) -> bool { lt(self, other) }
}
impl<K: TotalOrd + Show, V: Show> Show for TreeMap<K, V> {
impl<K: Ord + Show, V: Show> Show for TreeMap<K, V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(write!(f, r"\{"));
@ -82,18 +82,18 @@ impl<K: TotalOrd + Show, V: Show> Show for TreeMap<K, V> {
}
}
impl<K: TotalOrd, V> Container for TreeMap<K, V> {
impl<K: Ord, V> Container for TreeMap<K, V> {
fn len(&self) -> uint { self.length }
}
impl<K: TotalOrd, V> Mutable for TreeMap<K, V> {
impl<K: Ord, V> Mutable for TreeMap<K, V> {
fn clear(&mut self) {
self.root = None;
self.length = 0
}
}
impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> {
impl<K: Ord, V> Map<K, V> for TreeMap<K, V> {
fn find<'a>(&'a self, key: &K) -> Option<&'a V> {
let mut current: &'a Option<Box<TreeNode<K, V>>> = &self.root;
loop {
@ -111,7 +111,7 @@ impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> {
}
}
impl<K: TotalOrd, V> MutableMap<K, V> for TreeMap<K, V> {
impl<K: Ord, V> MutableMap<K, V> for TreeMap<K, V> {
#[inline]
fn find_mut<'a>(&'a mut self, key: &K) -> Option<&'a mut V> {
find_mut(&mut self.root, key)
@ -130,7 +130,7 @@ impl<K: TotalOrd, V> MutableMap<K, V> for TreeMap<K, V> {
}
}
impl<K: TotalOrd, V> TreeMap<K, V> {
impl<K: Ord, V> TreeMap<K, V> {
/// Create an empty TreeMap
pub fn new() -> TreeMap<K, V> { TreeMap{root: None, length: 0} }
@ -216,7 +216,7 @@ macro_rules! bound_setup {
}
impl<K: TotalOrd, V> TreeMap<K, V> {
impl<K: Ord, V> TreeMap<K, V> {
/// Get a lazy iterator that should be initialized using
/// `traverse_left`/`traverse_right`/`traverse_complete`.
fn iter_for_traversal<'a>(&'a self) -> Entries<'a, K, V> {
@ -546,23 +546,23 @@ impl<'a, T> Iterator<&'a T> for RevSetItems<'a, T> {
/// A implementation of the `Set` trait on top of the `TreeMap` container. The
/// only requirement is that the type of the elements contained ascribes to the
/// `TotalOrd` trait.
/// `Ord` trait.
#[deriving(Clone)]
pub struct TreeSet<T> {
map: TreeMap<T, ()>
}
impl<T: PartialEq + TotalOrd> PartialEq for TreeSet<T> {
impl<T: PartialEq + Ord> PartialEq for TreeSet<T> {
#[inline]
fn eq(&self, other: &TreeSet<T>) -> bool { self.map == other.map }
}
impl<T: PartialOrd + TotalOrd> PartialOrd for TreeSet<T> {
impl<T: PartialOrd + Ord> PartialOrd for TreeSet<T> {
#[inline]
fn lt(&self, other: &TreeSet<T>) -> bool { self.map < other.map }
}
impl<T: TotalOrd + Show> Show for TreeSet<T> {
impl<T: Ord + Show> Show for TreeSet<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(write!(f, r"\{"));
@ -575,17 +575,17 @@ impl<T: TotalOrd + Show> Show for TreeSet<T> {
}
}
impl<T: TotalOrd> Container for TreeSet<T> {
impl<T: Ord> Container for TreeSet<T> {
#[inline]
fn len(&self) -> uint { self.map.len() }
}
impl<T: TotalOrd> Mutable for TreeSet<T> {
impl<T: Ord> Mutable for TreeSet<T> {
#[inline]
fn clear(&mut self) { self.map.clear() }
}
impl<T: TotalOrd> Set<T> for TreeSet<T> {
impl<T: Ord> Set<T> for TreeSet<T> {
#[inline]
fn contains(&self, value: &T) -> bool {
self.map.contains_key(value)
@ -620,7 +620,7 @@ impl<T: TotalOrd> Set<T> for TreeSet<T> {
}
}
impl<T: TotalOrd> MutableSet<T> for TreeSet<T> {
impl<T: Ord> MutableSet<T> for TreeSet<T> {
#[inline]
fn insert(&mut self, value: T) -> bool { self.map.insert(value, ()) }
@ -628,7 +628,7 @@ impl<T: TotalOrd> MutableSet<T> for TreeSet<T> {
fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
}
impl<T: TotalOrd> TreeSet<T> {
impl<T: Ord> TreeSet<T> {
/// Create an empty TreeSet
#[inline]
pub fn new() -> TreeSet<T> { TreeSet{map: TreeMap::new()} }
@ -728,7 +728,7 @@ pub struct UnionItems<'a, T> {
}
/// Compare `x` and `y`, but return `short` if x is None and `long` if y is None
fn cmp_opt<T: TotalOrd>(x: Option<&T>, y: Option<&T>,
fn cmp_opt<T: Ord>(x: Option<&T>, y: Option<&T>,
short: Ordering, long: Ordering) -> Ordering {
match (x, y) {
(None , _ ) => short,
@ -737,7 +737,7 @@ fn cmp_opt<T: TotalOrd>(x: Option<&T>, y: Option<&T>,
}
}
impl<'a, T: TotalOrd> Iterator<&'a T> for DifferenceItems<'a, T> {
impl<'a, T: Ord> Iterator<&'a T> for DifferenceItems<'a, T> {
fn next(&mut self) -> Option<&'a T> {
loop {
match cmp_opt(self.a.peek(), self.b.peek(), Less, Less) {
@ -749,7 +749,7 @@ impl<'a, T: TotalOrd> Iterator<&'a T> for DifferenceItems<'a, T> {
}
}
impl<'a, T: TotalOrd> Iterator<&'a T> for SymDifferenceItems<'a, T> {
impl<'a, T: Ord> Iterator<&'a T> for SymDifferenceItems<'a, T> {
fn next(&mut self) -> Option<&'a T> {
loop {
match cmp_opt(self.a.peek(), self.b.peek(), Greater, Less) {
@ -761,7 +761,7 @@ impl<'a, T: TotalOrd> Iterator<&'a T> for SymDifferenceItems<'a, T> {
}
}
impl<'a, T: TotalOrd> Iterator<&'a T> for IntersectionItems<'a, T> {
impl<'a, T: Ord> Iterator<&'a T> for IntersectionItems<'a, T> {
fn next(&mut self) -> Option<&'a T> {
loop {
let o_cmp = match (self.a.peek(), self.b.peek()) {
@ -779,7 +779,7 @@ impl<'a, T: TotalOrd> Iterator<&'a T> for IntersectionItems<'a, T> {
}
}
impl<'a, T: TotalOrd> Iterator<&'a T> for UnionItems<'a, T> {
impl<'a, T: Ord> Iterator<&'a T> for UnionItems<'a, T> {
fn next(&mut self) -> Option<&'a T> {
loop {
match cmp_opt(self.a.peek(), self.b.peek(), Greater, Less) {
@ -803,7 +803,7 @@ struct TreeNode<K, V> {
level: uint
}
impl<K: TotalOrd, V> TreeNode<K, V> {
impl<K: Ord, V> TreeNode<K, V> {
/// Creates a new tree node.
#[inline]
pub fn new(key: K, value: V) -> TreeNode<K, V> {
@ -812,7 +812,7 @@ impl<K: TotalOrd, V> TreeNode<K, V> {
}
// Remove left horizontal link by rotating right
fn skew<K: TotalOrd, V>(node: &mut Box<TreeNode<K, V>>) {
fn skew<K: Ord, V>(node: &mut Box<TreeNode<K, V>>) {
if node.left.as_ref().map_or(false, |x| x.level == node.level) {
let mut save = node.left.take_unwrap();
swap(&mut node.left, &mut save.right); // save.right now None
@ -823,7 +823,7 @@ fn skew<K: TotalOrd, V>(node: &mut Box<TreeNode<K, V>>) {
// Remove dual horizontal link by rotating left and increasing level of
// the parent
fn split<K: TotalOrd, V>(node: &mut Box<TreeNode<K, V>>) {
fn split<K: Ord, V>(node: &mut Box<TreeNode<K, V>>) {
if node.right.as_ref().map_or(false,
|x| x.right.as_ref().map_or(false, |y| y.level == node.level)) {
let mut save = node.right.take_unwrap();
@ -834,7 +834,7 @@ fn split<K: TotalOrd, V>(node: &mut Box<TreeNode<K, V>>) {
}
}
fn find_mut<'r, K: TotalOrd, V>(node: &'r mut Option<Box<TreeNode<K, V>>>,
fn find_mut<'r, K: Ord, V>(node: &'r mut Option<Box<TreeNode<K, V>>>,
key: &K)
-> Option<&'r mut V> {
match *node {
@ -849,7 +849,7 @@ fn find_mut<'r, K: TotalOrd, V>(node: &'r mut Option<Box<TreeNode<K, V>>>,
}
}
fn insert<K: TotalOrd, V>(node: &mut Option<Box<TreeNode<K, V>>>,
fn insert<K: Ord, V>(node: &mut Option<Box<TreeNode<K, V>>>,
key: K, value: V) -> Option<V> {
match *node {
Some(ref mut save) => {
@ -879,9 +879,9 @@ fn insert<K: TotalOrd, V>(node: &mut Option<Box<TreeNode<K, V>>>,
}
}
fn remove<K: TotalOrd, V>(node: &mut Option<Box<TreeNode<K, V>>>,
fn remove<K: Ord, V>(node: &mut Option<Box<TreeNode<K, V>>>,
key: &K) -> Option<V> {
fn heir_swap<K: TotalOrd, V>(node: &mut Box<TreeNode<K, V>>,
fn heir_swap<K: Ord, V>(node: &mut Box<TreeNode<K, V>>,
child: &mut Option<Box<TreeNode<K, V>>>) {
// *could* be done without recursion, but it won't borrow check
for x in child.mut_iter() {
@ -962,7 +962,7 @@ fn remove<K: TotalOrd, V>(node: &mut Option<Box<TreeNode<K, V>>>,
};
}
impl<K: TotalOrd, V> FromIterator<(K, V)> for TreeMap<K, V> {
impl<K: Ord, V> FromIterator<(K, V)> for TreeMap<K, V> {
fn from_iter<T: Iterator<(K, V)>>(iter: T) -> TreeMap<K, V> {
let mut map = TreeMap::new();
map.extend(iter);
@ -970,7 +970,7 @@ impl<K: TotalOrd, V> FromIterator<(K, V)> for TreeMap<K, V> {
}
}
impl<K: TotalOrd, V> Extendable<(K, V)> for TreeMap<K, V> {
impl<K: Ord, V> Extendable<(K, V)> for TreeMap<K, V> {
#[inline]
fn extend<T: Iterator<(K, V)>>(&mut self, mut iter: T) {
for (k, v) in iter {
@ -979,7 +979,7 @@ impl<K: TotalOrd, V> Extendable<(K, V)> for TreeMap<K, V> {
}
}
impl<T: TotalOrd> FromIterator<T> for TreeSet<T> {
impl<T: Ord> FromIterator<T> for TreeSet<T> {
fn from_iter<Iter: Iterator<T>>(iter: Iter) -> TreeSet<T> {
let mut set = TreeSet::new();
set.extend(iter);
@ -987,7 +987,7 @@ impl<T: TotalOrd> FromIterator<T> for TreeSet<T> {
}
}
impl<T: TotalOrd> Extendable<T> for TreeSet<T> {
impl<T: Ord> Extendable<T> for TreeSet<T> {
#[inline]
fn extend<Iter: Iterator<T>>(&mut self, mut iter: Iter) {
for elem in iter {
@ -1070,7 +1070,7 @@ mod test_treemap {
assert_eq!(m.find(&k1), Some(&v1));
}
fn check_equal<K: PartialEq + TotalOrd, V: PartialEq>(ctrl: &[(K, V)],
fn check_equal<K: PartialEq + Ord, V: PartialEq>(ctrl: &[(K, V)],
map: &TreeMap<K, V>) {
assert_eq!(ctrl.is_empty(), map.is_empty());
for x in ctrl.iter() {
@ -1091,7 +1091,7 @@ mod test_treemap {
}
}
fn check_left<K: TotalOrd, V>(node: &Option<Box<TreeNode<K, V>>>,
fn check_left<K: Ord, V>(node: &Option<Box<TreeNode<K, V>>>,
parent: &Box<TreeNode<K, V>>) {
match *node {
Some(ref r) => {
@ -1104,7 +1104,7 @@ mod test_treemap {
}
}
fn check_right<K: TotalOrd, V>(node: &Option<Box<TreeNode<K, V>>>,
fn check_right<K: Ord, V>(node: &Option<Box<TreeNode<K, V>>>,
parent: &Box<TreeNode<K, V>>,
parent_red: bool) {
match *node {
@ -1121,7 +1121,7 @@ mod test_treemap {
}
}
fn check_structure<K: TotalOrd, V>(map: &TreeMap<K, V>) {
fn check_structure<K: Ord, V>(map: &TreeMap<K, V>) {
match map.root {
Some(ref r) => {
check_left(&r.left, r);

41
src/libcore/cmp.rs
View File

@ -37,9 +37,6 @@
//! assert!(SketchyNum {num: 25} != SketchyNum {num: 57});
//! ```
pub use Eq = self::TotalEq;
pub use Ord = self::TotalOrd;
/// Trait for values that can be compared for equality and inequality.
///
/// This trait allows partial equality, where types can be unordered instead of
@ -51,7 +48,7 @@ pub use Ord = self::TotalOrd;
/// default.
///
/// Eventually, this will be implemented by default for types that implement
/// `TotalEq`.
/// `Eq`.
#[lang="eq"]
pub trait PartialEq {
/// This method tests for `self` and `other` values to be equal, and is used by `==`.
@ -71,7 +68,7 @@ pub trait PartialEq {
/// - reflexive: `a == a`;
/// - symmetric: `a == b` implies `b == a`; and
/// - transitive: `a == b` and `b == c` implies `a == c`.
pub trait TotalEq: PartialEq {
pub trait Eq: 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
@ -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 + PartialOrd {
pub trait Ord: Eq + PartialOrd {
/// This method returns an ordering between `self` and `other` values.
///
/// By convention, `self.cmp(&other)` returns the ordering matching
@ -118,9 +115,9 @@ pub trait TotalOrd: TotalEq + PartialOrd {
fn cmp(&self, other: &Self) -> Ordering;
}
impl TotalEq for Ordering {}
impl Eq for Ordering {}
impl TotalOrd for Ordering {
impl Ord for Ordering {
#[inline]
fn cmp(&self, other: &Ordering) -> Ordering {
(*self as int).cmp(&(*other as int))
@ -182,20 +179,20 @@ pub trait Equiv<T> {
/// Compare and return the minimum of two values.
#[inline]
pub fn min<T: TotalOrd>(v1: T, v2: T) -> T {
pub fn min<T: Ord>(v1: T, v2: T) -> T {
if v1 < v2 { v1 } else { v2 }
}
/// Compare and return the maximum of two values.
#[inline]
pub fn max<T: TotalOrd>(v1: T, v2: T) -> T {
pub fn max<T: Ord>(v1: T, v2: T) -> T {
if v1 > v2 { v1 } else { v2 }
}
// Implementation of PartialEq, TotalEq, PartialOrd and TotalOrd for primitive types
// Implementation of PartialEq, Eq, PartialOrd and Ord for primitive types
#[cfg(not(test))]
mod impls {
use cmp::{PartialOrd, TotalOrd, PartialEq, TotalEq, Ordering,
use cmp::{PartialOrd, Ord, PartialEq, Eq, Ordering,
Less, Greater, Equal};
macro_rules! eq_impl(
@ -220,7 +217,7 @@ mod impls {
macro_rules! totaleq_impl(
($($t:ty)*) => ($(
impl TotalEq for $t {}
impl Eq for $t {}
)*)
)
@ -257,7 +254,7 @@ mod impls {
macro_rules! totalord_impl(
($($t:ty)*) => ($(
impl TotalOrd for $t {
impl Ord for $t {
#[inline]
fn cmp(&self, other: &$t) -> Ordering {
if *self < *other { Less }
@ -268,12 +265,12 @@ mod impls {
)*)
)
impl TotalOrd for () {
impl Ord for () {
#[inline]
fn cmp(&self, _other: &()) -> Ordering { Equal }
}
impl TotalOrd for bool {
impl Ord for bool {
#[inline]
fn cmp(&self, other: &bool) -> Ordering {
(*self as u8).cmp(&(*other as u8))
@ -299,11 +296,11 @@ mod impls {
#[inline]
fn gt(&self, other: & &'a T) -> bool { *(*self) > *(*other) }
}
impl<'a, T: TotalOrd> TotalOrd for &'a T {
impl<'a, T: Ord> Ord for &'a T {
#[inline]
fn cmp(&self, other: & &'a T) -> Ordering { (**self).cmp(*other) }
}
impl<'a, T: TotalEq> TotalEq for &'a T {}
impl<'a, T: Eq> Eq for &'a T {}
// &mut pointers
impl<'a, T: PartialEq> PartialEq for &'a mut T {
@ -322,11 +319,11 @@ mod impls {
#[inline]
fn gt(&self, other: &&'a mut T) -> bool { **self > **other }
}
impl<'a, T: TotalOrd> TotalOrd for &'a mut T {
impl<'a, T: Ord> Ord for &'a mut T {
#[inline]
fn cmp(&self, other: &&'a mut T) -> Ordering { (**self).cmp(*other) }
}
impl<'a, T: TotalEq> TotalEq for &'a mut T {}
impl<'a, T: Eq> Eq for &'a mut T {}
// @ pointers
impl<T:PartialEq> PartialEq for @T {
@ -345,11 +342,11 @@ mod impls {
#[inline]
fn gt(&self, other: &@T) -> bool { *(*self) > *(*other) }
}
impl<T: TotalOrd> TotalOrd for @T {
impl<T: Ord> Ord for @T {
#[inline]
fn cmp(&self, other: &@T) -> Ordering { (**self).cmp(*other) }
}
impl<T: TotalEq> TotalEq for @T {}
impl<T: Eq> Eq for @T {}
}
#[cfg(test)]

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(PartialEq, TotalEq, Show)]
#[deriving(PartialEq, Eq, Show)]
#[cfg(not(test))]
pub struct TypeId {
t: u64,

18
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::{PartialEq, PartialOrd, TotalOrd};
use cmp::{PartialEq, PartialOrd, Ord};
use clone::Clone;
use uint;
use mem;
@ -611,7 +611,7 @@ pub trait Iterator<A> {
/// assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10);
/// ```
#[inline]
fn max_by<B: TotalOrd>(&mut self, f: |&A| -> B) -> Option<A> {
fn max_by<B: Ord>(&mut self, f: |&A| -> B) -> Option<A> {
self.fold(None, |max: Option<(A, B)>, x| {
let x_val = f(&x);
match max {
@ -635,7 +635,7 @@ pub trait Iterator<A> {
/// assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0);
/// ```
#[inline]
fn min_by<B: TotalOrd>(&mut self, f: |&A| -> B) -> Option<A> {
fn min_by<B: Ord>(&mut self, f: |&A| -> B) -> Option<A> {
self.fold(None, |min: Option<(A, B)>, x| {
let x_val = f(&x);
match min {
@ -905,7 +905,7 @@ pub trait OrdIterator<A> {
fn min_max(&mut self) -> MinMaxResult<A>;
}
impl<A: TotalOrd, T: Iterator<A>> OrdIterator<A> for T {
impl<A: Ord, T: Iterator<A>> OrdIterator<A> for T {
#[inline]
fn max(&mut self) -> Option<A> {
self.fold(None, |max, x| {
@ -2182,12 +2182,12 @@ impl<A: Clone> RandomAccessIterator<A> for Repeat<A> {
/// the shorter sequence compares less.
pub mod order {
use cmp;
use cmp::{TotalEq, TotalOrd, PartialOrd, PartialEq};
use cmp::{Eq, Ord, PartialOrd, PartialEq};
use option::{Some, None};
use super::Iterator;
/// Compare `a` and `b` for equality using `TotalEq`
pub fn equals<A: TotalEq, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
/// Compare `a` and `b` for equality using `Eq`
pub fn equals<A: Eq, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> bool {
loop {
match (a.next(), b.next()) {
(None, None) => return true,
@ -2197,8 +2197,8 @@ pub mod order {
}
}
/// Order `a` and `b` lexicographically using `TotalOrd`
pub fn cmp<A: TotalOrd, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> cmp::Ordering {
/// Order `a` and `b` lexicographically using `Ord`
pub fn cmp<A: Ord, T: Iterator<A>, S: Iterator<A>>(mut a: T, mut b: S) -> cmp::Ordering {
loop {
match (a.next(), b.next()) {
(None, None) => return cmp::Equal,

4
src/libcore/option.rs
View File

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

4
src/libcore/prelude.rs
View File

@ -45,7 +45,7 @@ pub use mem::drop;
pub use char::Char;
pub use clone::Clone;
pub use cmp::{PartialEq, PartialOrd, TotalEq, TotalOrd};
pub use cmp::{PartialEq, PartialOrd, Eq, Ord};
pub use cmp::{Ordering, Less, Equal, Greater, Equiv};
pub use container::{Container, Mutable, Map, MutableMap, Set, MutableSet};
pub use iter::{FromIterator, Extendable};
@ -59,6 +59,6 @@ pub use str::{Str, StrSlice};
pub use tuple::{Tuple1, Tuple2, Tuple3, Tuple4};
pub use tuple::{Tuple5, Tuple6, Tuple7, Tuple8};
pub use tuple::{Tuple9, Tuple10, Tuple11, Tuple12};
pub use slice::{ImmutableEqVector, ImmutableTotalOrdVector};
pub use slice::{ImmutableEqVector, ImmutableOrdVector};
pub use slice::{MutableVector};
pub use slice::{Vector, ImmutableVector};

6
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::{PartialEq, TotalEq, PartialOrd, Equiv};
#[cfg(not(test))] use cmp::{PartialEq, Eq, PartialOrd, Equiv};
/// Return the offset of the first null pointer in `buf`.
#[inline]
@ -396,7 +396,7 @@ impl<T> PartialEq for *T {
}
#[cfg(not(test))]
impl<T> TotalEq for *T {}
impl<T> Eq for *T {}
#[cfg(not(test))]
impl<T> PartialEq for *mut T {
@ -409,7 +409,7 @@ impl<T> PartialEq for *mut T {
}
#[cfg(not(test))]
impl<T> TotalEq for *mut T {}
impl<T> Eq for *mut T {}
// Equivalence for pointers
#[cfg(not(test))]

2
src/libcore/result.rs
View File

@ -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, PartialEq, PartialOrd, TotalEq, TotalOrd, Show)]
#[deriving(Clone, PartialEq, PartialOrd, Eq, Ord, Show)]
#[must_use]
pub enum Result<T, E> {
/// Contains the success value

18
src/libcore/slice.rs
View File

@ -17,7 +17,7 @@
use mem::transmute;
use clone::Clone;
use container::Container;
use cmp::{PartialEq, TotalOrd, Ordering, Less, Equal, Greater};
use cmp::{PartialEq, Ord, Ordering, Less, Equal, Greater};
use cmp;
use default::Default;
use iter::*;
@ -251,7 +251,7 @@ impl<'a, T> RandomAccessIterator<&'a [T]> for Chunks<'a, T> {
pub mod traits {
use super::*;
use cmp::{PartialEq, PartialOrd, TotalEq, TotalOrd, Ordering, Equiv};
use cmp::{PartialEq, PartialOrd, Eq, Ord, Ordering, Equiv};
use iter::{order, Iterator};
use container::Container;
@ -273,9 +273,9 @@ pub mod traits {
fn ne(&self, other: &~[T]) -> bool { !self.eq(other) }
}
impl<'a,T:TotalEq> TotalEq for &'a [T] {}
impl<'a,T:Eq> Eq for &'a [T] {}
impl<T:TotalEq> TotalEq for ~[T] {}
impl<T:Eq> Eq for ~[T] {}
impl<'a,T:PartialEq, V: Vector<T>> Equiv<V> for &'a [T] {
#[inline]
@ -287,13 +287,13 @@ pub mod traits {
fn equiv(&self, other: &V) -> bool { self.as_slice() == other.as_slice() }
}
impl<'a,T:TotalOrd> TotalOrd for &'a [T] {
impl<'a,T:Ord> Ord for &'a [T] {
fn cmp(&self, other: & &'a [T]) -> Ordering {
order::cmp(self.iter(), other.iter())
}
}
impl<T: TotalOrd> TotalOrd for ~[T] {
impl<T: Ord> Ord for ~[T] {
#[inline]
fn cmp(&self, other: &~[T]) -> Ordering { self.as_slice().cmp(&other.as_slice()) }
}
@ -741,8 +741,8 @@ impl<'a,T:PartialEq> ImmutableEqVector<T> for &'a [T] {
}
}
/// Extension methods for vectors containing `TotalOrd` elements.
pub trait ImmutableTotalOrdVector<T: TotalOrd> {
/// Extension methods for vectors containing `Ord` elements.
pub trait ImmutableOrdVector<T: Ord> {
/**
* Binary search a sorted vector for a given element.
*
@ -751,7 +751,7 @@ pub trait ImmutableTotalOrdVector<T: TotalOrd> {
fn bsearch_elem(&self, x: &T) -> Option<uint>;
}
impl<'a, T: TotalOrd> ImmutableTotalOrdVector<T> for &'a [T] {
impl<'a, T: Ord> ImmutableOrdVector<T> for &'a [T] {
fn bsearch_elem(&self, x: &T) -> Option<uint> {
self.bsearch(|p| p.cmp(x))
}

10
src/libcore/str.rs
View File

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

10
src/libcore/tuple.rs
View File

@ -28,9 +28,9 @@
//!
//! * `Clone`
//! * `PartialEq`
//! * `TotalEq`
//! * `Eq`
//! * `PartialOrd`
//! * `TotalOrd`
//! * `Ord`
//! * `Default`
//!
//! # Examples
@ -123,7 +123,7 @@ macro_rules! tuple_impls {
}
#[cfg(not(test))]
impl<$($T:TotalEq),+> TotalEq for ($($T,)+) {}
impl<$($T:Eq),+> Eq for ($($T,)+) {}
#[cfg(not(test))]
impl<$($T:PartialOrd + PartialEq),+> PartialOrd for ($($T,)+) {
@ -146,7 +146,7 @@ macro_rules! tuple_impls {
}
#[cfg(not(test))]
impl<$($T:TotalOrd),+> TotalOrd for ($($T,)+) {
impl<$($T:Ord),+> Ord for ($($T,)+) {
#[inline]
fn cmp(&self, other: &($($T,)+)) -> Ordering {
lexical_cmp!($(self.$refN(), other.$refN()),+)
@ -364,7 +364,7 @@ mod tests {
assert!(((1.0, 2.0) < (2.0, nan)));
assert!(!((2.0, 2.0) < (2.0, nan)));
// TotalOrd
// Ord
assert!(small.cmp(&small) == Equal);
assert!(big.cmp(&big) == Equal);
assert!(small.cmp(&big) == Less);

4
src/libfmt_macros/lib.rs
View File

@ -146,7 +146,7 @@ pub enum Method<'a> {
}
/// A selector for what pluralization a plural method should take
#[deriving(PartialEq, TotalEq, Hash)]
#[deriving(PartialEq, Eq, Hash)]
pub enum PluralSelector {
/// One of the plural keywords should be used
Keyword(PluralKeyword),
@ -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(PartialEq, TotalEq, Hash, Show)]
#[deriving(PartialEq, Eq, Hash, Show)]
#[allow(missing_doc)]
pub enum PluralKeyword {
/// The plural form for zero objects.

8
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, PartialEq, TotalEq, PartialOrd, TotalOrd, Hash, Default)]
#[deriving(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct Pattern {
tokens: Vec<PatternToken>,
}
#[deriving(Clone, PartialEq, TotalEq, PartialOrd, TotalOrd, Hash)]
#[deriving(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
enum PatternToken {
Char(char),
AnyChar,
@ -212,7 +212,7 @@ enum PatternToken {
AnyExcept(Vec<CharSpecifier> )
}
#[deriving(Clone, PartialEq, TotalEq, PartialOrd, TotalOrd, Hash)]
#[deriving(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
enum CharSpecifier {
SingleChar(char),
CharRange(char, char)
@ -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, PartialEq, TotalEq, PartialOrd, TotalOrd, Hash, Default)]
#[deriving(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct MatchOptions {
/**

10
src/libnum/bigint.rs
View File

@ -89,7 +89,7 @@ impl PartialEq for BigUint {
match self.cmp(other) { Equal => true, _ => false }
}
}
impl TotalEq for BigUint {}
impl Eq for BigUint {}
impl PartialOrd for BigUint {
#[inline]
@ -98,7 +98,7 @@ impl PartialOrd for BigUint {
}
}
impl TotalOrd for BigUint {
impl Ord for BigUint {
#[inline]
fn cmp(&self, other: &BigUint) -> Ordering {
let (s_len, o_len) = (self.data.len(), other.data.len());
@ -786,7 +786,7 @@ fn get_radix_base(radix: uint) -> (DoubleBigDigit, uint) {
}
/// A Sign is a `BigInt`'s composing element.
#[deriving(PartialEq, PartialOrd, TotalEq, TotalOrd, Clone, Show)]
#[deriving(PartialEq, PartialOrd, Eq, Ord, Clone, Show)]
pub enum Sign { Minus, Zero, Plus }
impl Neg<Sign> for Sign {
@ -815,7 +815,7 @@ impl PartialEq for BigInt {
}
}
impl TotalEq for BigInt {}
impl Eq for BigInt {}
impl PartialOrd for BigInt {
#[inline]
@ -824,7 +824,7 @@ impl PartialOrd for BigInt {
}
}
impl TotalOrd for BigInt {
impl Ord for BigInt {
#[inline]
fn cmp(&self, other: &BigInt) -> Ordering {
let scmp = self.sign.cmp(&other.sign);

4
src/libnum/rational.rs
View File

@ -194,8 +194,8 @@ macro_rules! cmp_impl {
}
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)
cmp_impl!(impl Eq, )
cmp_impl!(impl Ord, cmp -> cmp::Ordering)
/* Arithmetic */
// a/b * c/d = (a*c)/(b*d)

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, PartialEq, PartialOrd, TotalOrd, TotalEq)]
#[deriving(Clone, PartialEq, PartialOrd, Ord, Eq)]
pub enum OutputType {
OutputTypeBitcode,
OutputTypeAssembly,

2
src/librustc/driver/config.rs
View File

@ -132,7 +132,7 @@ pub enum EntryFnType {
EntryNone,
}
#[deriving(PartialEq, PartialOrd, Clone, TotalOrd, TotalEq, Hash)]
#[deriving(PartialEq, PartialOrd, Clone, Ord, Eq, Hash)]
pub enum CrateType {
CrateTypeExecutable,
CrateTypeDylib,

4
src/librustc/middle/borrowck/mod.rs
View File

@ -188,13 +188,13 @@ pub struct Loan {
cause: euv::LoanCause,
}
#[deriving(PartialEq, TotalEq, Hash)]
#[deriving(PartialEq, Eq, Hash)]
pub enum LoanPath {
LpVar(ast::NodeId), // `x` in doc.rs
LpExtend(Rc<LoanPath>, mc::MutabilityCategory, LoanPathElem)
}
#[deriving(PartialEq, TotalEq, Hash)]
#[deriving(PartialEq, Eq, Hash)]
pub enum LoanPathElem {
LpDeref(mc::PointerKind), // `*LV` in doc.rs
LpInterior(mc::InteriorKind) // `LV.f` in doc.rs

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, PartialEq, TotalEq, Hash)]
#[deriving(FromPrimitive, PartialEq, Eq, Hash)]
pub enum LangItem {
$($variant),*
}

6
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, PartialEq, PartialOrd, TotalEq, TotalOrd, Hash)]
#[deriving(Clone, Show, PartialEq, PartialOrd, Eq, Ord, Hash)]
pub enum Lint {
CTypes,
UnusedImports,
@ -135,12 +135,12 @@ pub fn level_to_str(lv: Level) -> &'static str {
}
}
#[deriving(Clone, PartialEq, PartialOrd, TotalEq, TotalOrd)]
#[deriving(Clone, PartialEq, PartialOrd, Eq, Ord)]
pub enum Level {
Allow, Warn, Deny, Forbid
}
#[deriving(Clone, PartialEq, PartialOrd, TotalEq, TotalOrd)]
#[deriving(Clone, PartialEq, PartialOrd, Eq, Ord)]
pub struct LintSpec {
pub default: Level,
pub lint: Lint,

10
src/librustc/middle/mem_categorization.rs
View File

@ -99,7 +99,7 @@ pub struct CopiedUpvar {
}
// different kinds of pointers:
#[deriving(Clone, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, 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, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, Hash)]
pub enum InteriorKind {
InteriorField(FieldName),
InteriorElement(ElementKind),
}
#[deriving(Clone, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, Hash)]
pub enum FieldName {
NamedField(ast::Name),
PositionalField(uint)
}
#[deriving(Clone, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, Hash)]
pub enum ElementKind {
VecElement,
StrElement,
OtherElement,
}
#[deriving(Clone, PartialEq, TotalEq, Hash, Show)]
#[deriving(Clone, PartialEq, Eq, Hash, Show)]
pub enum MutabilityCategory {
McImmutable, // Immutable.
McDeclared, // Directly declared as mutable.

2
src/librustc/middle/resolve.rs
View File

@ -109,7 +109,7 @@ enum PatternBindingMode {
ArgumentIrrefutableMode,
}
#[deriving(PartialEq, TotalEq, Hash)]
#[deriving(PartialEq, Eq, Hash)]
enum Namespace {
TypeNS,
ValueNS

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

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

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(PartialEq, TotalEq, Hash)]
#[deriving(PartialEq, Eq, 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(PartialEq, TotalEq, Hash)]
#[deriving(PartialEq, Eq, Hash)]
pub struct MonoId {
pub def: ast::DefId,
pub params: Vec<MonoParamId>

56
src/librustc/middle/ty.rs
View File

@ -65,7 +65,7 @@ pub static INITIAL_DISCRIMINANT_VALUE: Disr = 0;
// Data types
#[deriving(PartialEq, TotalEq, Hash)]
#[deriving(PartialEq, Eq, Hash)]
pub struct field {
pub ident: ast::Ident,
pub mt: mt
@ -121,13 +121,13 @@ impl Method {
}
}
#[deriving(Clone, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, Hash)]
pub struct mt {
pub ty: t,
pub mutbl: ast::Mutability,
}
#[deriving(Clone, PartialEq, TotalEq, Hash, Encodable, Decodable, Show)]
#[deriving(Clone, PartialEq, Eq, 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(PartialEq, TotalEq, Hash)]
#[deriving(PartialEq, Eq, Hash)]
pub struct creader_cache_key {
pub cnum: CrateNum,
pub pos: uint,
@ -172,7 +172,7 @@ impl cmp::PartialEq for intern_key {
}
}
impl TotalEq for intern_key {}
impl Eq for intern_key {}
impl<W:Writer> Hash<W> for intern_key {
fn hash(&self, s: &mut W) {
@ -387,7 +387,7 @@ pub struct t_box_ {
enum t_opaque {}
#[allow(raw_pointer_deriving)]
#[deriving(Clone, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, 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, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, Hash)]
pub struct BareFnTy {
pub fn_style: ast::FnStyle,
pub abi: abi::Abi,
pub sig: FnSig,
}
#[deriving(Clone, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, 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, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, 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, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, Hash)]
pub struct param_ty {
pub idx: uint,
pub def_id: DefId
}
/// Representation of regions:
#[deriving(Clone, PartialEq, TotalEq, Hash, Encodable, Decodable, Show)]
#[deriving(Clone, PartialEq, Eq, 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, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, Hash)]
pub struct UpvarId {
pub var_id: ast::NodeId,
pub closure_expr_id: ast::NodeId,
}
#[deriving(Clone, PartialEq, TotalEq, Hash, Show)]
#[deriving(Clone, PartialEq, Eq, Hash, Show)]
pub enum BorrowKind {
/// Data must be immutable and is aliasable.
ImmBorrow,
@ -618,13 +618,13 @@ impl Region {
}
}
#[deriving(Clone, PartialEq, PartialOrd, TotalEq, TotalOrd, Hash, Encodable, Decodable, Show)]
#[deriving(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Encodable, Decodable, Show)]
pub struct FreeRegion {
pub scope_id: NodeId,
pub bound_region: BoundRegion
}
#[deriving(Clone, PartialEq, PartialOrd, TotalEq, TotalOrd, Hash, Encodable, Decodable, Show)]
#[deriving(Clone, PartialEq, PartialOrd, Eq, Ord, 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, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, 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, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, 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, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, Hash)]
pub enum sty {
ty_nil,
ty_bot,
@ -754,7 +754,7 @@ pub enum sty {
// on non-useful type error messages)
}
#[deriving(Clone, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, Hash)]
pub struct TyTrait {
pub def_id: DefId,
pub substs: substs,
@ -762,7 +762,7 @@ pub struct TyTrait {
pub bounds: BuiltinBounds
}
#[deriving(PartialEq, TotalEq, Hash)]
#[deriving(PartialEq, Eq, Hash)]
pub struct TraitRef {
pub def_id: DefId,
pub substs: substs
@ -822,7 +822,7 @@ pub enum type_err {
terr_variadic_mismatch(expected_found<bool>)
}
#[deriving(PartialEq, TotalEq, Hash)]
#[deriving(PartialEq, Eq, 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, PartialEq, TotalEq, Decodable, Hash, Show)]
#[deriving(Clone, Encodable, PartialEq, Eq, Decodable, Hash, Show)]
#[repr(uint)]
pub enum BuiltinBound {
BoundStatic,
@ -862,28 +862,28 @@ impl CLike for BuiltinBound {
}
}
#[deriving(Clone, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, Hash)]
pub struct TyVid(pub uint);
#[deriving(Clone, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, Hash)]
pub struct IntVid(pub uint);
#[deriving(Clone, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, Hash)]
pub struct FloatVid(pub uint);
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct RegionVid {
pub id: uint
}
#[deriving(Clone, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, Hash)]
pub enum InferTy {
TyVar(TyVid),
IntVar(IntVid),
FloatVar(FloatVid)
}
#[deriving(Clone, Encodable, Decodable, TotalEq, Hash, Show)]
#[deriving(Clone, Encodable, Decodable, Eq, Hash, Show)]
pub enum InferRegion {
ReVar(RegionVid),
ReSkolemized(uint, BoundRegion)

4
src/librustc/middle/typeck/infer/region_inference/mod.rs
View File

@ -31,7 +31,7 @@ use syntax::ast;
mod doc;
#[deriving(PartialEq, TotalEq, Hash)]
#[deriving(PartialEq, Eq, Hash)]
pub enum Constraint {
ConstrainVarSubVar(RegionVid, RegionVid),
ConstrainRegSubVar(Region, RegionVid),
@ -39,7 +39,7 @@ pub enum Constraint {
ConstrainRegSubReg(Region, Region),
}
#[deriving(PartialEq, TotalEq, Hash)]
#[deriving(PartialEq, Eq, Hash)]
pub struct TwoRegions {
a: Region,
b: Region,

2
src/librustc/middle/typeck/mod.rs
View File

@ -147,7 +147,7 @@ pub struct MethodCallee {
pub substs: ty::substs
}
#[deriving(Clone, PartialEq, TotalEq, Hash, Show)]
#[deriving(Clone, PartialEq, Eq, Hash, Show)]
pub struct MethodCall {
pub expr_id: ast::NodeId,
pub autoderef: u32

4
src/librustc/util/nodemap.rs
View File

@ -28,14 +28,14 @@ pub type DefIdSet = FnvHashSet<ast::DefId>;
pub mod FnvHashMap {
use std::hash::Hash;
use collections::HashMap;
pub fn new<K: Hash<super::FnvState> + TotalEq, V>() -> super::FnvHashMap<K, V> {
pub fn new<K: Hash<super::FnvState> + Eq, V>() -> super::FnvHashMap<K, V> {
HashMap::with_hasher(super::FnvHasher)
}
}
pub mod FnvHashSet {
use std::hash::Hash;
use collections::HashSet;
pub fn new<V: Hash<super::FnvState> + TotalEq>() -> super::FnvHashSet<V> {
pub fn new<V: Hash<super::FnvState> + Eq>() -> super::FnvHashSet<V> {
HashSet::with_hasher(super::FnvHasher)
}
}

2
src/librustdoc/clean/mod.rs
View File

@ -1028,7 +1028,7 @@ pub enum Type {
// region, raw, other boxes, mutable
}
#[deriving(Clone, Encodable, Decodable, PartialEq, TotalEq, Hash)]
#[deriving(Clone, Encodable, Decodable, PartialEq, Eq, Hash)]
pub enum Primitive {
Int, I8, I16, I32, I64,
Uint, U8, U16, U32, U64,

16
src/libserialize/collection_impls.rs
View File

@ -76,7 +76,7 @@ impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for RingBuf<T> {
impl<
E,
S: Encoder<E>,
K: Encodable<S, E> + PartialEq + TotalOrd,
K: Encodable<S, E> + PartialEq + Ord,
V: Encodable<S, E> + PartialEq
> Encodable<S, E> for TreeMap<K, V> {
fn encode(&self, e: &mut S) -> Result<(), E> {
@ -95,7 +95,7 @@ impl<
impl<
E,
D: Decoder<E>,
K: Decodable<D, E> + PartialEq + TotalOrd,
K: Decodable<D, E> + PartialEq + Ord,
V: Decodable<D, E> + PartialEq
> Decodable<D, E> for TreeMap<K, V> {
fn decode(d: &mut D) -> Result<TreeMap<K, V>, E> {
@ -114,7 +114,7 @@ impl<
impl<
E,
S: Encoder<E>,
T: Encodable<S, E> + PartialEq + TotalOrd
T: Encodable<S, E> + PartialEq + Ord
> 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> + PartialEq + TotalOrd
T: Decodable<D, E> + PartialEq + Ord
> Decodable<D, E> for TreeSet<T> {
fn decode(d: &mut D) -> Result<TreeSet<T>, E> {
d.read_seq(|d, len| {
@ -178,7 +178,7 @@ impl<
impl<
E,
S: Encoder<E>,
K: Encodable<S, E> + Hash<X> + TotalEq,
K: Encodable<S, E> + Hash<X> + Eq,
V: Encodable<S, E>,
X,
H: Hasher<X>
@ -199,7 +199,7 @@ impl<
impl<
E,
D: Decoder<E>,
K: Decodable<D, E> + Hash<S> + TotalEq,
K: Decodable<D, E> + Hash<S> + Eq,
V: Decodable<D, E>,
S,
H: Hasher<S> + Default
@ -221,7 +221,7 @@ impl<
impl<
E,
S: Encoder<E>,
T: Encodable<S, E> + Hash<X> + TotalEq,
T: Encodable<S, E> + Hash<X> + Eq,
X,
H: Hasher<X>
> Encodable<S, E> for HashSet<T, H> {
@ -240,7 +240,7 @@ impl<
impl<
E,
D: Decoder<E>,
T: Decodable<D, E> + Hash<S> + TotalEq,
T: Decodable<D, E> + Hash<S> + Eq,
S,
H: Hasher<S> + Default
> Decodable<D, E> for HashSet<T, H> {

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, PartialEq, PartialOrd, TotalOrd, TotalEq, Hash)]
#[deriving(Clone, PartialEq, PartialOrd, Ord, Eq, Hash)]
pub struct Ascii { chr: u8 }
impl Ascii {

2
src/libstd/bitflags.rs
View File

@ -112,7 +112,7 @@ macro_rules! bitflags(
($(#[$attr:meta])* flags $BitFlags:ident: $T:ty {
$($(#[$Flag_attr:meta])* static $Flag:ident = $value:expr),+
}) => (
#[deriving(PartialEq, TotalEq, Clone)]
#[deriving(PartialEq, Eq, Clone)]
$(#[$attr])*
pub struct $BitFlags {
bits: $T,

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

@ -25,7 +25,7 @@ use slice::{MutableCloneableVector, ImmutableVector, MutableVector};
pub type Port = u16;
#[deriving(PartialEq, TotalEq, Clone, Hash)]
#[deriving(PartialEq, Eq, 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(PartialEq, TotalEq, Clone, Hash)]
#[deriving(PartialEq, Eq, 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(PartialEq, TotalEq, Clone)]
#[deriving(PartialEq, Eq, 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(PartialEq, TotalEq, Clone)]
#[deriving(PartialEq, Eq, Clone)]
pub enum ProcessExit {
/// Normal termination with an exit status.
ExitStatus(int),

4
src/libstd/path/posix.rs
View File

@ -13,7 +13,7 @@
use container::Container;
use c_str::{CString, ToCStr};
use clone::Clone;
use cmp::{PartialEq, TotalEq};
use cmp::{PartialEq, Eq};
use from_str::FromStr;
use io::Writer;
use iter::{DoubleEndedIterator, AdditiveIterator, Extendable, Iterator, Map};
@ -65,7 +65,7 @@ impl PartialEq for Path {
}
}
impl TotalEq for Path {}
impl Eq for Path {}
impl FromStr for Path {
fn from_str(s: &str) -> Option<Path> {

4
src/libstd/path/windows.rs
View File

@ -13,7 +13,7 @@
use ascii::AsciiCast;
use c_str::{CString, ToCStr};
use clone::Clone;
use cmp::{PartialEq, TotalEq};
use cmp::{PartialEq, Eq};
use container::Container;
use from_str::FromStr;
use io::Writer;
@ -86,7 +86,7 @@ impl PartialEq for Path {
}
}
impl TotalEq for Path {}
impl Eq for Path {}
impl FromStr for Path {
fn from_str(s: &str) -> Option<Path> {

6
src/libstd/prelude.rs
View File

@ -58,7 +58,7 @@
#[doc(no_inline)] pub use c_str::ToCStr;
#[doc(no_inline)] pub use char::Char;
#[doc(no_inline)] pub use clone::Clone;
#[doc(no_inline)] pub use cmp::{PartialEq, PartialOrd, TotalEq, TotalOrd};
#[doc(no_inline)] pub use cmp::{PartialEq, PartialOrd, Eq, Ord};
#[doc(no_inline)] pub use cmp::{Ordering, Less, Equal, Greater, Equiv};
#[doc(no_inline)] pub use container::{Container, Mutable, Map, MutableMap};
#[doc(no_inline)] pub use container::{Set, MutableSet};
@ -81,9 +81,9 @@
#[doc(no_inline)] pub use tuple::{Tuple5, Tuple6, Tuple7, Tuple8};
#[doc(no_inline)] pub use tuple::{Tuple9, Tuple10, Tuple11, Tuple12};
#[doc(no_inline)] pub use slice::{CloneableVector, ImmutableCloneableVector};
#[doc(no_inline)] pub use slice::{MutableCloneableVector, MutableTotalOrdVector};
#[doc(no_inline)] pub use slice::{MutableCloneableVector, MutableOrdVector};
#[doc(no_inline)] pub use slice::{ImmutableVector, MutableVector};
#[doc(no_inline)] pub use slice::{ImmutableEqVector, ImmutableTotalOrdVector};
#[doc(no_inline)] pub use slice::{ImmutableEqVector, ImmutableOrdVector};
#[doc(no_inline)] pub use slice::{Vector, VectorVector, OwnedVector};
#[doc(no_inline)] pub use slice::MutableVectorAllocating;
#[doc(no_inline)] pub use string::String;

10
src/libstd/slice.rs
View File

@ -65,7 +65,7 @@ Vectors are a very useful type, and so there's several implementations of
traits from other modules. Some notable examples:
* `Clone`
* `Eq`, `Ord`, `TotalEq`, `TotalOrd` -- vectors can be compared,
* `Eq`, `Ord`, `Eq`, `Ord` -- vectors can be compared,
if the element type defines the corresponding trait.
## Iteration
@ -101,7 +101,7 @@ There are a number of free functions that create or take vectors, for example:
use mem::transmute;
use clone::Clone;
use cmp::{TotalOrd, Ordering, Less, Greater};
use cmp::{Ord, Ordering, Less, Greater};
use cmp;
use container::Container;
use iter::*;
@ -117,7 +117,7 @@ use vec::Vec;
pub use core::slice::{ref_slice, mut_ref_slice, Splits, Windows};
pub use core::slice::{Chunks, Vector, ImmutableVector, ImmutableEqVector};
pub use core::slice::{ImmutableTotalOrdVector, MutableVector, Items, MutItems};
pub use core::slice::{ImmutableOrdVector, MutableVector, Items, MutItems};
pub use core::slice::{MutSplits, MutChunks};
pub use core::slice::{bytes, MutableCloneableVector};
@ -698,7 +698,7 @@ impl<'a,T> MutableVectorAllocating<'a, T> for &'a mut [T] {
/// Methods for mutable vectors with orderable elements, such as
/// in-place sorting.
pub trait MutableTotalOrdVector<T> {
pub trait MutableOrdVector<T> {
/// Sort the vector, in place.
///
/// This is equivalent to `self.sort_by(|a, b| a.cmp(b))`.
@ -714,7 +714,7 @@ pub trait MutableTotalOrdVector<T> {
fn sort(self);
}
impl<'a, T: TotalOrd> MutableTotalOrdVector<T> for &'a mut [T] {
impl<'a, T: Ord> MutableOrdVector<T> for &'a mut [T] {
#[inline]
fn sort(self) {
self.sort_by(|a,b| a.cmp(b))

6
src/libstd/str.rs
View File

@ -70,7 +70,7 @@ is the same as `&[u8]`.
use char::Char;
use char;
use clone::Clone;
use cmp::{PartialEq, TotalEq, PartialOrd, TotalOrd, Equiv, Ordering};
use cmp::{PartialEq, Eq, PartialOrd, Ord, Equiv, Ordering};
use container::Container;
use default::Default;
use fmt;
@ -575,7 +575,7 @@ impl<'a> PartialEq for MaybeOwned<'a> {
}
}
impl<'a> TotalEq for MaybeOwned<'a> {}
impl<'a> Eq for MaybeOwned<'a> {}
impl<'a> PartialOrd for MaybeOwned<'a> {
#[inline]
@ -584,7 +584,7 @@ impl<'a> PartialOrd for MaybeOwned<'a> {
}
}
impl<'a> TotalOrd for MaybeOwned<'a> {
impl<'a> Ord for MaybeOwned<'a> {
#[inline]
fn cmp(&self, other: &MaybeOwned) -> Ordering {
self.as_slice().cmp(&other.as_slice())

2
src/libstd/string.rs
View File

@ -30,7 +30,7 @@ use str;
use vec::Vec;
/// A growable string stored as a UTF-8 encoded buffer.
#[deriving(Clone, PartialEq, PartialOrd, TotalEq, TotalOrd)]
#[deriving(Clone, PartialEq, PartialOrd, Eq, Ord)]
pub struct String {
vec: Vec<u8>,
}

10
src/libstd/vec.rs
View File

@ -12,7 +12,7 @@
use RawVec = raw::Vec;
use clone::Clone;
use cmp::{PartialOrd, PartialEq, Ordering, TotalEq, TotalOrd, max};
use cmp::{PartialOrd, PartialEq, Ordering, Eq, Ord, max};
use container::{Container, Mutable};
use default::Default;
use fmt;
@ -27,7 +27,7 @@ use ptr;
use raw::Slice;
use rt::heap::{allocate, reallocate, deallocate};
use slice::{ImmutableEqVector, ImmutableVector, Items, MutItems, MutableVector};
use slice::{MutableTotalOrdVector, OwnedVector, Vector};
use slice::{MutableOrdVector, OwnedVector, Vector};
use slice::{MutableVectorAllocating};
/// An owned, growable vector.
@ -388,9 +388,9 @@ impl<T: PartialOrd> PartialOrd for Vec<T> {
}
}
impl<T: TotalEq> TotalEq for Vec<T> {}
impl<T: Eq> Eq for Vec<T> {}
impl<T: TotalOrd> TotalOrd for Vec<T> {
impl<T: Ord> Ord for Vec<T> {
#[inline]
fn cmp(&self, other: &Vec<T>) -> Ordering {
self.as_slice().cmp(&other.as_slice())
@ -1263,7 +1263,7 @@ impl<T> Vec<T> {
}
}
impl<T:TotalOrd> Vec<T> {
impl<T:Ord> Vec<T> {
/// Sorts the vector in place.
///
/// This sort is `O(n log n)` worst-case and stable, but allocates

2
src/libsyntax/abi.rs
View File

@ -13,7 +13,7 @@ use std::fmt;
#[deriving(PartialEq)]
pub enum Os { OsWin32, OsMacos, OsLinux, OsAndroid, OsFreebsd, }
#[deriving(PartialEq, TotalEq, Hash, Encodable, Decodable, Clone)]
#[deriving(PartialEq, Eq, Hash, Encodable, Decodable, Clone)]
pub enum Abi {
// NB: This ordering MUST match the AbiDatas array below.
// (This is ensured by the test indices_are_correct().)

164
src/libsyntax/ast.rs
View File

@ -39,7 +39,7 @@ pub fn P<T: 'static>(value: T) -> P<T> {
// table) and a SyntaxContext to track renaming and
// macro expansion per Flatt et al., "Macros
// That Work Together"
#[deriving(Clone, Hash, PartialOrd, TotalEq, TotalOrd, Show)]
#[deriving(Clone, Hash, PartialOrd, Eq, Ord, Show)]
pub struct Ident {
pub name: Name,
pub ctxt: SyntaxContext
@ -114,7 +114,7 @@ impl<D:Decoder<E>, E> Decodable<D, E> for Ident {
/// Function name (not all functions have names)
pub type FnIdent = Option<Ident>;
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct Lifetime {
pub id: NodeId,
pub span: Span,
@ -125,7 +125,7 @@ pub struct Lifetime {
// for instance: std::cmp::PartialEq . It's represented
// as a sequence of identifiers, along with a bunch
// of supporting information.
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct Path {
pub span: Span,
/// A `::foo` path, is relative to the crate root rather than current
@ -137,7 +137,7 @@ pub struct Path {
/// A segment of a path: an identifier, an optional lifetime, and a set of
/// types.
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct PathSegment {
/// The identifier portion of this path segment.
pub identifier: Ident,
@ -151,7 +151,7 @@ pub type CrateNum = u32;
pub type NodeId = u32;
#[deriving(Clone, TotalEq, TotalOrd, PartialOrd, PartialEq, Encodable, Decodable, Hash, Show)]
#[deriving(Clone, Eq, Ord, PartialOrd, PartialEq, Encodable, Decodable, Hash, Show)]
pub struct DefId {
pub krate: CrateNum,
pub node: NodeId,
@ -171,14 +171,14 @@ pub static DUMMY_NODE_ID: NodeId = -1;
// typeck::collect::compute_bounds matches these against
// the "special" built-in traits (see middle::lang_items) and
// detects Copy, Send and Share.
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum TyParamBound {
TraitTyParamBound(TraitRef),
StaticRegionTyParamBound,
OtherRegionTyParamBound(Span) // FIXME -- just here until work for #5723 lands
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct TyParam {
pub ident: Ident,
pub id: NodeId,
@ -188,7 +188,7 @@ pub struct TyParam {
pub span: Span
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct Generics {
pub lifetimes: Vec<Lifetime>,
pub ty_params: OwnedSlice<TyParam>,
@ -206,13 +206,13 @@ impl Generics {
}
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum MethodProvenance {
FromTrait(DefId),
FromImpl(DefId),
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum Def {
DefFn(DefId, FnStyle),
DefStaticMethod(/* method */ DefId, MethodProvenance, FnStyle),
@ -249,7 +249,7 @@ pub enum Def {
DefMethod(DefId /* method */, Option<DefId> /* trait */),
}
#[deriving(Clone, PartialEq, TotalEq, Hash, Encodable, Decodable, Show)]
#[deriving(Clone, PartialEq, Eq, Hash, Encodable, Decodable, Show)]
pub enum DefRegion {
DefStaticRegion,
DefEarlyBoundRegion(/* index */ uint, /* lifetime decl */ NodeId),
@ -261,7 +261,7 @@ pub enum DefRegion {
// used to drive conditional compilation
pub type CrateConfig = Vec<@MetaItem> ;
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct Crate {
pub module: Mod,
pub attrs: Vec<Attribute>,
@ -271,7 +271,7 @@ pub struct Crate {
pub type MetaItem = Spanned<MetaItem_>;
#[deriving(Clone, Encodable, Decodable, TotalEq, Hash)]
#[deriving(Clone, Encodable, Decodable, Eq, Hash)]
pub enum MetaItem_ {
MetaWord(InternedString),
MetaList(InternedString, Vec<@MetaItem> ),
@ -303,7 +303,7 @@ impl PartialEq for MetaItem_ {
}
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct Block {
pub view_items: Vec<ViewItem>,
pub stmts: Vec<@Stmt>,
@ -313,26 +313,26 @@ pub struct Block {
pub span: Span,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct Pat {
pub id: NodeId,
pub node: Pat_,
pub span: Span,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct FieldPat {
pub ident: Ident,
pub pat: @Pat,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum BindingMode {
BindByRef(Mutability),
BindByValue(Mutability),
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum Pat_ {
PatWild,
PatWildMulti,
@ -358,20 +358,20 @@ pub enum Pat_ {
PatMac(Mac),
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash, Show)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash, Show)]
pub enum Mutability {
MutMutable,
MutImmutable,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum ExprVstore {
ExprVstoreUniq, // ~[1,2,3,4]
ExprVstoreSlice, // &[1,2,3,4]
ExprVstoreMutSlice, // &mut [1,2,3,4]
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum BinOp {
BiAdd,
BiSub,
@ -393,7 +393,7 @@ pub enum BinOp {
BiGt,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum UnOp {
UnBox,
UnUniq,
@ -404,7 +404,7 @@ pub enum UnOp {
pub type Stmt = Spanned<Stmt_>;
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum Stmt_ {
// could be an item or a local (let) binding:
StmtDecl(@Decl, NodeId),
@ -421,7 +421,7 @@ pub enum Stmt_ {
/// Where a local declaration came from: either a true `let ... =
/// ...;`, or one desugared from the pattern of a for loop.
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum LocalSource {
LocalLet,
LocalFor,
@ -430,7 +430,7 @@ pub enum LocalSource {
// FIXME (pending discussion of #1697, #2178...): local should really be
// a refinement on pat.
/// Local represents a `let` statement, e.g., `let <pat>:<ty> = <expr>;`
#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct Local {
pub ty: P<Ty>,
pub pat: @Pat,
@ -442,7 +442,7 @@ pub struct Local {
pub type Decl = Spanned<Decl_>;
#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum Decl_ {
// a local (let) binding:
DeclLocal(@Local),
@ -450,7 +450,7 @@ pub enum Decl_ {
DeclItem(@Item),
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct Arm {
pub attrs: Vec<Attribute>,
pub pats: Vec<@Pat>,
@ -458,7 +458,7 @@ pub struct Arm {
pub body: @Expr,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct Field {
pub ident: SpannedIdent,
pub expr: @Expr,
@ -467,26 +467,26 @@ pub struct Field {
pub type SpannedIdent = Spanned<Ident>;
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum BlockCheckMode {
DefaultBlock,
UnsafeBlock(UnsafeSource),
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum UnsafeSource {
CompilerGenerated,
UserProvided,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct Expr {
pub id: NodeId,
pub node: Expr_,
pub span: Span,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum Expr_ {
ExprVstore(@Expr, ExprVstore),
// First expr is the place; second expr is the value.
@ -555,7 +555,7 @@ pub enum Expr_ {
// else knows what to do with them, so you'll probably get a syntax
// error.
//
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
#[doc="For macro invocations; parsing is delegated to the macro"]
pub enum TokenTree {
// a single token
@ -631,7 +631,7 @@ pub enum TokenTree {
//
pub type Matcher = Spanned<Matcher_>;
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum Matcher_ {
// match one token
MatchTok(::parse::token::Token),
@ -648,12 +648,12 @@ pub type Mac = Spanned<Mac_>;
// is being invoked, and the vector of token-trees contains the source
// of the macro invocation.
// There's only one flavor, now, so this could presumably be simplified.
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum Mac_ {
MacInvocTT(Path, Vec<TokenTree> , SyntaxContext), // new macro-invocation
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum StrStyle {
CookedStr,
RawStr(uint)
@ -661,7 +661,7 @@ pub enum StrStyle {
pub type Lit = Spanned<Lit_>;
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum Lit_ {
LitStr(InternedString, StrStyle),
LitBinary(Rc<Vec<u8> >),
@ -677,20 +677,20 @@ pub enum Lit_ {
// NB: If you change this, you'll probably want to change the corresponding
// type structure in middle/ty.rs as well.
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct MutTy {
pub ty: P<Ty>,
pub mutbl: Mutability,
}
#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct TypeField {
pub ident: Ident,
pub mt: MutTy,
pub span: Span,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct TypeMethod {
pub ident: Ident,
pub attrs: Vec<Attribute>,
@ -706,13 +706,13 @@ pub struct TypeMethod {
// A trait method is either required (meaning it doesn't have an
// implementation, just a signature) or provided (meaning it has a default
// implementation).
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum TraitMethod {
Required(TypeMethod),
Provided(@Method),
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum IntTy {
TyI,
TyI8,
@ -728,7 +728,7 @@ impl fmt::Show for IntTy {
}
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum UintTy {
TyU,
TyU8,
@ -744,7 +744,7 @@ impl fmt::Show for UintTy {
}
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum FloatTy {
TyF32,
TyF64,
@ -758,7 +758,7 @@ impl fmt::Show for FloatTy {
}
// NB PartialEq method appears below.
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct Ty {
pub id: NodeId,
pub node: Ty_,
@ -766,7 +766,7 @@ pub struct Ty {
}
// Not represented directly in the AST, referred to by name through a ty_path.
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum PrimTy {
TyInt(IntTy),
TyUint(UintTy),
@ -776,7 +776,7 @@ pub enum PrimTy {
TyChar
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum Onceness {
Once,
Many
@ -791,7 +791,7 @@ impl fmt::Show for Onceness {
}
}
#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct ClosureTy {
pub lifetimes: Vec<Lifetime>,
pub fn_style: FnStyle,
@ -804,7 +804,7 @@ pub struct ClosureTy {
pub bounds: Option<OwnedSlice<TyParamBound>>,
}
#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct BareFnTy {
pub fn_style: FnStyle,
pub abi: Abi,
@ -812,7 +812,7 @@ pub struct BareFnTy {
pub decl: P<FnDecl>
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum Ty_ {
TyNil,
TyBot, /* bottom type */
@ -833,13 +833,13 @@ pub enum Ty_ {
TyInfer,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum AsmDialect {
AsmAtt,
AsmIntel
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct InlineAsm {
pub asm: InternedString,
pub asm_str_style: StrStyle,
@ -851,7 +851,7 @@ pub struct InlineAsm {
pub dialect: AsmDialect
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct Arg {
pub ty: P<Ty>,
pub pat: @Pat,
@ -878,7 +878,7 @@ impl Arg {
}
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct FnDecl {
pub inputs: Vec<Arg>,
pub output: P<Ty>,
@ -886,7 +886,7 @@ pub struct FnDecl {
pub variadic: bool
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum FnStyle {
UnsafeFn, // declared with "unsafe fn"
NormalFn, // declared with "fn"
@ -901,14 +901,14 @@ impl fmt::Show for FnStyle {
}
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum RetStyle {
NoReturn, // functions with return type _|_ that always
// raise an error or exit (i.e. never return to the caller)
Return, // everything else
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum ExplicitSelf_ {
SelfStatic, // no self
SelfValue, // `self`
@ -918,7 +918,7 @@ pub enum ExplicitSelf_ {
pub type ExplicitSelf = Spanned<ExplicitSelf_>;
#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct Method {
pub ident: Ident,
pub attrs: Vec<Attribute>,
@ -932,7 +932,7 @@ pub struct Method {
pub vis: Visibility,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct Mod {
/// A span from the first token past `{` to the last token until `}`.
/// For `mod foo;`, the inner span ranges from the first token
@ -942,31 +942,31 @@ pub struct Mod {
pub items: Vec<@Item>,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct ForeignMod {
pub abi: Abi,
pub view_items: Vec<ViewItem>,
pub items: Vec<@ForeignItem>,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct VariantArg {
pub ty: P<Ty>,
pub id: NodeId,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum VariantKind {
TupleVariantKind(Vec<VariantArg>),
StructVariantKind(@StructDef),
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct EnumDef {
pub variants: Vec<P<Variant>>,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct Variant_ {
pub name: Ident,
pub attrs: Vec<Attribute>,
@ -978,7 +978,7 @@ pub struct Variant_ {
pub type Variant = Spanned<Variant_>;
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct PathListIdent_ {
pub name: Ident,
pub id: NodeId,
@ -988,7 +988,7 @@ pub type PathListIdent = Spanned<PathListIdent_>;
pub type ViewPath = Spanned<ViewPath_>;
#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum ViewPath_ {
// quux = foo::bar::baz
@ -1005,7 +1005,7 @@ pub enum ViewPath_ {
ViewPathList(Path, Vec<PathListIdent> , NodeId)
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct ViewItem {
pub node: ViewItem_,
pub attrs: Vec<Attribute>,
@ -1013,7 +1013,7 @@ pub struct ViewItem {
pub span: Span,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum ViewItem_ {
// ident: name used to refer to this crate in the code
// optional (InternedString,StrStyle): if present, this is a location
@ -1029,17 +1029,17 @@ pub type Attribute = Spanned<Attribute_>;
// Distinguishes between Attributes that decorate items and Attributes that
// are contained as statements within items. These two cases need to be
// distinguished for pretty-printing.
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum AttrStyle {
AttrOuter,
AttrInner,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct AttrId(pub uint);
// doc-comments are promoted to attributes that have is_sugared_doc = true
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct Attribute_ {
pub id: AttrId,
pub style: AttrStyle,
@ -1054,13 +1054,13 @@ pub struct Attribute_ {
If this impl is an ItemImpl, the impl_id is redundant (it could be the
same as the impl's node id).
*/
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct TraitRef {
pub path: Path,
pub ref_id: NodeId,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum Visibility {
Public,
Inherited,
@ -1075,13 +1075,13 @@ impl Visibility {
}
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum Sized {
DynSize,
StaticSize,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct StructField_ {
pub kind: StructFieldKind,
pub id: NodeId,
@ -1091,7 +1091,7 @@ pub struct StructField_ {
pub type StructField = Spanned<StructField_>;
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum StructFieldKind {
NamedField(Ident, Visibility),
UnnamedField(Visibility), // element of a tuple-like struct
@ -1106,7 +1106,7 @@ impl StructFieldKind {
}
}
#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct StructDef {
pub fields: Vec<StructField>, /* fields, not including ctor */
/* ID of the constructor. This is only used for tuple- or enum-like
@ -1120,7 +1120,7 @@ pub struct StructDef {
FIXME (#3300): Should allow items to be anonymous. Right now
we just use dummy names for anon items.
*/
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct Item {
pub ident: Ident,
pub attrs: Vec<Attribute>,
@ -1130,7 +1130,7 @@ pub struct Item {
pub span: Span,
}
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum Item_ {
ItemStatic(P<Ty>, Mutability, @Expr),
ItemFn(P<FnDecl>, FnStyle, Abi, Generics, P<Block>),
@ -1148,7 +1148,7 @@ pub enum Item_ {
ItemMac(Mac),
}
#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct ForeignItem {
pub ident: Ident,
pub attrs: Vec<Attribute>,
@ -1158,7 +1158,7 @@ pub struct ForeignItem {
pub vis: Visibility,
}
#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum ForeignItem_ {
ForeignItemFn(P<FnDecl>, Generics),
ForeignItemStatic(P<Ty>, /* is_mutbl */ bool),
@ -1167,7 +1167,7 @@ pub enum ForeignItem_ {
// The data we save and restore about an inlined item or method. This is not
// part of the AST that we parse from a file, but it becomes part of the tree
// that we trans.
#[deriving(PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(PartialEq, Eq, Encodable, Decodable, Hash)]
pub enum InlinedItem {
IIItem(@Item),
IIMethod(DefId /* impl id */, bool /* is provided */, @Method),

6
src/libsyntax/codemap.rs
View File

@ -33,7 +33,7 @@ pub trait Pos {
/// A byte offset. Keep this small (currently 32-bits), as AST contains
/// a lot of them.
#[deriving(Clone, PartialEq, TotalEq, Hash, PartialOrd, Show)]
#[deriving(Clone, PartialEq, Eq, Hash, PartialOrd, Show)]
pub struct BytePos(pub u32);
/// A character offset. Because of multibyte utf8 characters, a byte offset
@ -96,7 +96,7 @@ pub struct Span {
pub static DUMMY_SP: Span = Span { lo: BytePos(0), hi: BytePos(0), expn_info: None };
#[deriving(Clone, PartialEq, TotalEq, Encodable, Decodable, Hash)]
#[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)]
pub struct Spanned<T> {
pub node: T,
pub span: Span,
@ -109,7 +109,7 @@ impl PartialEq for Span {
fn ne(&self, other: &Span) -> bool { !(*self).eq(other) }
}
impl TotalEq for Span {}
impl Eq for Span {}
impl<S:Encoder<E>, E> Encodable<S, E> for Span {
/* Note #1972 -- spans are encoded but not decoded */

2
src/libsyntax/ext/deriving/generic/mod.rs
View File

@ -28,7 +28,7 @@ Supported features (fairly exhaustive):
moment. (`TraitDef.additional_bounds`)
Unsupported: FIXME #6257: calling methods on reference fields,
e.g. deriving TotalEq/TotalOrd/Clone don't work on `struct A(&int)`,
e.g. deriving Eq/Ord/Clone don't work on `struct A(&int)`,
because of how the auto-dereferencing happens.
The most important thing for implementers is the `Substructure` and

4
src/libsyntax/ext/deriving/mod.rs
View File

@ -79,9 +79,9 @@ pub fn expand_meta_deriving(cx: &mut ExtCtxt,
// NOTE: after a stage0 snap this needs treatment
"PartialEq" => expand!(eq::expand_deriving_eq),
"Eq" | "TotalEq" => expand!(totaleq::expand_deriving_totaleq),
"Eq" => expand!(totaleq::expand_deriving_totaleq),
"PartialOrd" => expand!(ord::expand_deriving_ord),
"Ord" | "TotalOrd" => expand!(totalord::expand_deriving_totalord),
"Ord" => expand!(totalord::expand_deriving_totalord),
"Rand" => expand!(rand::expand_deriving_rand),

2
src/libsyntax/owned_slice.rs
View File

@ -119,7 +119,7 @@ impl<T: PartialEq> PartialEq for OwnedSlice<T> {
}
}
impl<T: TotalEq> TotalEq for OwnedSlice<T> {}
impl<T: Eq> Eq for OwnedSlice<T> {}
impl<T> Container for OwnedSlice<T> {
fn len(&self) -> uint { self.len }

2
src/libsyntax/parse/obsolete.rs
View File

@ -23,7 +23,7 @@ use parse::parser;
use parse::token;
/// The specific types of unsupported syntax
#[deriving(PartialEq, TotalEq, Hash)]
#[deriving(PartialEq, Eq, Hash)]
pub enum ObsoleteSyntax {
ObsoleteOwnedType,
ObsoleteOwnedExpr,

8
src/libsyntax/parse/token.rs
View File

@ -24,7 +24,7 @@ use std::rc::Rc;
use std::string::String;
#[allow(non_camel_case_types)]
#[deriving(Clone, Encodable, Decodable, PartialEq, TotalEq, Hash, Show)]
#[deriving(Clone, Encodable, Decodable, PartialEq, Eq, Hash, Show)]
pub enum BinOp {
PLUS,
MINUS,
@ -39,7 +39,7 @@ pub enum BinOp {
}
#[allow(non_camel_case_types)]
#[deriving(Clone, Encodable, Decodable, PartialEq, TotalEq, Hash, Show)]
#[deriving(Clone, Encodable, Decodable, PartialEq, Eq, Hash, Show)]
pub enum Token {
/* Expression-operator symbols. */
EQ,
@ -102,7 +102,7 @@ pub enum Token {
EOF,
}
#[deriving(Clone, Encodable, Decodable, PartialEq, TotalEq, Hash)]
#[deriving(Clone, Encodable, Decodable, PartialEq, Eq, Hash)]
/// For interpolation during macro expansion.
pub enum Nonterminal {
NtItem(@ast::Item),
@ -552,7 +552,7 @@ pub fn get_ident_interner() -> Rc<IdentInterner> {
/// destroyed. In particular, they must not access string contents. This can
/// be fixed in the future by just leaking all strings until task death
/// somehow.
#[deriving(Clone, PartialEq, Hash, PartialOrd, TotalEq, TotalOrd)]
#[deriving(Clone, PartialEq, Hash, PartialOrd, Eq, Ord)]
pub struct InternedString {
string: RcStr,
}

6
src/libsyntax/util/interner.rs
View File

@ -28,7 +28,7 @@ pub struct Interner<T> {
}
// when traits can extend traits, we should extend index<Name,T> to get []
impl<T: TotalEq + Hash + Clone + 'static> Interner<T> {
impl<T: Eq + Hash + Clone + 'static> Interner<T> {
pub fn new() -> Interner<T> {
Interner {
map: RefCell::new(HashMap::new()),
@ -95,9 +95,9 @@ pub struct RcStr {
string: Rc<String>,
}
impl TotalEq for RcStr {}
impl Eq for RcStr {}
impl TotalOrd for RcStr {
impl Ord for RcStr {
fn cmp(&self, other: &RcStr) -> Ordering {
self.as_slice().cmp(&other.as_slice())
}

4
src/libtest/lib.rs
View File

@ -83,7 +83,7 @@ pub mod stats;
// colons. This way if some test runner wants to arrange the tests
// hierarchically it may.
#[deriving(Clone, PartialEq, TotalEq, Hash)]
#[deriving(Clone, PartialEq, Eq, Hash)]
pub enum TestName {
StaticTestName(&'static str),
DynTestName(String)
@ -183,7 +183,7 @@ pub struct Bencher {
// The definition of a single test. A test runner will run a list of
// these.
#[deriving(Clone, Show, PartialEq, TotalEq, Hash)]
#[deriving(Clone, Show, PartialEq, Eq, Hash)]
pub struct TestDesc {
pub name: TestName,
pub ignore: bool,

2
src/libtest/stats.rs
View File

@ -441,7 +441,7 @@ pub fn write_boxplot<T: Float + Show + FromPrimitive>(
/// Returns a HashMap with the number of occurrences of every element in the
/// sequence that the iterator exposes.
pub fn freq_count<T: Iterator<U>, U: TotalEq+Hash>(mut iter: T) -> hashmap::HashMap<U, uint> {
pub fn freq_count<T: Iterator<U>, U: Eq+Hash>(mut iter: T) -> hashmap::HashMap<U, uint> {
let mut map: hashmap::HashMap<U,uint> = hashmap::HashMap::new();
for elem in iter {
map.insert_or_update_with(elem, 1, |_, count| *count += 1);

2
src/libtime/lib.rs
View File

@ -74,7 +74,7 @@ mod imp {
}
/// A record specifying a time value in seconds and nanoseconds.
#[deriving(Clone, PartialEq, TotalEq, PartialOrd, TotalOrd, Encodable, Decodable, Show)]
#[deriving(Clone, PartialEq, Eq, PartialOrd, Ord, Encodable, Decodable, Show)]
pub struct Timespec { pub sec: i64, pub nsec: i32 }
/*
* Timespec assumes that pre-epoch Timespecs have negative sec and positive

4
src/liburl/lib.rs
View File

@ -48,7 +48,7 @@ use std::uint;
/// fragment: Some("quz".to_string()) };
/// // https://username@example.com:8080/foo/bar?baz=qux#quz
/// ```
#[deriving(Clone, PartialEq, TotalEq)]
#[deriving(Clone, PartialEq, Eq)]
pub struct Url {
/// The scheme part of a URL, such as `https` in the above example.
pub scheme: String,
@ -81,7 +81,7 @@ pub struct Path {
}
/// An optional subcomponent of a URI authority component.
#[deriving(Clone, PartialEq, TotalEq)]
#[deriving(Clone, PartialEq, Eq)]
pub struct UserInfo {
/// The user name.
pub user: String,

2
src/libuuid/lib.rs
View File

@ -487,7 +487,7 @@ impl PartialEq for Uuid {
}
}
impl TotalEq for Uuid {}
impl Eq for Uuid {}
// FIXME #9845: Test these more thoroughly
impl<T: Encoder<E>, E> Encodable<T, E> for Uuid {

8
src/snapshots.txt
View File

@ -1,3 +1,11 @@
S 2014-05-30 60a43f9
freebsd-x86_64 59067eb9e89bde3e20a1078104f4b1105e4b56fc
linux-i386 c1a81811e8e104c91c35d94a140e3cf8463c7655
linux-x86_64 5c7167a2f964118103af5735a9215e8421803406
macos-i386 872b9818badefda412c7513b93742369f969094d
macos-x86_64 78c0f2ead6287c433d0cd18e1860404526ba5049
winnt-i386 63ca814f86493a8f06ab616b5e31d49a19bec1b2
S 2014-05-29 50b8528
freebsd-x86_64 cfa0dcc98a57f03a53bb53df6fd5db02143e2bee
linux-i386 baf7c6ab5792f3d560a0f2adc94d7ff96d0cab3d

2
src/test/bench/shootout-k-nucleotide.rs
View File

@ -30,7 +30,7 @@ static OCCURRENCES: [&'static str, ..5] = [
// Code implementation
#[deriving(PartialEq, PartialOrd, TotalOrd, TotalEq)]
#[deriving(PartialEq, PartialOrd, Ord, Eq)]
struct Code(u64);
impl Code {

2
src/test/compile-fail/deriving-span-TotalEq-enum-struct-variant.rs
View File

@ -16,7 +16,7 @@ extern crate rand;
#[deriving(PartialEq)]
struct Error;
#[deriving(TotalEq,PartialEq)]
#[deriving(Eq,PartialEq)]
enum Enum {
A {
x: Error //~ ERROR

2
src/test/compile-fail/deriving-span-TotalEq-enum.rs
View File

@ -16,7 +16,7 @@ extern crate rand;
#[deriving(PartialEq)]
struct Error;
#[deriving(TotalEq,PartialEq)]
#[deriving(Eq,PartialEq)]
enum Enum {
A(
Error //~ ERROR

2
src/test/compile-fail/deriving-span-TotalEq-struct.rs
View File

@ -16,7 +16,7 @@ extern crate rand;
#[deriving(PartialEq)]
struct Error;
#[deriving(TotalEq,PartialEq)]
#[deriving(Eq,PartialEq)]
struct Struct {
x: Error //~ ERROR
}

2
src/test/compile-fail/deriving-span-TotalEq-tuple-struct.rs
View File

@ -16,7 +16,7 @@ extern crate rand;
#[deriving(PartialEq)]
struct Error;
#[deriving(TotalEq,PartialEq)]
#[deriving(Eq,PartialEq)]
struct Struct(
Error //~ ERROR
);

4
src/test/compile-fail/deriving-span-TotalOrd-enum-struct-variant.rs
View File

@ -13,10 +13,10 @@
#![feature(struct_variant)]
extern crate rand;
#[deriving(TotalEq,PartialOrd,PartialEq)]
#[deriving(Eq,PartialOrd,PartialEq)]
struct Error;
#[deriving(TotalOrd,TotalEq,PartialOrd,PartialEq)]
#[deriving(Ord,Eq,PartialOrd,PartialEq)]
enum Enum {
A {
x: Error //~ ERROR

4
src/test/compile-fail/deriving-span-TotalOrd-enum.rs
View File

@ -13,10 +13,10 @@
#![feature(struct_variant)]
extern crate rand;
#[deriving(TotalEq,PartialOrd,PartialEq)]
#[deriving(Eq,PartialOrd,PartialEq)]
struct Error;
#[deriving(TotalOrd,TotalEq,PartialOrd,PartialEq)]
#[deriving(Ord,Eq,PartialOrd,PartialEq)]
enum Enum {
A(
Error //~ ERROR

4
src/test/compile-fail/deriving-span-TotalOrd-struct.rs
View File

@ -13,10 +13,10 @@
#![feature(struct_variant)]
extern crate rand;
#[deriving(TotalEq,PartialOrd,PartialEq)]
#[deriving(Eq,PartialOrd,PartialEq)]
struct Error;
#[deriving(TotalOrd,TotalEq,PartialOrd,PartialEq)]
#[deriving(Ord,Eq,PartialOrd,PartialEq)]
struct Struct {
x: Error //~ ERROR
}

4
src/test/compile-fail/deriving-span-TotalOrd-tuple-struct.rs
View File

@ -13,10 +13,10 @@
#![feature(struct_variant)]
extern crate rand;
#[deriving(TotalEq,PartialOrd,PartialEq)]
#[deriving(Eq,PartialOrd,PartialEq)]
struct Error;
#[deriving(TotalOrd,TotalEq,PartialOrd,PartialEq)]
#[deriving(Ord,Eq,PartialOrd,PartialEq)]
struct Struct(
Error //~ ERROR
);

6
src/test/run-pass/deriving-cmp-generic-enum.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#[deriving(PartialEq, TotalEq, PartialOrd, TotalOrd)]
#[deriving(PartialEq, Eq, PartialOrd, Ord)]
enum E<T> {
E0,
E1(T),
@ -22,7 +22,7 @@ pub fn main() {
let e21 = E2(1, 1);
let e22 = E2(1, 2);
// in order for both PartialOrd and TotalOrd
// in order for both PartialOrd and Ord
let es = [e0, e11, e12, e21, e22];
for (i, e1) in es.iter().enumerate() {
@ -46,7 +46,7 @@ pub fn main() {
assert_eq!(*e1 <= *e2, le);
assert_eq!(*e1 >= *e2, ge);
// TotalOrd
// Ord
assert_eq!(e1.cmp(e2), ord);
}
}

6
src/test/run-pass/deriving-cmp-generic-struct-enum.rs
View File

@ -10,7 +10,7 @@
#![feature(struct_variant)]
#[deriving(PartialEq, TotalEq, PartialOrd, TotalOrd)]
#[deriving(PartialEq, Eq, PartialOrd, Ord)]
enum ES<T> {
ES1 { x: T },
ES2 { x: T, y: T }
@ -20,7 +20,7 @@ enum ES<T> {
pub fn main() {
let (es11, es12, es21, es22) = (ES1 {x: 1}, ES1 {x: 2}, ES2 {x: 1, y: 1}, ES2 {x: 1, y: 2});
// in order for both PartialOrd and TotalOrd
// in order for both PartialOrd and Ord
let ess = [es11, es12, es21, es22];
for (i, es1) in ess.iter().enumerate() {
@ -42,7 +42,7 @@ pub fn main() {
assert_eq!(*es1 <= *es2, le);
assert_eq!(*es1 >= *es2, ge);
// TotalOrd
// Ord
assert_eq!(es1.cmp(es2), ord);
}
}

6
src/test/run-pass/deriving-cmp-generic-struct.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#[deriving(PartialEq, TotalEq, PartialOrd, TotalOrd)]
#[deriving(PartialEq, Eq, PartialOrd, Ord)]
struct S<T> {
x: T,
y: T
@ -18,7 +18,7 @@ pub fn main() {
let s1 = S {x: 1, y: 1};
let s2 = S {x: 1, y: 2};
// in order for both PartialOrd and TotalOrd
// in order for both PartialOrd and Ord
let ss = [s1, s2];
for (i, s1) in ss.iter().enumerate() {
@ -42,7 +42,7 @@ pub fn main() {
assert_eq!(*s1 <= *s2, le);
assert_eq!(*s1 >= *s2, ge);
// TotalOrd
// Ord
assert_eq!(s1.cmp(s2), ord);
}
}

6
src/test/run-pass/deriving-cmp-generic-tuple-struct.rs
View File

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#[deriving(PartialEq, TotalEq, PartialOrd, TotalOrd)]
#[deriving(PartialEq, Eq, PartialOrd, Ord)]
struct TS<T>(T,T);
@ -16,7 +16,7 @@ pub fn main() {
let ts1 = TS(1, 1);
let ts2 = TS(1, 2);
// in order for both PartialOrd and TotalOrd
// in order for both PartialOrd and Ord
let tss = [ts1, ts2];
for (i, ts1) in tss.iter().enumerate() {
@ -40,7 +40,7 @@ pub fn main() {
assert_eq!(*ts1 <= *ts2, le);
assert_eq!(*ts1 >= *ts2, ge);
// TotalOrd
// Ord
assert_eq!(ts1.cmp(ts2), ord);
}
}

6
src/test/run-pass/deriving-cmp-shortcircuit.rs
View File

@ -21,13 +21,13 @@ impl PartialOrd for FailCmp {
fn lt(&self, _: &FailCmp) -> bool { fail!("lt") }
}
impl TotalEq for FailCmp {}
impl Eq for FailCmp {}
impl TotalOrd for FailCmp {
impl Ord for FailCmp {
fn cmp(&self, _: &FailCmp) -> Ordering { fail!("cmp") }
}
#[deriving(PartialEq,PartialOrd,TotalEq,TotalOrd)]
#[deriving(PartialEq,PartialOrd,Eq,Ord)]
struct ShortCircuit {
x: int,
y: FailCmp

6
src/test/run-pass/deriving-global.rs
View File

@ -15,21 +15,21 @@ mod submod {
// if any of these are implemented without global calls for any
// function calls, then being in a submodule will (correctly)
// cause errors about unrecognised module `std` (or `extra`)
#[deriving(PartialEq, PartialOrd, TotalEq, TotalOrd,
#[deriving(PartialEq, PartialOrd, Eq, Ord,
Hash,
Clone,
Show, Rand,
Encodable, Decodable)]
enum A { A1(uint), A2(int) }
#[deriving(PartialEq, PartialOrd, TotalEq, TotalOrd,
#[deriving(PartialEq, PartialOrd, Eq, Ord,
Hash,
Clone,
Show, Rand,
Encodable, Decodable)]
struct B { x: uint, y: int }
#[deriving(PartialEq, PartialOrd, TotalEq, TotalOrd,
#[deriving(PartialEq, PartialOrd, Eq, Ord,
Hash,
Clone,
Show, Rand,

2
src/test/run-pass/deriving-self-lifetime-totalord-totaleq.rs
View File

@ -12,7 +12,7 @@
use std::cmp::{Less,Equal,Greater};
#[deriving(TotalEq,TotalOrd)]
#[deriving(Eq,Ord)]
struct A<'a> {
x: &'a int
}

2
src/test/run-pass/issue-12860.rs
View File

@ -13,7 +13,7 @@ extern crate collections;
use collections::HashSet;
#[deriving(PartialEq, TotalEq, Hash)]
#[deriving(PartialEq, Eq, Hash)]
struct XYZ {
x: int,
y: int,

4
src/test/run-pass/regions-mock-tcx.rs
View File

@ -40,7 +40,7 @@ impl<'tcx> PartialEq for TypeStructure<'tcx> {
}
}
impl<'tcx> TotalEq for TypeStructure<'tcx> {}
impl<'tcx> Eq for TypeStructure<'tcx> {}
struct TypeContext<'tcx, 'ast> {
ty_arena: &'tcx Arena,
@ -86,7 +86,7 @@ impl<'tcx,'ast> TypeContext<'tcx, 'ast> {
}
}
#[deriving(PartialEq, TotalEq, Hash)]
#[deriving(PartialEq, Eq, Hash)]
struct NodeId {
id: uint
}

2
src/test/run-pass/vector-sort-failure-safe.rs
View File

@ -15,7 +15,7 @@ static MAX_LEN: uint = 20;
static mut drop_counts: [uint, .. MAX_LEN] = [0, .. MAX_LEN];
static mut clone_count: uint = 0;
#[deriving(Rand, PartialEq, PartialOrd, TotalEq, TotalOrd)]
#[deriving(Rand, PartialEq, PartialOrd, Eq, Ord)]
struct DropCounter { x: uint, clone_num: uint }
impl Clone for DropCounter {