---

yaml
---
r: 139013
b: refs/heads/try2
c: 387aa36
h: refs/heads/master
i:
  139011: 30bba9b
v: v3

Author: z0w0

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 73b253dc800efe9fa73edfed4663d175b667129b
+refs/heads/try2: 387aa3668a4ff865c5554a9f3dac2d339f8ef7aa
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/RELEASES.txt

@@ -10,8 +10,7 @@ Version 0.6 (March 2013)
       * Remove `static` keyword
       * Static method syntax
       * `as Trait`
-      * `copy` removed, replaced with `Clone`?
-      * `std::map` removed, replaced with `core::hashmap`
+      * `copy` removed?
 
    * Syntax changes
       * The self type parameter in traits is now spelled `Self`
@@ -39,8 +38,7 @@ Version 0.6 (March 2013)
       * Trait implementations no longer support visibility modifiers
 
    * Semantic changes
-      * Types with owned pointers or custom destructors move by default,
-        eliminating the `move` keyword
+      * Linear types move by default, eliminating the `move` keyword
       * All foreign functions are considered unsafe
       * &mut is now unaliasable
       * Writes to borrowed @mut pointers are prevented dynamically
@@ -59,19 +57,16 @@ Version 0.6 (March 2013)
         improve inference and eliminate unsoundness
 
    * Libraries
+      * Lots of effort to organize the container API's around `core::container`
+      * `core::send_map` renamed to `core::hashmap`
       * Added big integers to `std::bigint`
       * Removed `core::oldcomm` module
       * Added pipe-based `core::comm` module
+      * Reimplemented `std::treemap`
       * Numeric traits have been reorganized under `core::num`
+      * `core::dvec` removed. Use `@mut ~[T]` or other language types
       * `vec::slice` finally returns a slice
       * `debug!` and friends don't require a format string, e.g. `debug!(Foo)`
-      * Containers reorganized around traits in `core::container`
-      * `core::dvec` removed, `~[T]` is a drop-in replacement
-      * `core::send_map` renamed to `core::hashmap`
-      * `std::treemap` reimplemented as an owned balanced tree
-      * `std::deque` and `std::smallintmap` reimplemented as owned containers
-      * `core::trie` added as a fast ordered map for integer keys
-      * Set types added to `core::hashmap`, `core::trie` and `std::treemap`
 
    * Tools
       * Replaced the 'cargo' package manager with 'rustpkg'

branches/try2/mk/rt.mk

@@ -132,7 +132,7 @@ rt/$(1)/%.o: rt/%.S  $$(MKFILE_DEPS) \
 
 rt/$(1)/arch/$$(HOST_$(1))/libmorestack.a: $$(MORESTACK_OBJ_$(1))
 	@$$(call E, link: $$@)
-	$$(Q)$(AR_$(1)) rcs $$@ $$<
+	$$(Q)ar rcs $$@ $$<
 
 rt/$(1)/$(CFG_RUNTIME_$(1)): $$(RUNTIME_OBJS_$(1)) $$(MKFILE_DEPS) \
                         $$(RUNTIME_DEF_$(1)) \

branches/try2/src/libcore/container.rs

@@ -35,9 +35,6 @@ pub trait Map<K, V>: Mutable {
     /// Visit all values
     pure fn each_value(&self, f: &fn(&V) -> bool);
 
-    /// Iterate over the map and mutate the contained values
-    fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool);
-
     /// Return the value corresponding to the key in the map
     pure fn find(&self, key: &K) -> Option<&self/V>;
 

branches/try2/src/libcore/core.rc

@@ -56,7 +56,6 @@ Implicitly, all crates behave as if they included the following prologue:
 
 // On Linux, link to the runtime with -lrt.
 #[cfg(target_os = "linux")]
