---

yaml
---
r: 93765
b: refs/heads/try
c: 68d5510
h: refs/heads/master
i:
  93763: 4e6304a
v: v3

Author: alexcrichton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0da105a8b7b6b1e0568e8ff20f6ff4b13cc7ecc2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
-refs/heads/try: d57765d8a9d5c1136b914d0d3a073d44882f4ba9
+refs/heads/try: 68d5510292ed2f9714568285759ca9ef54d9b48c
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/doc/po/ja/tutorial-tasks.md.po

@@ -213,7 +213,7 @@ msgstr ""
 #. type: Plain text
 #: doc/tutorial-tasks.md:102
 msgid ""
-"The `spawn` function has a very simple type signature: `fn spawn(f: proc())`. "
+"The `spawn` function has a very simple type signature: `fn spawn(f: ~fn())`. "
 "Because it accepts only owned closures, and owned closures contain only "
 "owned data, `spawn` can safely move the entire closure and all its "
 "associated state into an entirely different task for execution. Like any "

branches/try/doc/po/ja/tutorial.md.po

@@ -3509,13 +3509,13 @@ msgstr "## 所有クロージャ"
 #. type: Plain text
 #: doc/tutorial.md:1510
 msgid ""
-"Owned closures, written `proc`, hold on to "
+"Owned closures, written `~fn` in analogy to the `~` pointer type, hold on to "
 "things that can safely be sent between processes. They copy the values they "
 "close over, much like managed closures, but they also own them: that is, no "
 "other code can access them. Owned closures are used in concurrent code, "
 "particularly for spawning [tasks][tasks]."
 msgstr ""
-"`~` `proc` で書き表される所有クロージャは安全にプロセス"
+"`~` ポインタ型と同様に `~fn` 型  で書き表される所有クロージャは安全にプロセス"
 "間で送信することができます。所有クローじゃはマネージドクロージャと全く同じよ"
 "うに閉じ込める値をコピーしますが、値を所有します。つまり、他のコードは閉じ込"
 "められた値にアクセスできなくなります。所有クロージャは並列プログラム、特に "
@@ -3666,11 +3666,11 @@ msgstr ""
 #: doc/tutorial.md:1582
 msgid ""
 "`do` is a convenient way to create tasks with the `task::spawn` function.  "
-"`spawn` has the signature `spawn(fn: proc())`. In other words, it is a "
+"`spawn` has the signature `spawn(fn: ~fn())`. In other words, it is a "
 "function that takes an owned closure that takes no arguments."
 msgstr ""
 "`task::spawn` 関数を用いてタスクを生成する場合、 `do` を用いると便利です。"
-"`spawn` は、 `spawn(fn: proc())` という方を持っています。言い換えると、"
+"`spawn` は、 `spawn(fn: ~fn())` という方を持っています。言い換えると、"
 "`spawn` は「引数をとらない所有クロージャ」を引数としてとる関数ということで"
 "す。"
 

branches/try/doc/po/tutorial-tasks.md.pot

@@ -213,7 +213,7 @@ msgstr ""
 #. type: Plain text
 #: doc/tutorial-tasks.md:102
 msgid ""
-"The `spawn` function has a very simple type signature: `fn spawn(f: proc())`. "
+"The `spawn` function has a very simple type signature: `fn spawn(f: ~fn())`. "
 "Because it accepts only owned closures, and owned closures contain only "
 "owned data, `spawn` can safely move the entire closure and all its "
 "associated state into an entirely different task for execution. Like any "

branches/try/doc/po/tutorial.md.pot

@@ -2683,7 +2683,7 @@ msgstr ""
 #. type: Plain text
 #: doc/tutorial.md:1510
 msgid ""
-"Owned closures, written `proc`, hold on to "
+"Owned closures, written `~fn` in analogy to the `~` pointer type, hold on to "
 "things that can safely be sent between processes. They copy the values they "
 "close over, much like managed closures, but they also own them: that is, no "
 "other code can access them. Owned closures are used in concurrent code, "
@@ -2808,7 +2808,7 @@ msgstr ""
 #: doc/tutorial.md:1582
 msgid ""
 "`do` is a convenient way to create tasks with the `task::spawn` function.  "
-"`spawn` has the signature `spawn(fn: proc())`. In other words, it is a "
+"`spawn` has the signature `spawn(fn: ~fn())`. In other words, it is a "
 "function that takes an owned closure that takes no arguments."
 msgstr ""
 

branches/try/doc/tutorial-tasks.md

