---

yaml
---
r: 85329
b: refs/heads/dist-snap
c: 11b3d76
h: refs/heads/master
i:
  85327: 29450e3
v: v3

Author: robertknight

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 0983ebe5310d4eb6d289f636f7ed0536c08bbc0e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: f02cc6bf0a276115a31354b1c1530e6fe9eb4d58
+refs/heads/dist-snap: 11b3d76fb6ae627aea1b2a3a3de2807c21f9e720
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libstd/cell.rs

@@ -13,7 +13,6 @@
 #[missing_doc];
 
 use cast::transmute_mut;
-use unstable::finally::Finally;
 use prelude::*;
 
 /*
@@ -66,17 +65,18 @@ impl<T> Cell<T> {
 
     /// Calls a closure with a reference to the value.
     pub fn with_ref<R>(&self, op: &fn(v: &T) -> R) -> R {
-        do self.with_mut_ref |ptr| { op(ptr) }
+        let v = self.take();
+        let r = op(&v);
+        self.put_back(v);
+        r
     }
 
     /// Calls a closure with a mutable reference to the value.
     pub fn with_mut_ref<R>(&self, op: &fn(v: &mut T) -> R) -> R {
-        let mut v = Some(self.take());
-        do (|| {
-            op(v.get_mut_ref())
-        }).finally {
-            self.put_back(v.take_unwrap());
-        }
+        let mut v = self.take();
+        let r = op(&mut v);
+        self.put_back(v);
+        r
     }
 }
 

branches/dist-snap/src/libstd/rand.rs

@@ -461,6 +461,26 @@ pub trait RngUtil {
      * ~~~
      */
     fn shuffle_mut<T>(&mut self, values: &mut [T]);
+
+    /**
+     * Sample up to `n` values from an iterator.
+     *
+     * # Example
+     *
+     * ~~~ {.rust}
+     *
+     * use std::rand;
+     * use std::rand::RngUtil;
+     *
+     * fn main() {
+     *     let mut rng = rand::rng();
+     *     let vals = range(1, 100).to_owned_vec();
+     *     let sample = rng.sample(vals.iter(), 5);
+     *     printfln!(sample);
+     * }
+     * ~~~
+     */
+    fn sample<A, T: Iterator<A>>(&mut self, iter: T, n: uint) -> ~[A];
 }
 
 /// Extension methods for random number generators
@@ -607,6 +627,23 @@ impl<R: Rng> RngUtil for R {
             values.swap(i, self.gen_uint_range(0u, i + 1u));
         }
     }
+
+    /// Randomly sample up to `n` elements from an iterator
+    fn sample<A, T: Iterator<A>>(&mut self, iter: T, n: uint) -> ~[A] {
+        let mut reservoir : ~[A] = vec::with_capacity(n);
+        for (i, elem) in iter.enumerate() {
+            if i < n {
+                reservoir.push(elem);
+                loop
+            }
+
+            let k = self.gen_uint_range(0, i + 1);
+            if k < reservoir.len() {
+                reservoir[k] = elem
+            }
+        }
+        reservoir
+    }
 }
 
 /// Create a random number generator with a default algorithm and seed.
@@ -914,6 +951,7 @@ pub fn random<T: Rand>() -> T {
 
 #[cfg(test)]
 mod test {
+    use iterator::{Iterator, range};
     use option::{Option, Some};
     use super::*;
 
@@ -1130,6 +1168,24 @@ mod test {
             }
         }
     }
+
+    #[test]
+    fn test_sample() {
+        let MIN_VAL = 1;
+        let MAX_VAL = 100;
+
+        let mut r = rng();
+        let vals = range(MIN_VAL, MAX_VAL).to_owned_vec();
+        let small_sample = r.sample(vals.iter(), 5);
+        let large_sample = r.sample(vals.iter(), vals.len() + 5);
+
+        assert_eq!(small_sample.len(), 5);
+        assert_eq!(large_sample.len(), vals.len());
+
+        assert!(small_sample.iter().all(|e| {
+            **e >= MIN_VAL && **e <= MAX_VAL
+        }));
+    }
 }
 
 #[cfg(test)]

branches/dist-snap/src/libstd/rt/comm.rs

@@ -18,8 +18,7 @@ use kinds::Send;
 use rt;
 use rt::sched::Scheduler;
 use rt::local::Local;
