Auto merge of #26212 - Manishearth:rollup, r=Manishearth

- Successful merges: #26181, #26184, #26189, #26191, #26195, #26202
- Failed merges:
This commit is contained in:
bors 2015-06-11 16:33:53 +00:00
commit deff2f50a9
6 changed files with 34 additions and 38 deletions

View file

@ -30,15 +30,13 @@ You may also be interested in browsing [trending Rust repositories][github-rust]
## Is anyone using Rust in production?
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:
Yes. For example (incomplete):
* [OpenDNS](http://labs.opendns.com/2013/10/04/zeromq-helping-us-block-malicious-domains/)
* [Skylight](http://skylight.io)
Let the fact that this is an easily countable number be a warning.
* [wit.ai](https://github.com/wit-ai/witd)
* [Codius](https://codius.org/blog/codius-rust/)
* [MaidSafe](http://maidsafe.net/)
## Does it run on Windows?

View file

@ -324,37 +324,34 @@ first, it may seem strange, but well figure it out. Heres how youd prob
try to return a closure from a function:
```rust,ignore
fn factory() -> (Fn(i32) -> Vec<i32>) {
let vec = vec![1, 2, 3];
fn factory() -> (Fn(i32) -> i32) {
let num = 5;
|n| vec.push(n)
|x| x + num
}
let f = factory();
let answer = f(4);
assert_eq!(vec![1, 2, 3, 4], answer);
let answer = f(1);
assert_eq!(6, 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) -> 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>) {
^~~~~~~~~~~~~~~~~~~~~
`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();
^
```
In order to return something from a function, Rust needs to know what
@ -364,16 +361,16 @@ way to give something a size is to take a reference to it, as references
have a known size. So wed write this:
```rust,ignore
fn factory() -> &(Fn(i32) -> Vec<i32>) {
let vec = vec![1, 2, 3];
fn factory() -> &(Fn(i32) -> i32) {
let num = 5;
|n| vec.push(n)
|x| x + num
}
let f = factory();
let answer = f(4);
assert_eq!(vec![1, 2, 3, 4], answer);
let answer = f(1);
assert_eq!(6, answer);
```
But we get another error:
@ -448,7 +445,8 @@ assert_eq!(6, answer);
We use a trait object, by `Box`ing up the `Fn`. Theres just one last problem:
```text
error: `num` does not live long enough
error: closure may outlive the current function, but it borrows `num`,
which is owned by the current function [E0373]
Box::new(|x| x + num)
^~~~~~~~~~~
```

View file

@ -3077,6 +3077,7 @@ pub fn empty<T>() -> Empty<T> {
}
/// An iterator that yields an element exactly once.
#[derive(Clone)]
#[unstable(feature="iter_once", reason = "new addition")]
pub struct Once<T> {
inner: ::option::IntoIter<T>

View file

@ -865,6 +865,7 @@ fn next_back(&mut self) -> Option<&'a mut A> { self.inner.next_back() }
impl<'a, A> ExactSizeIterator for IterMut<'a, A> {}
/// An iterator over the item contained inside an Option.
#[derive(Clone)]
#[stable(feature = "rust1", since = "1.0.0")]
pub struct IntoIter<A> { inner: Item<A> }

View file

@ -586,11 +586,9 @@ struct ListNode {
This type cannot have a well-defined size, because it needs to be arbitrarily
large (since we would be able to nest `ListNode`s to any depth). Specifically,
```
size of ListNode = 1 byte for head
+ 1 byte for the discriminant of the Option
+ size of ListNode
```
size of `ListNode` = 1 byte for `head`
+ 1 byte for the discriminant of the `Option`
+ size of `ListNode`
One way to fix this is by wrapping `ListNode` in a `Box`, like so:

View file

@ -486,7 +486,7 @@ pub fn to_lowercase(self) -> ToLowercase {
/// # Return value
///
/// Returns an iterator which yields the characters corresponding to the
/// lowercase equivalent of the character. If no conversion is possible then
/// titlecase equivalent of the character. If no conversion is possible then
/// an iterator with just the input character is returned.
#[unstable(feature = "unicode", reason = "recently added")]
#[inline]