---

yaml
---
r: 13306
b: refs/heads/master
c: 0d20717
h: refs/heads/master
v: v3

Author: nikomatsakis

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 45680c83ab81986bbedf93878e3d24f69be02981
+refs/heads/master: 0d20717fab410cf1f90938d90ad4153b77b6f8b3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf

trunk/src/libcore/dvec.rs

@@ -57,6 +57,11 @@ fn dvec<A>() -> dvec<A> {
     {mut data: [mut]}
 }
 
+#[doc = "Creates a new dvec with a single element"]
+fn from_elt<A>(+e: A) -> dvec<A> {
+    {mut data: [mut e]}
+}
+
 #[doc = "Creates a new dvec with the contents of a vector"]
 fn from_vec<A>(+v: [mut A]) -> dvec<A> {
     {mut data: v}
@@ -234,12 +239,19 @@ impl extensions<A:copy> for dvec<A> {
         self.data[idx] = a;
     }
 
-    #[doc = "Overwrites the contents of the element at `idx` with `a`"]
+    #[doc = "Overwrites the contents of the element at `idx` with `a`,
+    growing the vector if necessary.  New elements will be initialized
+    with `initval`"]
     fn grow_set_elt(idx: uint, initval: A, val: A) {
         self.swap { |v|
             let mut v <- v;
             vec::grow_set(v, idx, initval, val);
             v
         }
     }
+
+    #[doc = "Returns the last element, failing if the vector is empty"]
+    fn last() -> A {
+        self.get_elt(self.len() - 1u)
+    }
 }

trunk/src/libcore/vec.rs

