---

yaml
---
r: 152281
b: refs/heads/try2
c: 6a58537
h: refs/heads/master
i:
  152279: 74124f8
v: v3

Author: alexcrichton

[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: 3ec321f535cbeae3399c6b13b34d7098c480cf0e
+refs/heads/try2: 6a585375a01b7c6b52ad93f764220bcb18027ef6
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/crates.mk

@@ -60,36 +60,36 @@ DEPS_core :=
 DEPS_rlibc :=
 DEPS_alloc := core libc native:jemalloc
 DEPS_debug := std
-DEPS_std := core rand libc alloc native:rustrt native:backtrace
+DEPS_std := core rand libc alloc collections native:rustrt native:backtrace
 DEPS_graphviz := std
 DEPS_green := std native:context_switch
 DEPS_rustuv := std native:uv native:uv_support
 DEPS_native := std
-DEPS_syntax := std term serialize collections log fmt_macros debug
+DEPS_syntax := std term serialize log fmt_macros debug
 DEPS_rustc := syntax native:rustllvm flate arena serialize sync getopts \
-              collections time log graphviz debug
-DEPS_rustdoc := rustc native:hoedown serialize sync getopts collections \
+              time log graphviz debug
+DEPS_rustdoc := rustc native:hoedown serialize sync getopts \
                 test time debug
 DEPS_flate := std native:miniz
-DEPS_arena := std collections
+DEPS_arena := std
 DEPS_graphviz := std
 DEPS_glob := std
-DEPS_serialize := std collections log
-DEPS_term := std collections log
+DEPS_serialize := std log
+DEPS_term := std log
 DEPS_semver := std
 DEPS_uuid := std serialize
 DEPS_sync := std alloc
 DEPS_getopts := std
-DEPS_collections := std debug
+DEPS_collections := core alloc
 DEPS_fourcc := syntax std
 DEPS_hexfloat := syntax std
 DEPS_num := std
-DEPS_test := std collections getopts serialize term time regex
+DEPS_test := std getopts serialize term time regex
 DEPS_time := std serialize sync
 DEPS_rand := core
-DEPS_url := std collections
+DEPS_url := std
 DEPS_log := std sync
-DEPS_regex := std collections
+DEPS_regex := std
 DEPS_regex_macros = syntax std regex
 DEPS_fmt_macros = std
 
@@ -105,6 +105,7 @@ ONLY_RLIB_libc := 1
 ONLY_RLIB_rlibc := 1
 ONLY_RLIB_alloc := 1
 ONLY_RLIB_rand := 1
+ONLY_RLIB_collections := 1
 
 ################################################################################
 # You should not need to edit below this line

branches/try2/src/libcollections/bitv.rs

@@ -10,14 +10,17 @@
 
 #![allow(missing_doc)]
 
+use core::prelude::*;
 
-use std::cmp;
-use std::fmt;
-use std::iter::RandomAccessIterator;
-use std::iter::{Enumerate, Repeat, Map, Zip};
-use std::ops;
-use std::slice;
-use std::uint;
+use core::cmp;
+use core::fmt;
+use core::iter::{Enumerate, Repeat, Map, Zip};
+use core::ops;
+use core::slice;
+use core::uint;
+
+use string::String;
+use vec::Vec;
 
 #[deriving(Clone)]
 struct SmallBitv {

branches/try2/src/libcollections/btree.rs

@@ -18,8 +18,13 @@
 ///a length (the height of the tree), and lower and upper bounds on the
 ///number of elements that a given node can contain.
 
-use std::fmt;
-use std::fmt::Show;
+use core::prelude::*;
+
+use alloc::owned::Box;
+use core::fmt;
+use core::fmt::Show;
+
+use vec::Vec;
 
 #[allow(missing_doc)]
 pub struct BTree<K, V> {

branches/try2/src/libcollections/deque.rs

@@ -10,7 +10,7 @@
 
 //! Container traits for collections
 
-use std::container::Mutable;
+use core::prelude::*;
 
 /// A double-ended sequence that allows querying, insertion and deletion at both ends.
 pub trait Deque<T> : Mutable {

branches/try2/src/libcollections/dlist.rs

@@ -21,9 +21,12 @@
 // Backlinks over DList::prev are raw pointers that form a full chain in
 // the reverse direction.
 
-use std::iter;
-use std::mem;
-use std::ptr;
+use core::prelude::*;
+
+use alloc::owned::Box;
+use core::iter;
+use core::mem;
+use core::ptr;
 
 use deque::Deque;
 

branches/try2/src/libcollections/enum_set.rs

@@ -13,7 +13,9 @@
 //! This module defines a container which uses an efficient bit mask
 //! representation to hold C-like enum variants.
 
-use std::num::Bitwise;
+use core::prelude::*;
+
+use core::num::Bitwise;
 
 #[deriving(Clone, PartialEq, Eq, Hash, Show)]
 /// A specialized Set implementation to use enum types.

branches/try2/src/libstd/hash/mod.rs renamed to branches/try2/src/libcollections/hash/mod.rs

@@ -63,22 +63,17 @@
 
 #![allow(unused_must_use)]
 
-use container::Container;
-use intrinsics::TypeId;
-use iter::Iterator;
-use option::{Option, Some, None};
-use owned::Box;
-use rc::Rc;
-use result::{Result, Ok, Err};
-use slice::{Vector, ImmutableVector};
-use str::{Str, StrSlice};
+use core::prelude::*;
+
+use alloc::owned::Box;
+use alloc::rc::Rc;
+use core::intrinsics::TypeId;
+
 use vec::Vec;
 
 /// Reexport the `sip::hash` function as our default hasher.
 pub use hash = self::sip::hash;
 
-pub use Writer = io::Writer;
-
 pub mod sip;
 
 /// A trait that represents a hashable type. The `S` type parameter is an
@@ -96,33 +91,29 @@ pub trait Hasher<S> {
     fn hash<T: Hash<S>>(&self, value: &T) -> u64;
 }
 
+pub trait Writer {
+    fn write(&mut self, bytes: &[u8]);
+}
+
 //////////////////////////////////////////////////////////////////////////////
 
 macro_rules! impl_hash(
-    ( $( $ty:ty => $method:ident;)* ) => (
+    ( $($ty:ident)* ) => (
         $(
             impl<S: Writer> Hash<S> for $ty {
                 #[inline]
                 fn hash(&self, state: &mut S) {
-                    state.$method(*self);
+                    let a: [u8, ..::core::$ty::BYTES] = unsafe {
+                        ::core::mem::transmute(*self)
+                    };
+                    state.write(a.as_slice())
                 }
             }
         )*
     )
 )
 
-impl_hash!(
-    u8 => write_u8;
-    u16 => write_le_u16;
-    u32 => write_le_u32;
-    u64 => write_le_u64;
-    uint => write_le_uint;
-    i8 => write_i8;
-    i16 => write_le_i16;
-    i32 => write_le_i32;
-    i64 => write_le_i64;
-    int => write_le_int;
-)
+impl_hash!( u8 u16 u32 u64 uint i8 i16 i32 i64 int )
 
 impl<S: Writer> Hash<S> for bool {
     #[inline]
@@ -142,7 +133,7 @@ impl<'a, S: Writer> Hash<S> for &'a str {
     #[inline]
     fn hash(&self, state: &mut S) {
         state.write(self.as_bytes());
-        state.write_u8(0xFF);
+        0xffu8.hash(state)
     }
 }
 

branches/try2/src/libstd/hash/sip.rs renamed to branches/try2/src/libcollections/hash/sip.rs

@@ -24,17 +24,11 @@
  * discouraged.
  */
 
-use clone::Clone;
-use container::Container;
-use default::Default;
-use int;
-use io::{IoResult, Writer};
-use iter::Iterator;
-use result::Ok;
-use slice::ImmutableVector;
-use uint;
-
-use super::{Hash, Hasher};
+use core::prelude::*;
+
+use core::default::Default;
+
+use super::{Hash, Hasher, Writer};
 
 /// `SipState` computes a SipHash 2-4 hash over a stream of bytes.
 pub struct SipState {
@@ -151,41 +145,11 @@ impl SipState {
 
         v0 ^ v1 ^ v2 ^ v3
     }
-
-    #[inline]
-    fn write_le(&mut self, n: u64, size: uint) {
-        self.tail |= n << 8*self.ntail;
-        self.ntail += size;
-
-        if self.ntail >= 8 {
-            let m = self.tail;
-
-            self.v3 ^= m;
-            compress!(self.v0, self.v1, self.v2, self.v3);
-            compress!(self.v0, self.v1, self.v2, self.v3);
-            self.v0 ^= m;
-
-            self.ntail -= 8;
-            if self.ntail == 0 {
-                self.tail = 0;
-            } else {
-                self.tail = n >> 64 - 8*self.ntail;
-            }
-        }
-    }
 }
 
-macro_rules! make_write_le(
-    ($this:expr, $n:expr, $size:expr) => ({
-          $this.write_le($n as u64, $size);
-          $this.length += $size;
-          Ok(())
-    })
-)
-
 impl Writer for SipState {
     #[inline]
-    fn write(&mut self, msg: &[u8]) -> IoResult<()> {
+    fn write(&mut self, msg: &[u8]) {
         let length = msg.len();
         self.length += length;
 
@@ -196,7 +160,7 @@ impl Writer for SipState {
             if length < needed {
                 self.tail |= u8to64_le!(msg, 0, length) << 8*self.ntail;
                 self.ntail += length;
-                return Ok(());
+                return
             }
 
             let m = self.tail | u8to64_le!(msg, 0, needed) << 8*self.ntail;
@@ -228,60 +192,7 @@ impl Writer for SipState {
 
         self.tail = u8to64_le!(msg, i, left);
         self.ntail = left;
-
-        Ok(())
-    }
-
-    #[inline]
-    fn write_u8(&mut self, n: u8) -> IoResult<()> {
-        make_write_le!(self, n, 1)
-    }
-
-    #[inline]
-    fn write_le_u16(&mut self, n: u16) -> IoResult<()> {
-        make_write_le!(self, n, 2)
     }
-
-    #[inline]
-    fn write_le_u32(&mut self, n: u32) -> IoResult<()> {
-        make_write_le!(self, n, 4)
-    }
-
-    #[inline]
-    fn write_le_u64(&mut self, n: u64) -> IoResult<()> {
-        make_write_le!(self, n, 8)
-    }
-
-    #[inline]
-    fn write_le_uint(&mut self, n: uint) -> IoResult<()> {
-        make_write_le!(self, n, uint::BYTES)
-    }
-
-    #[inline]
-    fn write_i8(&mut self, n: i8) -> IoResult<()> {
-        make_write_le!(self, n, 1)
-    }
-
-    #[inline]
-    fn write_le_i16(&mut self, n: i16) -> IoResult<()> {
-        make_write_le!(self, n, 2)
-    }
-
-    #[inline]
-    fn write_le_i32(&mut self, n: i32) -> IoResult<()> {
-        make_write_le!(self, n, 4)
-    }
-
-    #[inline]
-    fn write_le_i64(&mut self, n: i64) -> IoResult<()> {
-        make_write_le!(self, n, 8)
-    }
-
-    #[inline]
-    fn write_le_int(&mut self, n: int) -> IoResult<()> {
-        make_write_le!(self, n, int::BYTES)
-    }
-
 }
 
 impl Clone for SipState {