---

yaml
---
r: 159935
b: refs/heads/try
c: 01b599e
h: refs/heads/master
i:
  159933: efc6952
  159931: 451595a
  159927: 440331d
  159919: 00cb0a1
  159903: 064232b
  159871: 96009d3
v: v3

Author: jbcrail

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: e09d98603e608c9e47d4c89f7b4dca87a4b56da3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 9c96a79a74f10bed18b031ce0ac4126c56d6cfb3
-refs/heads/try: 946225d77f65e307de3c216cbc2c686b880a6791
+refs/heads/try: 01b599eb34125b7bc4d01fd7cc24876179ad6798
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/mk/docs.mk

@@ -28,13 +28,13 @@
 DOCS := index intro tutorial guide guide-ffi guide-macros guide-lifetimes \
 	guide-tasks guide-container guide-pointers guide-testing \
 	guide-plugin guide-crates complement-bugreport \
-	complement-lang-faq complement-design-faq complement-project-faq \
+	complement-lang-faq complement-design-faq complement-project-faq rust \
     rustdoc guide-unsafe guide-strings reference
 
 PDF_DOCS := guide reference
 
-RUSTDOC_DEPS_reference := doc/full-toc.inc
-RUSTDOC_FLAGS_reference := --html-in-header=doc/full-toc.inc
+RUSTDOC_DEPS_rust := doc/full-toc.inc
+RUSTDOC_FLAGS_rust := --html-in-header=doc/full-toc.inc
 
 L10N_LANGS := ja
 

branches/try/src/doc/intro.md

@@ -217,7 +217,7 @@ including the right thing!) Even though we compiled with flags to give us as
 many warnings as possible, and to treat those warnings as errors, we got no
 errors. When we ran the program, it crashed.
 
-Why does this happen? When we append to an array, its length changes. Since
+Why does this happen? When we prepend to an array, its length changes. Since
 its length changes, we may need to allocate more memory. In Ruby, this happens
 as well, we just don't think about it very often. So why does the C++ version
 segfault when we allocate more memory?

branches/try/src/etc/vim/syntax/rust.vim

@@ -93,7 +93,7 @@ syn keyword rustEnum Ordering
 syn keyword rustEnumVariant Less Equal Greater
 syn keyword rustTrait Collection Mutable Map MutableMap MutableSeq
 syn keyword rustTrait Set MutableSet
-syn keyword rustTrait FromIterator IntoIterator Extend ExactSize
+syn keyword rustTrait FromIterator Extendable ExactSize
 syn keyword rustTrait Iterator DoubleEndedIterator
 syn keyword rustTrait RandomAccessIterator CloneableIterator
 syn keyword rustTrait OrdIterator MutableDoubleEndedIterator

branches/try/src/libcollections/binary_heap.rs

@@ -555,7 +555,7 @@ impl<T: Ord> FromIterator<T> for BinaryHeap<T> {
     }
 }
 
