---

yaml
---
r: 114302
b: refs/heads/master
c: 564b925
h: refs/heads/master
v: v3

Author: limeburst

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: e8c579e01d026df002fe6522d6f9c123b3920dc8
+refs/heads/master: 564b9250362cc7bb0f40320bf2cedc58ec47b077
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ec0258a381b88b5574e3f8ce72ae553ac3a574b7
 refs/heads/try: 7c6c492fb2af9a85f21ff952942df3523b22fd17

trunk/src/doc/rust.md

@@ -2943,7 +2943,7 @@ See [Break expressions](#break-expressions) and [Continue expressions](#continue
 break_expr : "break" [ lifetime ];
 ~~~~
 
-A `break` expression has an optional _label_.
+A `break` expression has an optional `label`.
 If the label is absent, then executing a `break` expression immediately terminates the innermost loop enclosing it.
 It is only permitted in the body of a loop.
 If the label is present, then `break foo` terminates the loop with label `foo`,
@@ -2956,7 +2956,7 @@ but must enclose it.
 continue_expr : "continue" [ lifetime ];
 ~~~~
 
-A `continue` expression has an optional _label_.
+A `continue` expression has an optional `label`.
 If the label is absent,
 then executing a `continue` expression immediately terminates the current iteration of the innermost loop enclosing it,
 returning control to the loop *head*.
@@ -3115,7 +3115,7 @@ let x: List<int> = Cons(10, box Cons(11, box Nil));
 
 match x {
     Cons(a, box Cons(b, _)) => {
-        process_pair(a, b);
+        process_pair(a,b);
     }
     Cons(10, _) => {
         process_ten();
@@ -3329,8 +3329,8 @@ order specified by the tuple type.
 An example of a tuple type and its use:
 
 ~~~~
-type Pair<'a> = (int, &'a str);
-let p: Pair<'static> = (10, "hello");
+type Pair<'a> = (int,&'a str);
+let p: Pair<'static> = (10,"hello");
 let (a, b) = p;
 assert!(b != "world");
 ~~~~

trunk/src/doc/tutorial.md

@@ -2602,7 +2602,7 @@ fn main() {
 ~~~
 
 The full list of derivable traits is `Eq`, `TotalEq`, `Ord`,
-`TotalOrd`, `Encodable`, `Decodable`, `Clone`,
+`TotalOrd`, `Encodable` `Decodable`, `Clone`,
 `Hash`, `Rand`, `Default`, `Zero`, `FromPrimitive` and `Show`.
 
 # Crates and the module system

trunk/src/libcollections/dlist.rs

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

trunk/src/libcollections/priority_queue.rs

@@ -22,30 +22,30 @@ 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> {
         Items { iter: self.data.iter() }
     }
 
-    /// Returns the greatest item in a queue or None if it is empty
-    pub fn top<'a>(&'a self) -> Option<&'a T> {
-        if self.is_empty() { None } else { Some(self.data.get(0)) }
-    }
+    /// Returns the greatest item in the queue - fails if empty
+    pub fn top<'a>(&'a self) -> &'a T { self.data.get(0) }
 
-    #[deprecated="renamed to `top`"]
-    pub fn maybe_top<'a>(&'a self) -> Option<&'a T> { self.top() }
+    /// Returns the greatest item in the queue - None if empty
+    pub fn maybe_top<'a>(&'a self) -> Option<&'a T> {
+        if self.is_empty() { None } else { Some(self.top()) }
+    }
 
     /// Returns the number of elements the queue can hold without reallocating
     pub fn capacity(&self) -> uint { self.data.capacity() }
@@ -60,23 +60,20 @@ impl<T: TotalOrd> PriorityQueue<T> {
         self.data.reserve(n)
     }
 
