Skip to content

Commit bf5f507

Browse files
author
Keegan McAllister
committed
---
yaml --- r: 187782 b: refs/heads/tmp c: 65e1e6b h: refs/heads/master v: v3
1 parent 9d7ccb3 commit bf5f507

File tree

174 files changed

+3065
-3444
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

174 files changed

+3065
-3444
lines changed

‎[refs]

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -34,5 +34,5 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
3434
refs/heads/beta: 522d09dfecbeca1595f25ac58c6d0178bbd21d7d
3535
refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
3636
refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
37-
refs/heads/tmp: b711b6a5b2bc52ca27d75d5031239dbac92e42e2
37+
refs/heads/tmp: 65e1e6bb942701a061f6772507141ea9f8e920e2
3838
refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

‎branches/tmp/src/doc/trpl/error-handling.md

Lines changed: 0 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -223,78 +223,6 @@ let input = io::stdin().read_line()
223223
.ok()
224224
.expect("Failed to read line");
225225
```
226-
227226
`ok()` converts the `IoResult` into an `Option`, and `expect()` does the same
228227
thing as `unwrap()`, but takes a message. This message is passed along to the
229228
underlying `panic!`, providing a better error message if the code errors.
230-
231-
# Using `try!`
232-
233-
When writing code that calls many functions that return the `Result` type, the
234-
error handling can be tedious. The `try!` macro hides some of the boilerplate
235-
of propagating errors up the call stack.
236-
237-
It replaces this:
238-
239-
```rust
240-
use std::fs::File;
241-
use std::io;
242-
use std::io::prelude::*;
243-
244-
struct Info {
245-
name: String,
246-
age: i32,
247-
rating: i32,
248-
}
249-
250-
fn write_info(info: &Info) -> io::Result<()> {
251-
let mut file = File::open("my_best_friends.txt").unwrap();
252-
253-
if let Err(e) = writeln!(&mut file, "name: {}", info.name) {
254-
return Err(e)
255-
}
256-
if let Err(e) = writeln!(&mut file, "age: {}", info.age) {
257-
return Err(e)
258-
}
259-
if let Err(e) = writeln!(&mut file, "rating: {}", info.rating) {
260-
return Err(e)
261-
}
262-
263-
return Ok(());
264-
}
265-
```
266-
267-
With this:
268-
269-
```rust
270-
use std::fs::File;
271-
use std::io;
272-
use std::io::prelude::*;
273-
274-
struct Info {
275-
name: String,
276-
age: i32,
277-
rating: i32,
278-
}
279-
280-
fn write_info(info: &Info) -> io::Result<()> {
281-
let mut file = try!(File::open("my_best_friends.txt"));
282-
283-
try!(writeln!(&mut file, "name: {}", info.name));
284-
try!(writeln!(&mut file, "age: {}", info.age));
285-
try!(writeln!(&mut file, "rating: {}", info.rating));
286-
287-
return Ok(());
288-
}
289-
```
290-
291-
Wrapping an expression in `try!` will result in the unwrapped success (`Ok`)
292-
value, unless the result is `Err`, in which case `Err` is returned early from
293-
the enclosing function.
294-
295-
It's worth noting that you can only use `try!` from a function that returns a
296-
`Result`, which means that you cannot use `try!` inside of `main()`, because
297-
`main()` doesn't return anything.
298-
299-
`try!` makes use of [`FromError`](../std/error/#the-fromerror-trait) to determine
300-
what to return in the error case.

‎branches/tmp/src/doc/trpl/macros.md

Lines changed: 40 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -73,7 +73,7 @@ macro_rules! vec {
7373
};
7474
}
7575
# fn main() {
76-
# assert_eq!([1,2,3], vec![1,2,3]);
76+
# assert_eq!(&[1,2,3], &vec![1,2,3]);
7777
# }
7878
```
7979