-#[doc(hidden)]
 pub mod linkhack {
     #[link_args="-lrustrt -lrt"]
     #[link_args = "-lpthread"]
@@ -253,7 +252,7 @@ pub mod rt;
 // A curious inner-module that's not exported that contains the binding
 // 'core' so that macro-expanded references to core::error and such
 // can be resolved within libcore.
-#[doc(hidden)]
+#[doc(hidden)] // FIXME #3538
 pub mod core {
     #[cfg(stage0)]
     pub const error : u32 = 1_u32;

branches/try2/src/libcore/hashmap.rs

@@ -325,19 +325,6 @@ pub mod linear {
             self.each(|&(_, v)| blk(v))
         }
 
-        /// Iterate over the map and mutate the contained values
-        fn mutate_values(&mut self, blk: &fn(&'self K,
-                              &'self mut V) -> bool) {
-            for uint::range(0, self.buckets.len()) |i| {
-                match self.buckets[i] {
-                  Some(Bucket{key: ref key, value: ref mut value, _}) => {
-                    if !blk(key, value) { return }
-                  }
-                  None => ()
-                }
-            }
-        }
-
         /// Return the value corresponding to the key in the map
         pure fn find(&self, k: &K) -> Option<&self/V> {
             match self.bucket_for_key(k) {

branches/try2/src/libcore/iter.rs

@@ -31,10 +31,6 @@ pub trait ReverseIter<A>: BaseIter<A> {
     pure fn each_reverse(&self, blk: &fn(&A) -> bool);
 }
 
-pub trait MutableIter<A>: BaseIter<A> {
-    fn each_mut(&mut self, blk: &fn(&mut A) -> bool);
-}
-
 pub trait ExtendedIter<A> {
     pure fn eachi(&self, blk: &fn(uint, v: &A) -> bool);
     pure fn all(&self, blk: &fn(&A) -> bool) -> bool;

branches/try2/src/libcore/prelude.rs

@@ -27,9 +27,8 @@ pub use clone::Clone;
 pub use cmp::{Eq, Ord, TotalOrd, Ordering, Less, Equal, Greater};
 pub use container::{Container, Mutable, Map, Set};
 pub use hash::Hash;
-pub use iter::{BaseIter, ReverseIter, MutableIter, ExtendedIter, EqIter};
-pub use iter::{CopyableIter, CopyableOrderedIter, CopyableNonstrictIter};
-pub use iter::Times;
+pub use iter::{BaseIter, ReverseIter, ExtendedIter, EqIter, CopyableIter};
+pub use iter::{CopyableOrderedIter, CopyableNonstrictIter, Times};
 pub use num::NumCast;
 pub use path::GenericPath;
 pub use path::Path;
@@ -44,10 +43,6 @@ pub use vec::{CopyableVector, ImmutableVector};
 pub use vec::{ImmutableEqVector, ImmutableCopyableVector};
 pub use vec::{OwnedVector, OwnedCopyableVector};
 
-/* Reexported runtime types */
-pub use comm::{stream, Port, Chan, GenericChan, GenericSmartChan, GenericPort, Peekable};
-pub use task::spawn;
-
 /* Reexported modules */
 
 pub use at_vec;

branches/try2/src/libcore/trie.rs

@@ -81,16 +81,11 @@ impl<T> Map<uint, T> for TrieMap<T> {
 
     /// Visit all values in order
     #[inline(always)]
-    pure fn each_value(&self, f: &fn(&T) -> bool) {
+    pure fn each_value(&self,
+                       f: &fn(&T) -> bool) {
         self.each(|&(_, v)| f(v))
     }
 
-    /// Iterate over the map and mutate the contained values
-    #[inline(always)]
-    fn mutate_values(&mut self, f: &fn(&uint, &mut T) -> bool) {
-        self.root.mutate_values(f);
-    }
-
     /// Return the value corresponding to the key in the map
     #[inline(hint)]
     pure fn find(&self, key: &uint) -> Option<&self/T> {
@@ -155,6 +150,11 @@ impl<T> TrieMap<T> {
     pure fn each_value_reverse(&self, f: &fn(&T) -> bool) {
         self.each_reverse(|&(_, v)| f(v))
     }
+
+    /// Iterate over the map and mutate the contained values
+    fn mutate_values(&mut self, f: &fn(uint, &mut T) -> bool) {
+        self.root.mutate_values(f);
+    }
 }
 
 pub struct TrieSet {
@@ -248,13 +248,13 @@ impl<T> TrieNode<T> {
         true
     }
 
-    fn mutate_values(&mut self, f: &fn(&uint, &mut T) -> bool) -> bool {
+    fn mutate_values(&mut self, f: &fn(uint, &mut T) -> bool) -> bool {
         for vec::each_mut(self.children) |child| {
             match *child {
                 Internal(ref mut x) => if !x.mutate_values(f) {
                     return false
                 },
-                External(k, ref mut v) => if !f(&k, v) { return false },
+                External(k, ref mut v) => if !f(k, v) { return false },
                 Nothing => ()
             }
         }
@@ -269,8 +269,8 @@ pure fn chunk(n: uint, idx: uint) -> uint {
     (n >> (SHIFT * real_idx)) & MASK
 }
 
-fn insert<T>(count: &mut uint, child: &mut Child<T>, key: uint, value: T,
-             idx: uint) -> bool {
+fn insert<T>(count: &mut uint, child: &mut Child<T>, key: uint,
+                   value: T, idx: uint) -> bool {
     let mut tmp = Nothing;
     tmp <-> *child;
     let mut added = false;

branches/try2/src/libcore/vec.rs

@@ -1357,7 +1357,7 @@ pub pure fn each<T>(v: &r/[T], f: &fn(&r/T) -> bool) {
 /// a vector with mutable contents and you would like
 /// to mutate the contents as you iterate.
 #[inline(always)]
-pub fn each_mut<T>(v: &'r mut [T], f: &fn(elem: &'r mut T) -> bool) {
+pub fn each_mut<T>(v: &mut [T], f: &fn(elem: &mut T) -> bool) {
     let mut i = 0;
     let n = v.len();
     while i < n {
@@ -2280,9 +2280,11 @@ pub mod bytes {
 // ___________________________________________________________________________
 // ITERATION TRAIT METHODS
 
-impl<A> iter::BaseIter<A> for &'self [A] {
+impl<A> iter::BaseIter<A> for &self/[A] {
     #[inline(always)]
-    pure fn each(&self, blk: &fn(v: &'self A) -> bool) { each(*self, blk) }
+    pub pure fn each(&self, blk: &fn(v: &'self A) -> bool) {
+        each(*self, blk)
+    }
     #[inline(always)]
     pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
 }
@@ -2303,29 +2305,6 @@ impl<A> iter::BaseIter<A> for @[A] {
     pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
 }
 
-impl<A> iter::MutableIter<A> for &'self mut [A] {
-    #[inline(always)]
-    fn each_mut(&mut self, blk: &fn(v: &'self mut A) -> bool) {
-        each_mut(*self, blk)
-    }
-}
-
-// FIXME(#4148): This should be redundant
-impl<A> iter::MutableIter<A> for ~[A] {
-    #[inline(always)]
-    fn each_mut(&mut self, blk: &fn(v: &'self mut A) -> bool) {
-        each_mut(*self, blk)
-    }
-}
-
-// FIXME(#4148): This should be redundant
-impl<A> iter::MutableIter<A> for @mut [A] {
-    #[inline(always)]
-    fn each_mut(&mut self, blk: &fn(v: &mut A) -> bool) {
-        each_mut(*self, blk)
-    }
-}
-
 impl<A> iter::ExtendedIter<A> for &self/[A] {
     pub pure fn eachi(&self, blk: &fn(uint, v: &A) -> bool) {
         iter::eachi(self, blk)

branches/try2/src/librustc/middle/astencode.rs

@@ -1203,8 +1203,8 @@ impl fake_ext_ctxt for fake_session {
 }
 
 #[cfg(test)]
-fn mk_ctxt() -> @fake_ext_ctxt {
-    @parse::new_parse_sess(None) as @fake_ext_ctxt
+fn mk_ctxt() -> fake_ext_ctxt {
+    @parse::new_parse_sess(None) as fake_ext_ctxt
 }
 
 #[cfg(test)]

branches/try2/src/librustdoc/rustdoc.rc

@@ -116,8 +116,7 @@ fn run(config: Config) {
             // Remove things marked doc(hidden)
             prune_hidden_pass::mk_pass(),
             // Remove things that are private
-            // XXX enable this after 'export' is removed in favor of 'pub'
-            // prune_private_pass::mk_pass(),
+            prune_private_pass::mk_pass(),
             // Extract brief documentation from the full descriptions
             desc_to_brief_pass::mk_pass(),
             // Massage the text to remove extra indentation

branches/try2/src/libstd/smallintmap.rs

@@ -85,17 +85,7 @@ impl<V> Map<uint, V> for SmallIntMap<V> {
         self.each(|&(_, v)| blk(v))
     }
 
-    /// Visit all key-value pairs in order
-    fn mutate_values(&mut self, it: &fn(&uint, &'self mut V) -> bool) {
-        for uint::range(0, self.v.len()) |i| {
-            match self.v[i] {
-              Some(ref mut elt) => if !it(&i, elt) { break },
-              None => ()
-            }
-        }
-    }
-
-    /// Iterate over the map and mutate the contained values
+    /// Return the value corresponding to the key in the map
     pure fn find(&self, key: &uint) -> Option<&self/V> {
         if *key < self.v.len() {
             match self.v[*key] {

branches/try2/src/libstd/treemap.rs

@@ -134,11 +134,6 @@ impl<K: TotalOrd, V> Map<K, V> for TreeMap<K, V> {
         self.each(|&(_, v)| f(v))
     }
 
-    /// Iterate over the map and mutate the contained values
-    fn mutate_values(&mut self, f: &fn(&'self K, &'self mut V) -> bool) {
-        mutate_values(&mut self.root, f);
-    }
-
     /// Return the value corresponding to the key in the map
     pure fn find(&self, key: &K) -> Option<&self/V> {
         let mut current: &self/Option<~TreeNode<K, V>> = &self.root;
@@ -563,20 +558,6 @@ pure fn each_reverse<K: TotalOrd, V>(node: &r/Option<~TreeNode<K, V>>,
     }
 }
 
-fn mutate_values<K: TotalOrd, V>(node: &'r mut Option<~TreeNode<K, V>>,
-                                 f: &fn(&'r K, &'r mut V) -> bool) -> bool {
-    match *node {
-      Some(~TreeNode{key: ref key, value: ref mut value, left: ref mut left,
-                     right: ref mut right, _}) => {
-        if !mutate_values(left, f) { return false }
-        if !f(key, value) { return false }
-        if !mutate_values(right, f) { return false }
-      }
-      None => return false
-    }
-    true
-}
-
 // Remove left horizontal link by rotating right
 fn skew<K: TotalOrd, V>(node: &mut ~TreeNode<K, V>) {
     if node.left.map_default(false, |x| x.level == node.level) {

branches/try2/src/libsyntax/parse/mod.rs

@@ -300,7 +300,7 @@ mod test {
     use core::str;
     use util::testing::*;
 
-    #[test] fn to_json_str (val: @Encodable<std::json::Encoder>) -> ~str {
+    #[test] fn to_json_str (val: Encodable<std::json::Encoder>) -> ~str {
         do io::with_str_writer |writer| {
             val.encode(~std::json::Encoder(writer));
         }

branches/try2/src/rt/rust_builtin.cpp

@@ -321,7 +321,7 @@ get_time(int64_t *sec, int32_t *nsec) {
     ul.HighPart = fileTime.dwHighDateTime;
     uint64_t ns_since_1601 = ul.QuadPart / 10;
 
-    const uint64_t NANOSECONDS_FROM_1601_TO_1970 = 11644473600000000ull;
+    const uint64_t NANOSECONDS_FROM_1601_TO_1970 = 11644473600000000u;
     uint64_t ns_since_1970 = ns_since_1601 - NANOSECONDS_FROM_1601_TO_1970;
     *sec = ns_since_1970 / 1000000;
     *nsec = (ns_since_1970 % 1000000) * 1000;

branches/try2/src/test/bench/core-std.rs

@@ -17,7 +17,6 @@ use std::oldmap;
 use std::oldmap::{Map, HashMap};
 
 use core::io::{Reader, ReaderUtil};
-use core::rand::RngUtil;
 
 macro_rules! bench (
     ($id:ident) => (maybe_run_test(argv, stringify!($id).to_owned(), $id))

branches/try2/src/test/bench/graph500-bfs.rs

@@ -29,7 +29,6 @@ use std::deque::Deque;
 use std::par;
 use core::io::WriterUtil;
 use core::int::abs;
-use core::rand::RngUtil;
 
 type node_id = i64;
 type graph = ~[~[node_id]];
@@ -38,7 +37,7 @@ type bfs_result = ~[node_id];
 fn make_edges(scale: uint, edgefactor: uint) -> ~[(node_id, node_id)] {
     let r = rand::xorshift();
 
-    fn choose_edge(i: node_id, j: node_id, scale: uint, r: @rand::Rng)
+    fn choose_edge(i: node_id, j: node_id, scale: uint, r: rand::Rng)
         -> (node_id, node_id) {
 
         let A = 0.57;

branches/try2/src/test/bench/noise.rs

@@ -1,7 +1,5 @@
 // Perlin noise benchmark from https://gist.github.com/1170424
 
-use core::rand::RngUtil;
-
 struct Vec2 {
     x: f32,
     y: f32,
@@ -10,7 +8,7 @@ struct Vec2 {
 fn lerp(a: f32, b: f32, v: f32) -> f32  { a * (1.0 - v) + b * v }
 fn smooth(v: f32) -> f32                { v * v * (3.0 - 2.0 * v) }
 
-fn random_gradient(r: @rand::Rng) -> Vec2 {
+fn random_gradient(r: rand::Rng) -> Vec2 {
     let v = r.gen_float() * float::consts::pi * 2.0;
     Vec2{
         x: float::cos(v) as f32,