-use rt::select::{SelectInner, SelectPortInner};
-use select::{Select, SelectPort};
+use rt::select::{Select, SelectPort};
 use unstable::atomics::{AtomicUint, AtomicOption, Acquire, Relaxed, SeqCst};
 use unstable::sync::UnsafeAtomicRcBox;
 use util::Void;
@@ -114,9 +113,7 @@ impl<T> ChanOne<T> {
     // 'do_resched' configures whether the scheduler immediately switches to
     // the receiving task, or leaves the sending task still running.
     fn try_send_inner(self, val: T, do_resched: bool) -> bool {
-        if do_resched {
-            rtassert!(!rt::in_sched_context());
-        }
+        rtassert!(!rt::in_sched_context());
 
         let mut this = self;
         let mut recvr_active = true;
@@ -218,7 +215,7 @@ impl<T> PortOne<T> {
     }
 }
 
-impl<T> SelectInner for PortOne<T> {
+impl<T> Select for PortOne<T> {
     #[inline] #[cfg(not(test))]
     fn optimistic_check(&mut self) -> bool {
         unsafe { (*self.packet()).state.load(Acquire) == STATE_ONE }
@@ -321,9 +318,7 @@ impl<T> SelectInner for PortOne<T> {
     }
 }
 
-impl<T> Select for PortOne<T> { }
-
-impl<T> SelectPortInner<T> for PortOne<T> {
+impl<T> SelectPort<T> for PortOne<T> {
     fn recv_ready(self) -> Option<T> {
         let mut this = self;
         let packet = this.packet();
@@ -354,8 +349,6 @@ impl<T> SelectPortInner<T> for PortOne<T> {
     }
 }
 
-impl<T> SelectPort<T> for PortOne<T> { }
-
 impl<T> Peekable<T> for PortOne<T> {
     fn peek(&self) -> bool {
         unsafe {
@@ -520,7 +513,7 @@ impl<T> Peekable<T> for Port<T> {
 // of them, but a &Port<T> should also be selectable so you can select2 on it
 // alongside a PortOne<U> without passing the port by value in recv_ready.
 
-impl<'self, T> SelectInner for &'self Port<T> {
+impl<'self, T> Select for &'self Port<T> {
     #[inline]
     fn optimistic_check(&mut self) -> bool {
         do self.next.with_mut_ref |pone| { pone.optimistic_check() }
@@ -538,9 +531,7 @@ impl<'self, T> SelectInner for &'self Port<T> {
     }
 }
 
-impl<'self, T> Select for &'self Port<T> { }
-
-impl<T> SelectInner for Port<T> {
+impl<T> Select for Port<T> {
     #[inline]
     fn optimistic_check(&mut self) -> bool {
         (&*self).optimistic_check()
@@ -557,9 +548,7 @@ impl<T> SelectInner for Port<T> {
     }
 }
 
-impl<T> Select for Port<T> { }
-
-impl<'self, T> SelectPortInner<T> for &'self Port<T> {
+impl<'self, T> SelectPort<T> for &'self Port<T> {
     fn recv_ready(self) -> Option<T> {
         match self.next.take().recv_ready() {
             Some(StreamPayload { val, next }) => {
@@ -571,8 +560,6 @@ impl<'self, T> SelectPortInner<T> for &'self Port<T> {
     }
 }
 
-impl<'self, T> SelectPort<T> for &'self Port<T> { }
-
 pub struct SharedChan<T> {
     // Just like Chan, but a shared AtomicOption instead of Cell
     priv next: UnsafeAtomicRcBox<AtomicOption<StreamChanOne<T>>>

branches/dist-snap/src/libstd/rt/kill.rs

@@ -488,8 +488,8 @@ impl Death {
         rtassert!(self.unkillable == 0);
         self.unkillable = 1;
 
-        // NB. See corresponding comment at the callsite in task.rs.
-        // FIXME(#8192): Doesn't work with "let _ = ..."
+        // FIXME(#7544): See corresponding fixme at the callsite in task.rs.
+        // NB(#8192): Doesn't work with "let _ = ..."
         { use util; util::ignore(group); }
 
         // Step 1. Decide if we need to collect child failures synchronously.

branches/dist-snap/src/libstd/rt/mod.rs

@@ -142,7 +142,8 @@ pub mod tube;
 /// Simple reimplementation of core::comm
 pub mod comm;
 
-mod select;
+/// Routines for select()ing on pipes.
+pub mod select;
 
 // FIXME #5248 shouldn't be pub
 /// The runtime needs to be able to put a pointer into thread-local storage.