@@ -357,6 +357,45 @@ fn main() {
357357

358358
[items]: ../reference.html#items
359359

360+
# Recursive macros
361+
362+
A macro's expansion can include more macro invocations, including invocations
363+
of the very same macro being expanded. These recursive macros are useful for
364+
processing tree-structured input, as illustrated by this (simplistic) HTML
365+
shorthand:
366+
367+
```rust
368+
# #![allow(unused_must_use)]
369+
macro_rules! write_html {
370+
($w:expr, ) => (());
371+
372+
($w:expr, $e:tt) => (write!($w, "{}", $e));
373+
374+
($w:expr, $tag:ident [ $($inner:tt)* ] $($rest:tt)*) => {{
375+
write!($w, "<{}>", stringify!($tag));
376+
write_html!($w, $($inner)*);
377+
write!($w, "</{}>", stringify!($tag));
378+
write_html!($w, $($rest)*);
379+
}};
380+
}
381+
382+
fn main() {
383+
# // FIXME(#21826)
384+
use std::fmt::Write;
385+
let mut out = String::new();
386+
387+
write_html!(&mut out,
388+
html[
389+
head[title["Macros guide"]]
390+
body[h1["Macros are the best!"]]
391+
]);
392+
393+
assert_eq!(out,
394+
"<html><head><title>Macros guide</title></head>\
395+
<body><h1>Macros are the best!</h1></body></html>");
396+
}
397+
```
398+
360399
# Further reading
361400

362401
The [advanced macros chapter][] goes into more detail about macro syntax. It

‎branches/tmp/src/libcollections/binary_heap.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -480,7 +480,7 @@ impl<T: Ord> BinaryHeap<T> {
480480
/// heap.push(3);
481481
///
482482
/// let vec = heap.into_sorted_vec();
483-
/// assert_eq!(vec, [1, 2, 3, 4, 5, 6, 7]);
483+
/// assert_eq!(vec, vec![1, 2, 3, 4, 5, 6, 7]);
484484
/// ```
485485
pub fn into_sorted_vec(mut self) -> Vec<T> {
486486
let mut end = self.len();

‎branches/tmp/src/libcollections/bit.rs

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -640,13 +640,13 @@ impl BitVec {
640640
/// let mut bv = BitVec::from_elem(3, true);
641641
/// bv.set(1, false);
642642
///
643-
/// assert_eq!(bv.to_bytes(), [0b10100000]);
643+
/// assert_eq!(bv.to_bytes(), vec!(0b10100000));
644644
///
645645
/// let mut bv = BitVec::from_elem(9, false);
646646
/// bv.set(2, true);
647647
/// bv.set(8, true);
648648
///
649-
/// assert_eq!(bv.to_bytes(), [0b00100000, 0b10000000]);
649+
/// assert_eq!(bv.to_bytes(), vec!(0b00100000, 0b10000000));
650650
/// ```
651651
pub fn to_bytes(&self) -> Vec<u8> {
652652
fn bit(bit_vec: &BitVec, byte: usize, bit: usize) -> u8 {
@@ -806,7 +806,7 @@ impl BitVec {
806806
/// let mut bv = BitVec::from_bytes(&[0b01001011]);
807807
/// bv.grow(2, true);
808808
/// assert_eq!(bv.len(), 10);
809-
/// assert_eq!(bv.to_bytes(), [0b01001011, 0b11000000]);
809+
/// assert_eq!(bv.to_bytes(), vec!(0b01001011, 0b11000000));
810810
/// ```
811811
pub fn grow(&mut self, n: usize, value: bool) {
812812
// Note: we just bulk set all the bits in the last word in this fn in multiple places
@@ -2285,12 +2285,12 @@ mod tests {
22852285
fn test_to_bytes() {
22862286
let mut bv = BitVec::from_elem(3, true);
22872287
bv.set(1, false);
2288-
assert_eq!(bv.to_bytes(), [0b10100000]);
2288+
assert_eq!(bv.to_bytes(), vec!(0b10100000));
22892289

22902290
let mut bv = BitVec::from_elem(9, false);
22912291
bv.set(2, true);
22922292
bv.set(8, true);
2293-
assert_eq!(bv.to_bytes(), [0b00100000, 0b10000000]);
2293+
assert_eq!(bv.to_bytes(), vec!(0b00100000, 0b10000000));
22942294
}
22952295

22962296
#[test]
@@ -2675,7 +2675,7 @@ mod bit_set_test {
26752675
let bit_vec: BitSet = usizes.into_iter().collect();
26762676

26772677
let idxs: Vec<_> = bit_vec.iter().collect();
2678-
assert_eq!(idxs, [0, 2, 3]);
2678+
assert_eq!(idxs, vec![0, 2, 3]);
26792679

26802680
let long: BitSet = (0..10000).filter(|&n| n % 2 == 0).collect();
26812681
let real: Vec<_> = range_step(0, 10000, 2).collect();

‎branches/tmp/src/libcollections/btree/map.rs

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -347,7 +347,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
347347
let result = stack.with(move |pusher, node| {
348348
// Same basic logic as found in `find`, but with PartialSearchStack mediating the
349349
// actual nodes for us
350-
match Node::search(node, &key) {
350+
return match Node::search(node, &key) {
351351
Found(mut handle) => {
352352
// Perfect match, swap the values and return the old one
353353
mem::swap(handle.val_mut(), &mut value);
@@ -372,7 +372,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
372372
}
373373
});
374374
match result {
375-
Finished(ret) => return ret,
375+
Finished(ret) => { return ret; },
376376
Continue((new_stack, renewed_key, renewed_val)) => {
377377
stack = new_stack;
378378
key = renewed_key;
@@ -439,7 +439,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
439439
let mut stack = stack::PartialSearchStack::new(self);
440440
loop {
441441
let result = stack.with(move |pusher, node| {
442-
match Node::search(node, key) {
442+
return match Node::search(node, key) {
443443
Found(handle) => {
444444
// Perfect match. Terminate the stack here, and remove the entry
445445
Finished(Some(pusher.seal(handle).remove()))
@@ -1281,7 +1281,7 @@ impl<K, V> BTreeMap<K, V> {
12811281
/// a.insert(2, "b");
12821282
///
12831283
/// let keys: Vec<usize> = a.keys().cloned().collect();
1284-
/// assert_eq!(keys, [1, 2]);
1284+
/// assert_eq!(keys, vec![1,2,]);
12851285
/// ```
12861286
#[stable(feature = "rust1", since = "1.0.0")]
12871287
pub fn keys<'a>(&'a self) -> Keys<'a, K, V> {
@@ -1303,7 +1303,7 @@ impl<K, V> BTreeMap<K, V> {
13031303
/// a.insert(2, "b");
13041304
///
13051305
/// let values: Vec<&str> = a.values().cloned().collect();
1306-
/// assert_eq!(values, ["a", "b"]);
1306+
/// assert_eq!(values, vec!["a","b"]);
13071307
/// ```
13081308
#[stable(feature = "rust1", since = "1.0.0")]
13091309
pub fn values<'a>(&'a self) -> Values<'a, K, V> {
@@ -1560,7 +1560,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
15601560
let mut stack = stack::PartialSearchStack::new(self);
15611561
loop {
15621562
let result = stack.with(move |pusher, node| {
1563-
match Node::search(node, &key) {
1563+
return match Node::search(node, &key) {
15641564
Found(handle) => {
15651565
// Perfect match
15661566
Finished(Occupied(OccupiedEntry {

‎branches/tmp/src/libcollections/btree/set.rs

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -121,7 +121,7 @@ impl<T> BTreeSet<T> {
121121
/// }
122122
///
123123
/// let v: Vec<usize> = set.iter().cloned().collect();
124-
/// assert_eq!(v, [1, 2, 3, 4]);
124+
/// assert_eq!(v, vec![1,2,3,4]);
125125
/// ```
126126
#[stable(feature = "rust1", since = "1.0.0")]
127127
pub fn iter(&self) -> Iter<T> {
@@ -138,7 +138,7 @@ impl<T> BTreeSet<T> {
138138
/// let set: BTreeSet<usize> = [1, 2, 3, 4].iter().cloned().collect();
139139
///
140140
/// let v: Vec<usize> = set.into_iter().collect();
141-
/// assert_eq!(v, [1, 2, 3, 4]);
141+
/// assert_eq!(v, vec![1,2,3,4]);
142142
/// ```
143143
#[stable(feature = "rust1", since = "1.0.0")]
144144
pub fn into_iter(self) -> IntoIter<T> {
@@ -197,7 +197,7 @@ impl<T: Ord> BTreeSet<T> {
197197
/// b.insert(3);
198198
///
199199
/// let diff: Vec<usize> = a.difference(&b).cloned().collect();
200-
/// assert_eq!(diff, [1]);
200+
/// assert_eq!(diff, vec![1]);
201201
/// ```
202202
#[stable(feature = "rust1", since = "1.0.0")]
203203
pub fn difference<'a>(&'a self, other: &'a BTreeSet<T>) -> Difference<'a, T> {
@@ -220,7 +220,7 @@ impl<T: Ord> BTreeSet<T> {
220220
/// b.insert(3);
221221
///
222222
/// let sym_diff: Vec<usize> = a.symmetric_difference(&b).cloned().collect();
223-
/// assert_eq!(sym_diff, [1, 3]);
223+
/// assert_eq!(sym_diff, vec![1,3]);
224224
/// ```
225225
#[stable(feature = "rust1", since = "1.0.0")]
226226
pub fn symmetric_difference<'a>(&'a self, other: &'a BTreeSet<T>)
@@ -244,7 +244,7 @@ impl<T: Ord> BTreeSet<T> {
244244
/// b.insert(3);
245245
///
246246
/// let intersection: Vec<usize> = a.intersection(&b).cloned().collect();
247-
/// assert_eq!(intersection, [2]);
247+
/// assert_eq!(intersection, vec![2]);
248248
/// ```
249249
#[stable(feature = "rust1", since = "1.0.0")]
250250
pub fn intersection<'a>(&'a self, other: &'a BTreeSet<T>)
@@ -266,7 +266,7 @@ impl<T: Ord> BTreeSet<T> {
266266
/// b.insert(2);
267267
///
268268
/// let union: Vec<usize> = a.union(&b).cloned().collect();
269-
/// assert_eq!(union, [1, 2]);
269+
/// assert_eq!(union, vec![1,2]);
270270
/// ```
271271
#[stable(feature = "rust1", since = "1.0.0")]
272272
pub fn union<'a>(&'a self, other: &'a BTreeSet<T>) -> Union<'a, T> {
@@ -534,7 +534,7 @@ impl<'a, 'b, T: Ord + Clone> Sub<&'b BTreeSet<T>> for &'a BTreeSet<T> {
534534
///
535535
/// let result = &a - &b;
536536
/// let result_vec: Vec<_> = result.into_iter().collect();
537-
/// assert_eq!(result_vec, [1, 2]);
537+
/// assert_eq!(result_vec, vec![1, 2]);
538538
/// ```
539539
fn sub(self, rhs: &BTreeSet<T>) -> BTreeSet<T> {
540540
self.difference(rhs).cloned().collect()
@@ -557,7 +557,7 @@ impl<'a, 'b, T: Ord + Clone> BitXor<&'b BTreeSet<T>> for &'a BTreeSet<T> {
557557
///
558558
/// let result = &a ^ &b;
559559
/// let result_vec: Vec<_> = result.into_iter().collect();
560-
/// assert_eq!(result_vec, [1, 4]);
560+
/// assert_eq!(result_vec, vec![1, 4]);
561561
/// ```
562562
fn bitxor(self, rhs: &BTreeSet<T>) -> BTreeSet<T> {
563563
self.symmetric_difference(rhs).cloned().collect()
@@ -580,7 +580,7 @@ impl<'a, 'b, T: Ord + Clone> BitAnd<&'b BTreeSet<T>> for &'a BTreeSet<T> {
580580
///
581581
/// let result = &a & &b;
582582
/// let result_vec: Vec<_> = result.into_iter().collect();
583-
/// assert_eq!(result_vec, [2, 3]);
583+
/// assert_eq!(result_vec, vec![2, 3]);
584584
/// ```
585585
fn bitand(self, rhs: &BTreeSet<T>) -> BTreeSet<T> {
586586
self.intersection(rhs).cloned().collect()
@@ -603,7 +603,7 @@ impl<'a, 'b, T: Ord + Clone> BitOr<&'b BTreeSet<T>> for &'a BTreeSet<T> {
603603
///
604604
/// let result = &a | &b;
605605
/// let result_vec: Vec<_> = result.into_iter().collect();
606-
/// assert_eq!(result_vec, [1, 2, 3, 4, 5]);
606+
/// assert_eq!(result_vec, vec![1, 2, 3, 4, 5]);
607607
/// ```
608608
fn bitor(self, rhs: &BTreeSet<T>) -> BTreeSet<T> {
609609
self.union(rhs).cloned().collect()

0 commit comments

Comments
 (0)