---

yaml
---
r: 212476
b: refs/heads/master
c: fa0de66
h: refs/heads/master
v: v3

Author: tshepang

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 95407cc627bfd2c0cda7c41a1d8dba301b215bca
+refs/heads/master: fa0de66dfe7058bad6376b93ffffb682050d8805
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
 refs/heads/try: 1864973ae17213c5a58c4dd3f9af6d1b6c7d2e05

trunk/src/doc/complement-lang-faq.md

@@ -30,13 +30,15 @@ You may also be interested in browsing [trending Rust repositories][github-rust]
 
 ## Is anyone using Rust in production?
 
-Yes. For example (incomplete):
+Currently, Rust is still pre-1.0, and so we don't recommend that you use Rust
+in production unless you know exactly what you're getting into.
+
+That said, there are two production deployments of Rust that we're aware of:
 
 * [OpenDNS](http://labs.opendns.com/2013/10/04/zeromq-helping-us-block-malicious-domains/)
 * [Skylight](http://skylight.io)
-* [wit.ai](https://github.com/wit-ai/witd)
-* [Codius](https://codius.org/blog/codius-rust/)
-* [MaidSafe](http://maidsafe.net/)
+
+Let the fact that this is an easily countable number be a warning.
 
 ## Does it run on Windows?
 

trunk/src/doc/trpl/closures.md

@@ -324,34 +324,37 @@ first, it may seem strange, but we’ll figure it out. Here’s how you’d prob
 try to return a closure from a function:
 
 ```rust,ignore
-fn factory() -> (Fn(i32) -> i32) {
-    let num = 5;
+fn factory() -> (Fn(i32) -> Vec<i32>) {
+    let vec = vec![1, 2, 3];
 
-    |x| x + num
+    |n| vec.push(n)
 }
 
 let f = factory();
 
-let answer = f(1);
-assert_eq!(6, answer);
+let answer = f(4);
+assert_eq!(vec![1, 2, 3, 4], answer);
 ```
 
 This gives us these long, related errors:
 
 ```text
 error: the trait `core::marker::Sized` is not implemented for the type
-`core::ops::Fn(i32) -> i32` [E0277]
-fn factory() -> (Fn(i32) -> i32) {
-                ^~~~~~~~~~~~~~~~
-note: `core::ops::Fn(i32) -> i32` does not have a constant size known at compile-time
-fn factory() -> (Fn(i32) -> i32) {
-                ^~~~~~~~~~~~~~~~
-error: the trait `core::marker::Sized` is not implemented for the type `core::ops::Fn(i32) -> i32` [E0277]
-let f = factory();
-    ^
-note: `core::ops::Fn(i32) -> i32` does not have a constant size known at compile-time
-let f = factory();
-    ^
+`core::ops::Fn(i32) -> collections::vec::Vec<i32>` [E0277]
+f = factory();
+^
+note: `core::ops::Fn(i32) -> collections::vec::Vec<i32>` does not have a
+constant size known at compile-time
+f = factory();
+^
+error: the trait `core::marker::Sized` is not implemented for the type
+`core::ops::Fn(i32) -> collections::vec::Vec<i32>` [E0277]
+factory() -> (Fn(i32) -> Vec<i32>) {
+             ^~~~~~~~~~~~~~~~~~~~~
+note: `core::ops::Fn(i32) -> collections::vec::Vec<i32>` does not have a constant size known at compile-time
+factory() -> (Fn(i32) -> Vec<i32>) {
+             ^~~~~~~~~~~~~~~~~~~~~
+
 ```
 
 In order to return something from a function, Rust needs to know what
@@ -361,16 +364,16 @@ way to give something a size is to take a reference to it, as references
 have a known size. So we’d write this:
 
 ```rust,ignore
-fn factory() -> &(Fn(i32) -> i32) {
-    let num = 5;
+fn factory() -> &(Fn(i32) -> Vec<i32>) {
+    let vec = vec![1, 2, 3];
 
-    |x| x + num
+    |n| vec.push(n)
 }
 
 let f = factory();
 
-let answer = f(1);
-assert_eq!(6, answer);
+let answer = f(4);
+assert_eq!(vec![1, 2, 3, 4], answer);
 ```
 
 But we get another error:
@@ -445,8 +448,7 @@ assert_eq!(6, answer);
 We use a trait object, by `Box`ing up the `Fn`. There’s just one last problem:
 
 ```text
-error: closure may outlive the current function, but it borrows `num`,
-which is owned by the current function [E0373]
+error: `num` does not live long enough
 Box::new(|x| x + num)
          ^~~~~~~~~~~
 ```

trunk/src/libcollections/borrow.rs

@@ -21,7 +21,7 @@ use core::ops::Deref;
 use core::option::Option;
 
 use fmt;
-use alloc::{boxed, rc, arc};
+use alloc::{rc, arc};
 
 use self::Cow::*;
 
@@ -116,14 +116,6 @@ impl<'a, T: ?Sized> BorrowMut<T> for &'a mut T {
     fn borrow_mut(&mut self) -> &mut T { &mut **self }
 }
 
-impl<T: ?Sized> Borrow<T> for boxed::Box<T> {
-    fn borrow(&self) -> &T { &**self }
-}
-
-impl<T: ?Sized> BorrowMut<T> for boxed::Box<T> {
-    fn borrow_mut(&mut self) -> &mut T { &mut **self }
-}
-
 impl<T: ?Sized> Borrow<T> for rc::Rc<T> {
     fn borrow(&self) -> &T { &**self }
 }