---

yaml
---
r: 41831
b: refs/heads/master
c: a438bdc
h: refs/heads/master
i:
  41829: 38ff5ef
  41827: f974c00
  41823: 4c4908b
v: v3

Author: catamorphism

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 5320e132d1f60a7787f8290b7d8c7e16fcf9ccae
+refs/heads/master: a438bdc8a6b2be0dc3583f42d00b7800038fd64a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2f46b763da2c098913884f101b6d71d69af41b49
 refs/heads/try: 3d5418789064fdb463e872a4e651af1c628a3650

trunk/src/libcore/container.rs

@@ -122,7 +122,6 @@ pub mod to_bytes;
 pub mod clone;
 pub mod io;
 pub mod hash;
-pub mod container;
 
 
 /* Common data structures */

trunk/src/libcore/core.rc

@@ -286,7 +286,13 @@ impl ReprVisitor : TyVisitor {
     fn visit_f32() -> bool { self.write::<f32>() }
     fn visit_f64() -> bool { self.write::<f64>() }
 
-    fn visit_char() -> bool { self.write::<u32>() }
+    fn visit_char() -> bool {
+        do self.get::<char> |&ch| {
+            self.writer.write_char('\'');
+            self.writer.write_escaped_char(ch);
+            self.writer.write_char('\'');
+        }
+    }
 
     // Type no longer exists, vestigial function.
     fn visit_str() -> bool { fail; }

trunk/src/libcore/repr.rs

@@ -1,4 +1,4 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -46,8 +46,6 @@ pub trait SendMap<K:Eq Hash, V: Copy> {
 
 /// Open addressing with linear probing.
 pub mod linear {
-    use iter::BaseIter;
-    use container::Set;
     use cmp::Eq;
     use cmp;
     use hash::Hash;
@@ -444,7 +442,7 @@ pub mod linear {
         }
     }
 
-    impl<K:Hash IterBytes Eq, V: Eq> LinearMap<K, V>: Eq {
+    impl<K:Hash IterBytes Eq, V: Eq> LinearMap<K, V>: cmp::Eq {
         pure fn eq(&self, other: &LinearMap<K, V>) -> bool {
             if self.len() != other.len() { return false; }
 
@@ -462,47 +460,6 @@ pub mod linear {
             !self.eq(other)
         }
     }
-
-    pub struct LinearSet<T: Hash IterBytes Eq> {
-        priv map: LinearMap<T, ()>
-    }
-
-    impl <T: Hash IterBytes Eq> LinearSet<T>: BaseIter<T> {
-        /// Visit all values in order
-        pure fn each(&self, f: fn(&T) -> bool) { self.map.each_key(f) }
-        pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
-    }
-
-    impl <T: Hash IterBytes Eq> LinearSet<T>: Eq {
-        pure fn eq(&self, other: &LinearSet<T>) -> bool { self.map == other.map }
-        pure fn ne(&self, other: &LinearSet<T>) -> bool { self.map != other.map }
-    }
-
-    impl <T: Hash IterBytes Eq> LinearSet<T>: Set<T> {
-        /// Return true if the set contains a value
-        pure fn contains(&self, value: &T) -> bool {
-            self.map.contains_key(value)
-        }
-
-        /// Add a value to the set. Return true if the value was not already
-        /// present in the set.
-        fn insert(&mut self, value: T) -> bool { self.map.insert(value, ()) }
-
-        /// Remove a value from the set. Return true if the value was
-        /// present in the set.
-        fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
-    }
-
-    impl <T: Hash IterBytes Eq> LinearSet<T> {
-        /// Create an empty LinearSet
-        static fn new() -> LinearSet<T> { LinearSet{map: LinearMap()} }
-
-        /// Return the number of elements in the set
-        pure fn len(&self) -> uint { self.map.len() }
-
-        /// Return true if the set contains no elements
-        pure fn is_empty(&self) -> bool { self.map.is_empty() }
-    }
 }
 
 #[test]

trunk/src/libcore/send_map.rs

@@ -14,7 +14,6 @@
 
 #[forbid(deprecated_mode)];
 
-use core::container::Set;
 use core::cmp::{Eq, Ord};
 use core::option::{Option, Some, None};
 use core::prelude::*;
@@ -198,21 +197,6 @@ impl <T: Eq Ord> TreeSet<T>: Eq {
     pure fn ne(&self, other: &TreeSet<T>) -> bool { self.map != other.map }
 }
 
-impl <T: Ord> TreeSet<T>: Set<T> {
-    /// Return true if the set contains a value
-    pure fn contains(&self, value: &T) -> bool {
-        self.map.contains_key(value)
-    }
-
-    /// Add a value to the set. Return true if the value was not already
-    /// present in the set.
-    fn insert(&mut self, value: T) -> bool { self.map.insert(value, ()) }
-
-    /// Remove a value from the set. Return true if the value was
-    /// present in the set.
-    fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
-}
-
 impl <T: Ord> TreeSet<T> {
     /// Create an empty TreeSet
     static pure fn new() -> TreeSet<T> { TreeSet{map: TreeMap::new()} }
@@ -231,6 +215,19 @@ impl <T: Ord> TreeSet<T> {
         self.map.each_key_reverse(f)
     }
 
+    /// Return true if the set contains a value
+    pure fn contains(&self, value: &T) -> bool {
+        self.map.contains_key(value)
+    }
+
+    /// Add a value to the set. Return true if the value was not
+    /// already present in the set.
+    fn insert(&mut self, value: T) -> bool { self.map.insert(value, ()) }
+
+    /// Remove a value from the set. Return true if the value was
+    /// present in the set.
+    fn remove(&mut self, value: &T) -> bool { self.map.remove(value) }
+
     /// Get a lazy iterator over the values in the set.
     /// Requires that it be frozen (immutable).
     pure fn iter(&self) -> TreeSetIterator/&self<T> {