-impl<T: Ord> Extend<T> for BinaryHeap<T> {
+impl<T: Ord> Extendable<T> for BinaryHeap<T> {
     fn extend<Iter: Iterator<T>>(&mut self, mut iter: Iter) {
         let (lower, _) = iter.size_hint();
 

branches/try/src/libcollections/bit.rs

@@ -835,7 +835,7 @@ impl FromIterator<bool> for Bitv {
     }
 }
 
-impl Extend<bool> for Bitv {
+impl Extendable<bool> for Bitv {
     #[inline]
     fn extend<I: Iterator<bool>>(&mut self, mut iterator: I) {
         let (min, _) = iterator.size_hint();
@@ -1014,7 +1014,7 @@ impl FromIterator<bool> for BitvSet {
     }
 }
 
-impl Extend<bool> for BitvSet {
+impl Extendable<bool> for BitvSet {
     #[inline]
     fn extend<I: Iterator<bool>>(&mut self, iterator: I) {
         let &BitvSet(ref mut self_bitv) = self;

branches/try/src/libcollections/btree/map.rs

@@ -727,7 +727,7 @@ impl<K: Ord, V> FromIterator<(K, V)> for BTreeMap<K, V> {
     }
 }
 
-impl<K: Ord, V> Extend<(K, V)> for BTreeMap<K, V> {
+impl<K: Ord, V> Extendable<(K, V)> for BTreeMap<K, V> {
     #[inline]
     fn extend<T: Iterator<(K, V)>>(&mut self, mut iter: T) {
         for (k, v) in iter {

branches/try/src/libcollections/btree/set.rs

@@ -316,7 +316,7 @@ impl<T: Ord> FromIterator<T> for BTreeSet<T> {
     }
 }
 
-impl<T: Ord> Extend<T> for BTreeSet<T> {
+impl<T: Ord> Extendable<T> for BTreeSet<T> {
     #[inline]
     fn extend<Iter: Iterator<T>>(&mut self, mut iter: Iter) {
         for elem in iter {

branches/try/src/libcollections/dlist.rs

@@ -720,7 +720,7 @@ impl<A> FromIterator<A> for DList<A> {
     }
 }
 
-impl<A> Extend<A> for DList<A> {
+impl<A> Extendable<A> for DList<A> {
     fn extend<T: Iterator<A>>(&mut self, mut iterator: T) {
         for elt in iterator { self.push_back(elt); }
     }

branches/try/src/libcollections/enum_set.rs

@@ -16,8 +16,8 @@
 use core::prelude::*;
 use core::fmt;
 
-// FIXME(conventions): implement BitXor
 // FIXME(contentions): implement union family of methods? (general design may be wrong here)
+// FIXME(conventions): implement len
 
 #[deriving(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 /// A specialized `Set` implementation to use enum types.
@@ -91,12 +91,6 @@ impl<E:CLike> EnumSet<E> {
         EnumSet {bits: 0}
     }
 
-    /// Returns the number of elements in the given `EnumSet`.
-    #[unstable = "matches collection reform specification, waiting for dust to settle"]
-    pub fn len(&self) -> uint {
-        self.bits.count_ones()
-    }
-
     /// Returns true if the `EnumSet` is empty.
     #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn is_empty(&self) -> bool {
@@ -201,6 +195,12 @@ impl<E:CLike> BitAnd<EnumSet<E>, EnumSet<E>> for EnumSet<E> {
     }
 }
 
+impl<E:CLike> BitXor<EnumSet<E>, EnumSet<E>> for EnumSet<E> {
+    fn bitxor(&self, e: &EnumSet<E>) -> EnumSet<E> {
+        EnumSet {bits: self.bits ^ e.bits}
+    }
+}
+
 /// An iterator over an EnumSet
 pub struct Items<E> {
     index: uint,
@@ -235,22 +235,6 @@ impl<E:CLike> Iterator<E> for Items<E> {
     }
 }
 
-impl<E:CLike> FromIterator<E> for EnumSet<E> {
-    fn from_iter<I:Iterator<E>>(iterator: I) -> EnumSet<E> {
-        let mut ret = EnumSet::new();
-        ret.extend(iterator);
-        ret
-    }
-}
-
-impl<E:CLike> Extend<E> for EnumSet<E> {
-    fn extend<I: Iterator<E>>(&mut self, mut iterator: I) {
-        for element in iterator {
-            self.insert(element);
-        }
-    }
-}
-
 #[cfg(test)]
 mod test {
     use std::prelude::*;
@@ -290,20 +274,6 @@ mod test {
         assert_eq!("{A, C}", e.to_string().as_slice());
     }
 
-    #[test]
-    fn test_len() {
-        let mut e = EnumSet::new();
-        assert_eq!(e.len(), 0);
-        e.insert(A);
-        e.insert(B);
-        e.insert(C);
-        assert_eq!(e.len(), 3);
-        e.remove(&A);
-        assert_eq!(e.len(), 2);
-        e.clear();
-        assert_eq!(e.len(), 0);
-    }
-
     ///////////////////////////////////////////////////////////////////////////
     // intersect
 

branches/try/src/libcollections/ring_buf.rs

@@ -735,7 +735,7 @@ impl<A> FromIterator<A> for RingBuf<A> {
     }
 }
 
-impl<A> Extend<A> for RingBuf<A> {
+impl<A> Extendable<A> for RingBuf<A> {
     fn extend<T: Iterator<A>>(&mut self, mut iterator: T) {
         for elt in iterator {
             self.push_back(elt);

branches/try/src/libcollections/string.rs

@@ -683,8 +683,8 @@ impl FromIterator<char> for String {
     }
 }
 
-#[experimental = "waiting on Extend stabilization"]
-impl Extend<char> for String {
+#[experimental = "waiting on Extendable stabilization"]
+impl Extendable<char> for String {
     fn extend<I:Iterator<char>>(&mut self, mut iterator: I) {
         for ch in iterator {
             self.push(ch)

branches/try/src/libcollections/tree/map.rs

@@ -1260,7 +1260,7 @@ impl<K: Ord, V> FromIterator<(K, V)> for TreeMap<K, V> {
     }
 }
 
-impl<K: Ord, V> Extend<(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 {

branches/try/src/libcollections/tree/set.rs

@@ -659,7 +659,7 @@ impl<T: Ord> FromIterator<T> for TreeSet<T> {
     }
 }
 
-impl<T: Ord> Extend<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 {

branches/try/src/libcollections/trie/map.rs

@@ -628,7 +628,7 @@ impl<T> FromIterator<(uint, T)> for TrieMap<T> {
     }
 }
 
-impl<T> Extend<(uint, T)> for TrieMap<T> {
+impl<T> Extendable<(uint, T)> for TrieMap<T> {
     fn extend<Iter: Iterator<(uint, T)>>(&mut self, mut iter: Iter) {
         for (k, v) in iter {
             self.insert(k, v);

branches/try/src/libcollections/trie/set.rs

@@ -355,7 +355,7 @@ impl FromIterator<uint> for TrieSet {
     }
 }
 
-impl Extend<uint> for TrieSet {
+impl Extendable<uint> for TrieSet {
     fn extend<Iter: Iterator<uint>>(&mut self, mut iter: Iter) {
         for elem in iter {
             self.insert(elem);

branches/try/src/libcollections/vec.rs

@@ -484,8 +484,8 @@ impl<T> FromIterator<T> for Vec<T> {
     }
 }
 
-#[experimental = "waiting on Extend stability"]
-impl<T> Extend<T> for Vec<T> {
+#[experimental = "waiting on Extendable stability"]
+impl<T> Extendable<T> for Vec<T> {
     #[inline]
     fn extend<I: Iterator<T>>(&mut self, mut iterator: I) {
         let (lower, _) = iterator.size_hint();
@@ -801,13 +801,14 @@ impl<T> Vec<T> {
     ///
     /// # Example
     /// ```
-    /// let mut v = vec!["foo", "bar", "baz", "qux"];
+    /// let mut v = vec!["foo".to_string(), "bar".to_string(),
+    ///                  "baz".to_string(), "qux".to_string()];
     ///
-    /// assert_eq!(v.swap_remove(1), Some("bar"));
-    /// assert_eq!(v, vec!["foo", "qux", "baz"]);
+    /// assert_eq!(v.swap_remove(1), Some("bar".to_string()));
+    /// assert_eq!(v, vec!["foo".to_string(), "qux".to_string(), "baz".to_string()]);
     ///
-    /// assert_eq!(v.swap_remove(0), Some("foo"));
-    /// assert_eq!(v, vec!["baz", "qux"]);
+    /// assert_eq!(v.swap_remove(0), Some("foo".to_string()));
+    /// assert_eq!(v, vec!["baz".to_string(), "qux".to_string()]);
     ///
     /// assert_eq!(v.swap_remove(2), None);
     /// ```

branches/try/src/libcollections/vec_map.rs

@@ -499,7 +499,7 @@ impl<V> FromIterator<(uint, V)> for VecMap<V> {
     }
 }
 
-impl<V> Extend<(uint, V)> for VecMap<V> {
+impl<V> Extendable<(uint, V)> for VecMap<V> {
     fn extend<Iter: Iterator<(uint, V)>>(&mut self, mut iter: Iter) {
         for (k, v) in iter {
             self.insert(k, v);

branches/try/src/libcore/atomic.rs

@@ -717,15 +717,15 @@ unsafe fn atomic_xor<T>(dst: *mut T, val: T, order: Ordering) -> T {
 /// A fence 'A' which has `Release` ordering semantics, synchronizes with a
 /// fence 'B' with (at least) `Acquire` semantics, if and only if there exists
 /// atomic operations X and Y, both operating on some atomic object 'M' such
-/// that A is sequenced before X, Y is synchronized before B and Y observes
+/// that A is sequenced before X, Y is synchronized before B and Y observers
 /// the change to M. This provides a happens-before dependence between A and B.
 ///
 /// Atomic operations with `Release` or `Acquire` semantics can also synchronize
 /// with a fence.
 ///
-/// A fence which has `SeqCst` ordering, in addition to having both `Acquire`
-/// and `Release` semantics, participates in the global program order of the
-/// other `SeqCst` operations and/or fences.
+/// A fence with has `SeqCst` ordering, in addition to having both `Acquire` and
+/// `Release` semantics, participates in the global program order of the other
+/// `SeqCst` operations and/or fences.
 ///
 /// Accepts `Acquire`, `Release`, `AcqRel` and `SeqCst` orderings.
 ///

branches/try/src/libcore/intrinsics.rs

@@ -536,7 +536,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(Clone, PartialEq, Eq, Show)]
+#[deriving(PartialEq, Eq, Show)]
 pub struct TypeId {
     t: u64,
 }

branches/try/src/libcore/iter.rs

@@ -66,7 +66,6 @@ use num::{Zero, One, CheckedAdd, CheckedSub, Saturating, ToPrimitive, Int};
 use ops::{Add, Mul, Sub};
 use option::{Option, Some, None};
 use uint;
-#[deprecated = "renamed to Extend"] pub use self::Extend as Extendable;
 
 /// Conversion from an `Iterator`
 pub trait FromIterator<A> {
@@ -75,8 +74,8 @@ pub trait FromIterator<A> {
 }
 
 /// A type growable from an `Iterator` implementation
-pub trait Extend<A> {
-    /// Extend a container with the elements yielded by an arbitrary iterator
+pub trait Extendable<A>: FromIterator<A> {
+    /// Extend a container with the elements yielded by an iterator
     fn extend<T: Iterator<A>>(&mut self, iterator: T);
 }
 

branches/try/src/libcore/prelude.rs

@@ -48,7 +48,7 @@ pub use char::Char;
 pub use clone::Clone;
 pub use cmp::{PartialEq, PartialOrd, Eq, Ord};
 pub use cmp::{Ordering, Less, Equal, Greater, Equiv};
-pub use iter::{FromIterator, Extend};
+pub use iter::{FromIterator, Extendable};
 pub use iter::{Iterator, DoubleEndedIterator, RandomAccessIterator, CloneableIterator};
 pub use iter::{OrdIterator, MutableDoubleEndedIterator, ExactSize};
 pub use num::{Num, NumCast, CheckedAdd, CheckedSub, CheckedMul};

branches/try/src/libgreen/basic.rs

@@ -18,7 +18,7 @@
 use alloc::arc::Arc;
 use std::sync::atomic;
 use std::mem;
-use std::rt::rtio::{EventLoop, RemoteCallback};
+use std::rt::rtio::{EventLoop, IoFactory, RemoteCallback};
 use std::rt::rtio::{PausableIdleCallback, Callback};
 use std::rt::exclusive::Exclusive;
 
@@ -150,6 +150,8 @@ impl EventLoop for BasicLoop {
             Box<RemoteCallback + Send>
     }
 
+    fn io<'a>(&'a mut self) -> Option<&'a mut IoFactory> { None }
+
     fn has_active_io(&self) -> bool { false }
 }
 

branches/try/src/libgreen/simple.rs

@@ -16,6 +16,7 @@ use std::mem;
 use std::rt::Runtime;
 use std::rt::local::Local;
 use std::rt::mutex::NativeMutex;
+use std::rt::rtio;
 use std::rt::task::{Task, BlockedTask, TaskOpts};
 
 struct SimpleTask {
@@ -78,10 +79,9 @@ impl Runtime for SimpleTask {
                      _f: proc():Send) {
         panic!()
     }
-
+    fn local_io<'a>(&'a mut self) -> Option<rtio::LocalIo<'a>> { None }
     fn stack_bounds(&self) -> (uint, uint) { panic!() }
     fn stack_guard(&self) -> Option<uint> { panic!() }
-
     fn can_block(&self) -> bool { true }
     fn wrap(self: Box<SimpleTask>) -> Box<Any+'static> { panic!() }
 }

branches/try/src/libgreen/task.rs

@@ -24,6 +24,7 @@ use std::raw;
 use std::rt::Runtime;
 use std::rt::local::Local;
 use std::rt::mutex::NativeMutex;
+use std::rt::rtio;
 use std::rt::stack;
 use std::rt::task::{Task, BlockedTask, TaskOpts};
 use std::rt;
@@ -467,6 +468,14 @@ impl Runtime for GreenTask {
         sched.run_task(me, sibling)
     }
 
+    // Local I/O is provided by the scheduler's event loop
+    fn local_io<'a>(&'a mut self) -> Option<rtio::LocalIo<'a>> {
+        match self.sched.as_mut().unwrap().event_loop.io() {
+            Some(io) => Some(rtio::LocalIo::new(io)),
+            None => None,
+        }
+    }
+
     fn stack_bounds(&self) -> (uint, uint) {
         let c = self.coroutine.as_ref()
             .expect("GreenTask.stack_bounds called without a coroutine");