---

yaml
---
r: 50560
b: refs/heads/try
c: 80c71c8
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 5f13e9ccc2e3328d4cd8ca49f84e6840dd998346
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: f7a2371c176663d59062ec5158f39faecba45768
-refs/heads/try: 267f6c212f471c100060edaaf85a26e9a7ba820f
+refs/heads/try: 80c71c839acde882e53ee9505a05b81e4af33ab7
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/etc/emacs/rust-mode.el

@@ -7,7 +7,6 @@
 
 (require 'cm-mode)
 (require 'cc-mode)
-(eval-when-compile (require 'cl))
 
 (defun rust-electric-brace (arg)
   (interactive "*P")

branches/try/src/etc/kate/rust.xml

@@ -17,6 +17,7 @@
 	</list>
 	<list name="keywords">
 		<item> as </item>
+		<item> assert </item>
 		<item> break </item>
 		<item> const </item>
 		<item> copy </item>
@@ -68,7 +69,6 @@
 		<item> Shl </item>
 		<item> Shr </item>
 		<item> Index </item>
-		<item> Not </item>
 	</list>
 	<list name="types">
 		<item> bool </item>

branches/try/src/libcore/clone.rs

@@ -19,31 +19,3 @@ impl Clone for () {
     #[inline(always)]
     fn clone(&self) -> () { () }
 }
-
-macro_rules! clone_impl(
-    ($t:ty) => {
-        impl Clone for $t {
-            #[inline(always)]
-            fn clone(&self) -> $t { *self }
-        }
-    }
-)
-
-clone_impl!(int)
-clone_impl!(i8)
-clone_impl!(i16)
-clone_impl!(i32)
-clone_impl!(i64)
-
-clone_impl!(uint)
-clone_impl!(u8)
-clone_impl!(u16)
-clone_impl!(u32)
-clone_impl!(u64)
-
-clone_impl!(float)
-clone_impl!(f32)
-clone_impl!(f64)
-
-clone_impl!(bool)
-clone_impl!(char)

branches/try/src/libcore/core.rc

@@ -51,7 +51,6 @@ Implicitly, all crates behave as if they included the following prologue:
 #[warn(vecs_implicitly_copyable)];
 #[deny(non_camel_case_types)];
 #[allow(deprecated_mutable_fields)];
-#[deny(deprecated_self)];
 
 // On Linux, link to the runtime with -lrt.
 #[cfg(target_os = "linux")]
@@ -143,6 +142,8 @@ pub mod option;
 pub mod result;
 pub mod either;
 pub mod dlist;
+#[path="iter-trait.rs"] #[merge = "iter-trait/dlist.rs"]
+pub mod dlist_iter;
 pub mod hashmap;
 pub mod cell;
 pub mod trie;

branches/try/src/libcore/dlist.rs

@@ -18,8 +18,6 @@ Do not use ==, !=, <, etc on doubly-linked lists -- it may not terminate.
 
 */
 
-use iter;
-use iter::BaseIter;
 use kinds::Copy;
 use managed;
 use option::{None, Option, Some};
@@ -491,54 +489,14 @@ pub impl<T:Copy> DList<T> {
         let mut v = vec::with_capacity(self.size);
         unsafe {
             // Take this out of the unchecked when iter's functions are pure
-            for iter::eachi(&self) |index,data| {
+            for self.eachi |index,data| {
                 v[index] = *data;
             }
         }
         v
     }
 }
 
-impl<T> BaseIter<T> for @mut DList<T> {
-    /**
-    * Iterates through the current contents.
-    *
-    * Attempts to access this dlist during iteration are allowed (to
-    * allow for e.g. breadth-first search with in-place enqueues), but
-    * removing the current node is forbidden.
-    */
-    pure fn each(&self, f: fn(v: &T) -> bool) {
-        let mut link = self.peek_n();
-        while option::is_some(&link) {
-            let nobe = option::get(link);
-            fail_unless!(nobe.linked);
-
-            {
-                let frozen_nobe = &*nobe;
-                if !f(&frozen_nobe.data) { break; }
-            }
-
-            // Check (weakly) that the user didn't do a remove.
-            if self.size == 0 {
-                fail!(~"The dlist became empty during iteration??")
-            }
-            if !nobe.linked ||
-                (!((nobe.prev.is_some()
-                    || managed::mut_ptr_eq(self.hd.expect(~"headless dlist?"),
-                                           nobe))
-                   && (nobe.next.is_some()
-                    || managed::mut_ptr_eq(self.tl.expect(~"tailless dlist?"),
-                                           nobe)))) {
-                fail!(~"Removing a dlist node during iteration is forbidden!")
-            }
-            link = nobe.next_link();
-        }
-    }
-
-    #[inline(always)]
-    pure fn size_hint(&self) -> Option<uint> { Some(self.len()) }
-}
-
 #[cfg(test)]
 mod tests {
     use dlist::{DList, concat, from_vec, new_dlist_node};

branches/try/src/libcore/iter-trait.rs

@@ -0,0 +1,89 @@
+// 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.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// This makes use of a clever hack that brson came up with to
+// workaround our lack of traits and lack of macros.  See core.{rc,rs} for
+// how this file is used.
+
+use cmp::{Eq, Ord};
+use iter::BaseIter;
+use iter;
+use kinds::Copy;
+use option::Option;
+
+use self::inst::{IMPL_T, EACH, SIZE_HINT};
+
+impl<A> iter::BaseIter<A> for IMPL_T<A> {
+    #[inline(always)]
+    pure fn each(&self, blk: fn(v: &A) -> bool) { EACH(self, blk) }
+    #[inline(always)]
+    pure fn size_hint(&self) -> Option<uint> { SIZE_HINT(self) }
+}
+
+impl<A> iter::ExtendedIter<A> for IMPL_T<A> {
+    #[inline(always)]
+    pure fn eachi(&self, blk: fn(uint, v: &A) -> bool) {
+        iter::eachi(self, blk)
+    }
+    #[inline(always)]
+    pure fn all(&self, blk: fn(&A) -> bool) -> bool {
+        iter::all(self, blk)
+    }
+    #[inline(always)]
+    pure fn any(&self, blk: fn(&A) -> bool) -> bool {
+        iter::any(self, blk)
+    }
+    #[inline(always)]
+    pure fn foldl<B>(&self, b0: B, blk: fn(&B, &A) -> B) -> B {
+        iter::foldl(self, b0, blk)
+    }
+    #[inline(always)]
+    pure fn position(&self, f: fn(&A) -> bool) -> Option<uint> {
+        iter::position(self, f)
+    }
+    #[inline(always)]
+    pure fn map_to_vec<B>(&self, op: fn(&A) -> B) -> ~[B] {
+        iter::map_to_vec(self, op)
+    }
+    #[inline(always)]
+    pure fn flat_map_to_vec<B,IB:BaseIter<B>>(&self, op: fn(&A) -> IB)
+        -> ~[B] {
+        iter::flat_map_to_vec(self, op)
+    }
+
+}
+
+impl<A:Eq> iter::EqIter<A> for IMPL_T<A> {
+    #[inline(always)]
+    pure fn contains(&self, x: &A) -> bool { iter::contains(self, x) }
+    #[inline(always)]
+    pure fn count(&self, x: &A) -> uint { iter::count(self, x) }
+}
+
+impl<A:Copy> iter::CopyableIter<A> for IMPL_T<A> {
+    #[inline(always)]
+    pure fn filter_to_vec(&self, pred: fn(&A) -> bool) -> ~[A] {
+        iter::filter_to_vec(self, pred)
+    }
+    #[inline(always)]
+    pure fn to_vec(&self) -> ~[A] { iter::to_vec(self) }
+    #[inline(always)]
+    pure fn find(&self, f: fn(&A) -> bool) -> Option<A> {
+        iter::find(self, f)
+    }
+}
+
+impl<A:Copy + Ord> iter::CopyableOrderedIter<A> for IMPL_T<A> {
+    #[inline(always)]
+    pure fn min(&self) -> A { iter::min(self) }
+    #[inline(always)]
+    pure fn max(&self) -> A { iter::max(self) }
+}
+

branches/try/src/libcore/iter-trait/dlist.rs

@@ -0,0 +1,59 @@
+// 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.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+mod inst {
+    use dlist::DList;
+    use managed;
+    use option::{Option, Some};
+    use option;
+
+    #[allow(non_camel_case_types)]
+    pub type IMPL_T<A> = @mut DList<A>;
+
+    /**
+    * Iterates through the current contents.
+    *
+    * Attempts to access this dlist during iteration are allowed (to
+    * allow for e.g. breadth-first search with in-place enqueues), but
+    * removing the current node is forbidden.
+    */
+    pub pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
+        let mut link = self.peek_n();
+        while option::is_some(&link) {
+            let nobe = option::get(link);
+            fail_unless!(nobe.linked);
+
+            {
+                let frozen_nobe = &*nobe;
+                if !f(&frozen_nobe.data) { break; }
+            }
+
+            // Check (weakly) that the user didn't do a remove.
+            if self.size == 0 {
+                fail!(~"The dlist became empty during iteration??")
+            }
+            if !nobe.linked ||
+                (!((nobe.prev.is_some()
+                    || managed::mut_ptr_eq(self.hd.expect(~"headless dlist?"),
+                                           nobe))
+                   && (nobe.next.is_some()
+                    || managed::mut_ptr_eq(self.tl.expect(~"tailless dlist?"),
+                                           nobe)))) {
+                fail!(~"Removing a dlist node during iteration is forbidden!")
+            }
+            link = nobe.next_link();
+        }
+    }
+
+    #[inline(always)]
+    pub pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
+        Some(self.len())
+    }
+}

branches/try/src/libcore/nil.rs

@@ -15,7 +15,7 @@ Functions for the unit type.
 */
 
 #[cfg(notest)]
-use cmp::{Eq, Ord};
+use cmp::{Eq, Ord, TotalOrd, Ordering, Equal};
 
 #[cfg(notest)]
 impl Eq for () {
@@ -37,3 +37,8 @@ impl Ord for () {
     pure fn gt(&self, _other: &()) -> bool { false }
 }
 
+#[cfg(notest)]
+impl TotalOrd for () {
+    #[inline(always)]
+    pure fn cmp(&self, _other: &()) -> Ordering { Equal }
+}