@@ -91,7 +91,7 @@ _owned types_. The language leaves the implementation details to the standard
 library.
 
 The `spawn` function has a very simple type signature: `fn spawn(f:
-proc())`. Because it accepts only owned closures, and owned closures
+~fn())`. Because it accepts only owned closures, and owned closures
 contain only owned data, `spawn` can safely move the entire closure
 and all its associated state into an entirely different task for
 execution. Like any closure, the function passed to `spawn` may capture

branches/try/doc/tutorial.md

@@ -1409,7 +1409,7 @@ pervasively in Rust code.
 
 ## Owned closures
 
-Owned closures, written `proc`,
+Owned closures, written `~fn` in analogy to the `~` pointer type,
 hold on to things that can safely be sent between
 processes. They copy the values they close over, much like managed
 closures, but they also own them: that is, no other code can access
@@ -1484,7 +1484,7 @@ parentheses, where it looks more like a typical block of
 code.
 
 `do` is a convenient way to create tasks with the `task::spawn`
-function.  `spawn` has the signature `spawn(fn: proc())`. In other
+function.  `spawn` has the signature `spawn(fn: ~fn())`. In other
 words, it is a function that takes an owned closure that takes no
 arguments.
 

branches/try/src/libextra/future.rs

@@ -36,7 +36,7 @@ pub struct Future<A> {
 }
 
 enum FutureState<A> {
-    Pending(proc() -> A),
+    Pending(~fn() -> A),
     Evaluating,
     Forced(A)
 }
@@ -92,7 +92,7 @@ impl<A> Future<A> {
         Future {state: Forced(val)}
     }
 
-    pub fn from_fn(f: proc() -> A) -> Future<A> {
+    pub fn from_fn(f: ~fn() -> A) -> Future<A> {
         /*!
          * Create a future from a function.
          *
@@ -120,7 +120,7 @@ impl<A:Send> Future<A> {
         }
     }
 
-    pub fn spawn(blk: proc() -> A) -> Future<A> {
+    pub fn spawn(blk: ~fn() -> A) -> Future<A> {
         /*!
          * Create a future from a unique closure.
          *
@@ -137,7 +137,7 @@ impl<A:Send> Future<A> {
         Future::from_port(port)
     }
 
-    pub fn spawn_with<B: Send>(v: B, blk: proc(B) -> A) -> Future<A> {
+    pub fn spawn_with<B: Send>(v: B, blk: ~fn(B) -> A) -> Future<A> {
         /*!
          * Create a future from a unique closure taking one argument.
          *

branches/try/src/libextra/task_pool.rs

@@ -23,7 +23,7 @@ use std::vec;
 #[cfg(test)] use std::task::SingleThreaded;
 
 enum Msg<T> {
-    Execute(proc(&T)),
+    Execute(~fn(&T)),
     Quit
 }
 
@@ -49,15 +49,15 @@ impl<T> TaskPool<T> {
     /// local data to be kept around in that task.
     pub fn new(n_tasks: uint,
                opt_sched_mode: Option<SchedMode>,
-               init_fn_factory: &fn() -> proc(uint) -> T)
+               init_fn_factory: ~fn() -> ~fn(uint) -> T)
                -> TaskPool<T> {
         assert!(n_tasks >= 1);
 
         let channels = do vec::from_fn(n_tasks) |i| {
             let (port, chan) = comm::stream::<Msg<T>>();
             let init_fn = init_fn_factory();
 
-            let task_body: proc() = || {
+            let task_body: ~fn() = || {
                 let local_data = init_fn(i);
                 loop {
                     match port.recv() {
@@ -88,7 +88,7 @@ impl<T> TaskPool<T> {
 
     /// Executes the function `f` on a task in the pool. The function
     /// receives a reference to the local data returned by the `init_fn`.
-    pub fn execute(&mut self, f: proc(&T)) {
+    pub fn execute(&mut self, f: ~fn(&T)) {
         self.channels[self.next_index].send(Execute(f));
         self.next_index += 1;
         if self.next_index == self.channels.len() { self.next_index = 0; }
@@ -97,8 +97,8 @@ impl<T> TaskPool<T> {
 
 #[test]
 fn test_task_pool() {
-    let f: &fn() -> proc(uint) -> uint = || {
-        let g: proc(uint) -> uint = |i| i;
+    let f: ~fn() -> ~fn(uint) -> uint = || {
+        let g: ~fn(uint) -> uint = |i| i;
         g
     };
     let mut pool = TaskPool::new(4, Some(SingleThreaded), f);

branches/try/src/libextra/test.rs

@@ -74,22 +74,17 @@ impl TestDesc {
     }
 }
 
-/// Represents a benchmark function.
-pub trait TDynBenchFn {
-    fn run(&self, harness: &mut BenchHarness);
-}
-
 // A function that runs a test. If the function returns successfully,
 // the test succeeds; if the function fails then the test fails. We
 // may need to come up with a more clever definition of test in order
 // to support isolation of tests into tasks.
 pub enum TestFn {
     StaticTestFn(extern fn()),
     StaticBenchFn(extern fn(&mut BenchHarness)),
-    StaticMetricFn(proc(&mut MetricMap)),
-    DynTestFn(proc()),
-    DynMetricFn(proc(&mut MetricMap)),
-    DynBenchFn(~TDynBenchFn)
+    StaticMetricFn(~fn(&mut MetricMap)),
+    DynTestFn(~fn()),
+    DynMetricFn(~fn(&mut MetricMap)),
+    DynBenchFn(~fn(&mut BenchHarness))
 }
 
 impl TestFn {
@@ -864,7 +859,7 @@ pub fn run_test(force_ignore: bool,
 
     fn run_test_inner(desc: TestDesc,
                       monitor_ch: SharedChan<MonitorMsg>,
-                      testfn: proc()) {
+                      testfn: ~fn()) {
         let testfn_cell = ::std::cell::Cell::new(testfn);
         do task::spawn {
             let mut task = task::task();
@@ -883,8 +878,8 @@ pub fn run_test(force_ignore: bool,
     }
 
     match testfn {
-        DynBenchFn(bencher) => {
-            let bs = ::test::bench::benchmark(|harness| bencher.run(harness));
+        DynBenchFn(benchfn) => {
+            let bs = ::test::bench::benchmark(benchfn);
             monitor_ch.send((desc, TrBench(bs)));
             return;
         }

branches/try/src/libextra/workcache.rs

@@ -394,14 +394,14 @@ impl<'self> Prep<'self> {
     pub fn exec<T:Send +
         Encodable<json::Encoder> +
         Decodable<json::Decoder>>(
-            &'self self, blk: proc(&mut Exec) -> T) -> T {
+            &'self self, blk: ~fn(&mut Exec) -> T) -> T {
         self.exec_work(blk).unwrap()
     }
 
     fn exec_work<T:Send +
         Encodable<json::Encoder> +
         Decodable<json::Decoder>>( // FIXME(#5121)
-            &'self self, blk: proc(&mut Exec) -> T) -> Work<'self, T> {
+            &'self self, blk: ~fn(&mut Exec) -> T) -> Work<'self, T> {
         let mut bo = Some(blk);
 
         debug!("exec_work: looking up {} and {:?}", self.fn_name,

branches/try/src/librustc/lib.rs

@@ -322,7 +322,7 @@ diagnostic emitter which records when we hit a fatal error. If the task
 fails without recording a fatal error then we've encountered a compiler
 bug and need to present an error.
 */
-pub fn monitor(f: proc(@diagnostic::Emitter)) {
+pub fn monitor(f: ~fn(@diagnostic::Emitter)) {
     use std::comm::*;
 
     // XXX: This is a hack for newsched since it doesn't support split stacks.

branches/try/src/librustuv/net.rs

@@ -1101,7 +1101,7 @@ mod test {
             let handle2 = Cell::new(sched2.make_handle());
             let tasksFriendHandle = Cell::new(sched2.make_handle());
 
-            let on_exit: proc(UnwindResult) = |exit_status| {
+            let on_exit: ~fn(UnwindResult) = |exit_status| {
                 handle1.take().send(Shutdown);
                 handle2.take().send(Shutdown);
                 assert!(exit_status.is_success());
@@ -1115,7 +1115,7 @@ mod test {
                 }
             }
 
-            let test_function: proc() = || {
+            let test_function: ~fn() = || {
                 let io = unsafe { local_io() };
                 let addr = next_test_ip4();
                 let maybe_socket = io.udp_bind(addr);

branches/try/src/librustuv/tty.rs

@@ -39,8 +39,7 @@ impl TtyWatcher {
         // Related:
         // - https://github.com/joyent/libuv/issues/982
         // - https://github.com/joyent/libuv/issues/988
-        let guess = unsafe { uvll::guess_handle(fd) };
-        if readable && guess != uvll::UV_TTY as libc::c_int {
+        if unsafe { uvll::guess_handle(fd) != uvll::UV_TTY as libc::c_int } {
             return Err(UvError(uvll::EBADF));
         }
 
@@ -101,10 +100,6 @@ impl RtioTTY for TtyWatcher {
             n => Err(uv_error_to_io_error(UvError(n)))
         }
     }
-
-    fn isatty(&self) -> bool {
-        unsafe { uvll::guess_handle(self.fd) == uvll::UV_TTY as libc::c_int }
-    }
 }
 
 impl UvHandle<uvll::uv_tty_t> for TtyWatcher {

branches/try/src/libstd/io/buffered.rs

@@ -391,7 +391,6 @@ mod test {
     // newtype struct autoderef weirdness
     #[test]
     fn test_buffered_stream() {
-        use rt;
         struct S;
 
         impl io::Writer for S {