-    /// Remove the greatest item from a queue and return it, or `None` if it is
-    /// empty.
-    pub fn pop(&mut self) -> Option<T> {
-        match self.data.pop() {
-            None           => { None }
-            Some(mut item) => {
-                if !self.is_empty() {
-                    swap(&mut item, self.data.get_mut(0));
-                    self.siftdown(0);
-                }
-                Some(item)
-            }
+    /// Pop the greatest item from the queue - fails if empty
+    pub fn pop(&mut self) -> T {
+        let mut item = self.data.pop().unwrap();
+        if !self.is_empty() {
+            swap(&mut item, self.data.get_mut(0));
+            self.siftdown(0);
         }
+        item
     }
 
-    #[deprecated="renamed to `pop`"]
-    pub fn maybe_pop(&mut self) -> Option<T> { self.pop() }
+    /// Pop the greatest item from the queue - None if empty
+    pub fn maybe_pop(&mut self) -> Option<T> {
+        if self.is_empty() { None } else { Some(self.pop()) }
+    }
 
     /// Push an item onto the queue
     pub fn push(&mut self, item: T) {
@@ -87,48 +84,34 @@ impl<T: TotalOrd> PriorityQueue<T> {
 
     /// Optimized version of a push followed by a pop
     pub fn push_pop(&mut self, mut item: T) -> T {
-        if !self.is_empty() && *self.top().unwrap() > item {
+        if !self.is_empty() && *self.top() > item {
             swap(&mut item, self.data.get_mut(0));
             self.siftdown(0);
         }
         item
     }
 
-    /// Optimized version of a pop followed by a push. The push is done
-    /// regardless of whether the queue is empty.
-    pub fn replace(&mut self, mut item: T) -> Option<T> {
-        if !self.is_empty() {
-            swap(&mut item, self.data.get_mut(0));
-            self.siftdown(0);
-            Some(item)
-        } else {
-            self.push(item);
-            None
-        }
+    /// Optimized version of a pop followed by a push - fails if empty
+    pub fn replace(&mut self, mut item: T) -> T {
+        swap(&mut item, self.data.get_mut(0));
+        self.siftdown(0);
+        item
     }
 
-    #[allow(dead_code)]
-    #[deprecated="renamed to `into_vec`"]
-    fn to_vec(self) -> Vec<T> { self.into_vec() }
-
-    #[allow(dead_code)]
-    #[deprecated="renamed to `into_sorted_vec`"]
-    fn to_sorted_vec(self) -> Vec<T> { self.into_sorted_vec() }
-
     /// Consume the PriorityQueue and return the underlying vector
-    pub fn into_vec(self) -> Vec<T> { let PriorityQueue{data: v} = self; v }
+    pub fn to_vec(self) -> Vec<T> { let PriorityQueue{data: v} = self; v }
 
     /// Consume the PriorityQueue and return a vector in sorted
     /// (ascending) order
-    pub fn into_sorted_vec(self) -> Vec<T> {
+    pub fn to_sorted_vec(self) -> Vec<T> {
         let mut q = self;
         let mut end = q.len();
         while end > 1 {
             end -= 1;
             q.data.as_mut_slice().swap(0, end);
             q.siftdown_range(0, end)
         }
-        q.into_vec()
+        q.to_vec()
     }
 
     /// Create an empty PriorityQueue
@@ -214,15 +197,15 @@ 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);
         q
     }
 }
 
-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();
 
@@ -258,53 +241,53 @@ mod tests {
         sorted.sort();
         let mut heap = PriorityQueue::from_vec(data);
         while !heap.is_empty() {
-            assert_eq!(heap.top().unwrap(), sorted.last().unwrap());
-            assert_eq!(heap.pop().unwrap(), sorted.pop().unwrap());
+            assert_eq!(heap.top(), sorted.last().unwrap());
+            assert_eq!(heap.pop(), sorted.pop().unwrap());
         }
     }
 
     #[test]
     fn test_push() {
         let mut heap = PriorityQueue::from_vec(vec!(2, 4, 9));
         assert_eq!(heap.len(), 3);
-        assert!(*heap.top().unwrap() == 9);
+        assert!(*heap.top() == 9);
         heap.push(11);
         assert_eq!(heap.len(), 4);
-        assert!(*heap.top().unwrap() == 11);
+        assert!(*heap.top() == 11);
         heap.push(5);
         assert_eq!(heap.len(), 5);
-        assert!(*heap.top().unwrap() == 11);
+        assert!(*heap.top() == 11);
         heap.push(27);
         assert_eq!(heap.len(), 6);
-        assert!(*heap.top().unwrap() == 27);
+        assert!(*heap.top() == 27);
         heap.push(3);
         assert_eq!(heap.len(), 7);
-        assert!(*heap.top().unwrap() == 27);
+        assert!(*heap.top() == 27);
         heap.push(103);
         assert_eq!(heap.len(), 8);
-        assert!(*heap.top().unwrap() == 103);
+        assert!(*heap.top() == 103);
     }
 
     #[test]
     fn test_push_unique() {
         let mut heap = PriorityQueue::from_vec(vec!(box 2, box 4, box 9));
         assert_eq!(heap.len(), 3);
-        assert!(*heap.top().unwrap() == box 9);
+        assert!(*heap.top() == box 9);
         heap.push(box 11);
         assert_eq!(heap.len(), 4);
-        assert!(*heap.top().unwrap() == box 11);
+        assert!(*heap.top() == box 11);
         heap.push(box 5);
         assert_eq!(heap.len(), 5);
-        assert!(*heap.top().unwrap() == box 11);
+        assert!(*heap.top() == box 11);
         heap.push(box 27);
         assert_eq!(heap.len(), 6);
-        assert!(*heap.top().unwrap() == box 27);
+        assert!(*heap.top() == box 27);
         heap.push(box 3);
         assert_eq!(heap.len(), 7);
-        assert!(*heap.top().unwrap() == box 27);
+        assert!(*heap.top() == box 27);
         heap.push(box 103);
         assert_eq!(heap.len(), 8);
-        assert!(*heap.top().unwrap() == box 103);
+        assert!(*heap.top() == box 103);
     }
 
     #[test]
@@ -325,24 +308,24 @@ mod tests {
     fn test_replace() {
         let mut heap = PriorityQueue::from_vec(vec!(5, 5, 2, 1, 3));
         assert_eq!(heap.len(), 5);
-        assert_eq!(heap.replace(6).unwrap(), 5);
+        assert_eq!(heap.replace(6), 5);
         assert_eq!(heap.len(), 5);
-        assert_eq!(heap.replace(0).unwrap(), 6);
+        assert_eq!(heap.replace(0), 6);
         assert_eq!(heap.len(), 5);
-        assert_eq!(heap.replace(4).unwrap(), 5);
+        assert_eq!(heap.replace(4), 5);
         assert_eq!(heap.len(), 5);
-        assert_eq!(heap.replace(1).unwrap(), 4);
+        assert_eq!(heap.replace(1), 4);
         assert_eq!(heap.len(), 5);
     }
 
     fn check_to_vec(mut data: Vec<int>) {
         let heap = PriorityQueue::from_vec(data.clone());
-        let mut v = heap.clone().into_vec();
+        let mut v = heap.clone().to_vec();
         v.sort();
         data.sort();
 
         assert_eq!(v, data);
-        assert_eq!(heap.into_sorted_vec(), data);
+        assert_eq!(heap.to_sorted_vec(), data);
     }
 
     #[test]
@@ -363,21 +346,36 @@ mod tests {
     }
 
     #[test]
+    #[should_fail]
     fn test_empty_pop() {
         let mut heap: PriorityQueue<int> = PriorityQueue::new();
-        assert!(heap.pop().is_none());
+        heap.pop();
+    }
+
+    #[test]
+    fn test_empty_maybe_pop() {
+        let mut heap: PriorityQueue<int> = PriorityQueue::new();
+        assert!(heap.maybe_pop().is_none());
     }
 
     #[test]
+    #[should_fail]
     fn test_empty_top() {
         let empty: PriorityQueue<int> = PriorityQueue::new();
-        assert!(empty.top().is_none());
+        empty.top();
+    }
+
+    #[test]
+    fn test_empty_maybe_top() {
+        let empty: PriorityQueue<int> = PriorityQueue::new();
+        assert!(empty.maybe_top().is_none());
     }
 
     #[test]
+    #[should_fail]
     fn test_empty_replace() {
         let mut heap: PriorityQueue<int> = PriorityQueue::new();
-        heap.replace(5).is_none();
+        heap.replace(5);
     }
 
     #[test]
@@ -387,7 +385,7 @@ mod tests {
         let mut q: PriorityQueue<uint> = xs.as_slice().iter().rev().map(|&x| x).collect();
 
         for &x in xs.iter() {
-            assert_eq!(q.pop().unwrap(), x);
+            assert_eq!(q.pop(), x);
         }
     }
 }

trunk/src/libcore/bool.rs

@@ -15,14 +15,11 @@
 //! Implementations of the following traits:
 //!
 //! * `Not`
-//! * `BitAnd`
-//! * `BitOr`
-//! * `BitXor`
 //! * `Ord`
 //! * `TotalOrd`
 //! * `Eq`
-//! * `TotalEq`
 //! * `Default`
+//! * `Zero`
 //!
 //! A `to_bit` conversion function.
 

trunk/src/libcore/lib.rs

@@ -17,7 +17,7 @@
 //!
 //! * `memcpy`, `memcmp`, `memset` - These are core memory routines which are
 //!   often generated by LLVM. Additionally, this library can make explicit
-//!   calls to these funcitons. Their signatures are the same as found in C.
+//!   calls to these functions. Their signatures are the same as found in C.
 //!   These functions are often provided by the system libc, but can also be
 //!   provided by `librlibc` which is distributed with the standard rust
 //!   distribution.