@@ -211,18 +211,18 @@ fn from_mut<T>(+v: [mut T]) -> [T] unsafe {
 pure fn head<T: copy>(v: [const T]/&) -> T { v[0] }
 
 #[doc = "Returns a vector containing all but the first element of a slice"]
-fn tail<T: copy>(v: [const T]/&) -> [T] {
+pure fn tail<T: copy>(v: [const T]/&) -> [T] {
     ret slice(v, 1u, len(v));
 }
 
 #[doc = "Returns a vector containing all but the first `n` \
          elements of a slice"]
-fn tailn<T: copy>(v: [const T]/&, n: uint) -> [T] {
+pure fn tailn<T: copy>(v: [const T]/&, n: uint) -> [T] {
     slice(v, n, len(v))
 }
 
 #[doc = "Returns a vector containing all but the last element of a slice"]
-fn init<T: copy>(v: [const T]/&) -> [T] {
+pure fn init<T: copy>(v: [const T]/&) -> [T] {
     assert len(v) != 0u;
     slice(v, 0u, len(v) - 1u)
 }
@@ -1033,10 +1033,10 @@ pure fn unpack_mut_slice<T,U>(s: [mut T]/&,
 impl extensions/&<T> for [const T]/& {
     #[doc = "Returns true if a vector contains no elements"]
     #[inline]
-    fn is_empty() -> bool { is_empty(self) }
+    pure fn is_empty() -> bool { is_empty(self) }
     #[doc = "Returns true if a vector contains some elements"]
     #[inline]
-    fn is_not_empty() -> bool { is_not_empty(self) }
+    pure fn is_not_empty() -> bool { is_not_empty(self) }
     #[doc = "Returns the length of a vector"]
     #[inline]
     pure fn len() -> uint { len(self) }
@@ -1046,44 +1046,44 @@ impl extensions/&<T> for [const T]/& {
 impl extensions/&<T: copy> for [const T]/& {
     #[doc = "Returns the first element of a vector"]
     #[inline]
-    fn head() -> T { head(self) }
+    pure fn head() -> T { head(self) }
     #[doc = "Returns all but the last elemnt of a vector"]
     #[inline]
-    fn init() -> [T] { init(self) }
+    pure fn init() -> [T] { init(self) }
     #[doc = "
     Returns the last element of a `v`, failing if the vector is empty.
     "]
     #[inline]
-    fn last() -> T { last(self) }
+    pure fn last() -> T { last(self) }
     #[doc = "Returns a copy of the elements from [`start`..`end`) from `v`."]
     #[inline]
-    fn slice(start: uint, end: uint) -> [T] { slice(self, start, end) }
+    pure fn slice(start: uint, end: uint) -> [T] { slice(self, start, end) }
     #[doc = "Returns all but the first element of a vector"]
     #[inline]
-    fn tail() -> [T] { tail(self) }
+    pure fn tail() -> [T] { tail(self) }
 }
 
 #[doc = "Extension methods for vectors"]
 impl extensions/&<T> for [T]/& {
     #[doc = "Reduce a vector from right to left"]
     #[inline]
-    fn foldr<U: copy>(z: U, p: fn(T, U) -> U) -> U { foldr(self, z, p) }
+    pure fn foldr<U: copy>(z: U, p: fn(T, U) -> U) -> U { foldr(self, z, p) }
     #[doc = "
     Iterates over a vector
 
     Iterates over vector `v` and, for each element, calls function `f` with
     the element's value.
     "]
     #[inline]
-    fn iter(f: fn(T)) { iter(self, f) }
+    pure fn iter(f: fn(T)) { iter(self, f) }
     #[doc = "
     Iterates over a vector's elements and indexes
 
     Iterates over vector `v` and, for each element, calls function `f` with
     the element's value and index.
     "]
     #[inline]
-    fn iteri(f: fn(uint, T)) { iteri(self, f) }
+    pure fn iteri(f: fn(uint, T)) { iteri(self, f) }
     #[doc = "
     Find the first index matching some predicate
 
@@ -1092,26 +1092,26 @@ impl extensions/&<T> for [T]/& {
     elements then none is returned.
     "]
     #[inline]
-    fn position(f: fn(T) -> bool) -> option<uint> { position(self, f) }
+    pure fn position(f: fn(T) -> bool) -> option<uint> { position(self, f) }
     #[doc = "Find the first index containing a matching value"]
     #[inline]
-    fn position_elem(x: T) -> option<uint> { position_elem(self, x) }
+    pure fn position_elem(x: T) -> option<uint> { position_elem(self, x) }
     #[doc = "
     Iterates over a vector in reverse
 
     Iterates over vector `v` and, for each element, calls function `f` with
     the element's value.
     "]
     #[inline]
-    fn riter(f: fn(T)) { riter(self, f) }
+    pure fn riter(f: fn(T)) { riter(self, f) }
     #[doc ="
     Iterates over a vector's elements and indexes in reverse
 
     Iterates over vector `v` and, for each element, calls function `f` with
     the element's value and index.
     "]
     #[inline]
-    fn riteri(f: fn(uint, T)) { riteri(self, f) }
+    pure fn riteri(f: fn(uint, T)) { riteri(self, f) }
     #[doc = "
     Find the last index matching some predicate
 
@@ -1120,20 +1120,20 @@ impl extensions/&<T> for [T]/& {
     matches no elements then none is returned.
     "]
     #[inline]
-    fn rposition(f: fn(T) -> bool) -> option<uint> { rposition(self, f) }
+    pure fn rposition(f: fn(T) -> bool) -> option<uint> { rposition(self, f) }
     #[doc = "Find the last index containing a matching value"]
     #[inline]
-    fn rposition_elem(x: T) -> option<uint> { rposition_elem(self, x) }
+    pure fn rposition_elem(x: T) -> option<uint> { rposition_elem(self, x) }
     #[doc = "
     Apply a function to each element of a vector and return the results
     "]
     #[inline]
-    fn map<U>(f: fn(T) -> U) -> [U] { map(self, f) }
+    pure fn map<U>(f: fn(T) -> U) -> [U] { map(self, f) }
     #[doc = "
     Apply a function to the index and value of each element in the vector
     and return the results
     "]
-    fn mapi<U>(f: fn(uint, T) -> U) -> [U] {
+    pure fn mapi<U>(f: fn(uint, T) -> U) -> [U] {
         mapi(self, f)
     }
     #[doc = "Returns true if the function returns true for all elements.
@@ -1147,15 +1147,15 @@ impl extensions/&<T> for [T]/& {
     of each result vector
     "]
     #[inline]
-    fn flat_map<U>(f: fn(T) -> [U]) -> [U] { flat_map(self, f) }
+    pure fn flat_map<U>(f: fn(T) -> [U]) -> [U] { flat_map(self, f) }
     #[doc = "
     Apply a function to each element of a vector and return the results
 
     If function `f` returns `none` then that element is excluded from
     the resulting vector.
     "]
     #[inline]
-    fn filter_map<U: copy>(f: fn(T) -> option<U>) -> [U] {
+    pure fn filter_map<U: copy>(f: fn(T) -> option<U>) -> [U] {
         filter_map(self, f)
     }
 }
@@ -1170,7 +1170,7 @@ impl extensions/&<T: copy> for [T]/& {
     only those elements for which `f` returned true.
     "]
     #[inline]
-    fn filter(f: fn(T) -> bool) -> [T] { filter(self, f) }
+    pure fn filter(f: fn(T) -> bool) -> [T] { filter(self, f) }
     #[doc = "
     Search for the first element that matches a given predicate
 
@@ -1179,7 +1179,7 @@ impl extensions/&<T: copy> for [T]/& {
     is returned. If `f` matches no elements then none is returned.
     "]
     #[inline]
-    fn find(f: fn(T) -> bool) -> option<T> { find(self, f) }
+    pure fn find(f: fn(T) -> bool) -> option<T> { find(self, f) }
     #[doc = "
     Search for the last element that matches a given predicate
 
@@ -1188,7 +1188,7 @@ impl extensions/&<T: copy> for [T]/& {
     matches no elements then none is returned.
     "]
     #[inline]
-    fn rfind(f: fn(T) -> bool) -> option<T> { rfind(self, f) }
+    pure fn rfind(f: fn(T) -> bool) -> option<T> { rfind(self, f) }
 }
 
 #[doc = "Unsafe operations"]