Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Updated std::Option, std::Either and std::Result #8268

Closed
wants to merge 1 commit into from
Closed

Updated std::Option, std::Either and std::Result #8268

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion doc/tutorial-tasks.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -355,7 +355,7 @@ fn pnorm(nums: &~[float], p: uint) -> float {

fn main() {
let numbers = vec::from_fn(1000000, |_| rand::random::<float>());
println(fmt!("Inf-norm = %?", *numbers.iter().max().unwrap()));
println(fmt!("Inf-norm = %?", *numbers.iter().max().get()));

let numbers_arc = Arc::new(numbers);

Expand Down
2 changes: 1 addition & 1 deletion src/compiletest/errors.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,7 +15,7 @@ pub struct ExpectedError { line: uint, kind: ~str, msg: ~str }
// Load any test directives embedded in the file
pub fn load_errors(testfile: &Path) -> ~[ExpectedError] {
let mut error_patterns = ~[];
let rdr = io::file_reader(testfile).unwrap();
let rdr = io::file_reader(testfile).get();
let mut line_num = 1u;
while !rdr.eof() {
let ln = rdr.read_line();
Expand Down
2 changes: 1 addition & 1 deletion src/compiletest/header.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -105,7 +105,7 @@ pub fn is_test_ignored(config: &config, testfile: &Path) -> bool {
}

fn iter_header(testfile: &Path, it: &fn(~str) -> bool) -> bool {
let rdr = io::file_reader(testfile).unwrap();
let rdr = io::file_reader(testfile).get();
while !rdr.eof() {
let ln = rdr.read_line();

Expand Down
2 changes: 1 addition & 1 deletion src/compiletest/runtest.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -696,7 +696,7 @@ fn dump_output_file(config: &config, testfile: &Path,
out: &str, extension: &str) {
let outfile = make_out_name(config, testfile, extension);
let writer =
io::file_writer(&outfile, [io::Create, io::Truncate]).unwrap();
io::file_writer(&outfile, [io::Create, io::Truncate]).get();
writer.write_str(out);
}

Expand Down
28 changes: 14 additions & 14 deletions src/libextra/dlist.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -340,7 +340,7 @@ impl<T> DList<T> {
if take_a {
it.next();
} else {
it.insert_next_node(other.pop_front_node().unwrap());
it.insert_next_node(other.pop_front_node().get());
}
}
}
Expand Down Expand Up @@ -499,7 +499,7 @@ impl<'self, A> MutDListIterator<'self, A> {
None => return self.list.push_front_node(ins_node),
Some(prev) => prev,
};
let node_own = prev_node.next.take_unwrap();
let node_own = prev_node.next.take_get();
ins_node.next = link_with_prev(node_own, Rawlink::some(ins_node));
prev_node.next = link_with_prev(ins_node, Rawlink::some(prev_node));
self.list.length += 1;
Expand Down Expand Up @@ -634,14 +634,14 @@ mod tests {
n.push_front(2);
n.push_front(3);
{
assert_eq!(n.front().unwrap(), &3);
let x = n.front_mut().unwrap();
assert_eq!(n.front().get(), &3);
let x = n.front_mut().get();
assert_eq!(*x, 3);
*x = 0;
}
{
assert_eq!(n.back().unwrap(), &2);
let y = n.back_mut().unwrap();
assert_eq!(n.back().get(), &2);
let y = n.back_mut().get();
assert_eq!(*y, 2);
*y = 1;
}
Expand Down Expand Up @@ -750,7 +750,7 @@ mod tests {
n.push_front(4);
let mut it = n.iter();
assert_eq!(it.size_hint(), (1, Some(1)));
assert_eq!(it.next().unwrap(), &4);
assert_eq!(it.next().get(), &4);
assert_eq!(it.size_hint(), (0, Some(0)));
assert_eq!(it.next(), None);
}
Expand Down Expand Up @@ -778,11 +778,11 @@ mod tests {
n.push_front(6);
let mut it = n.iter();
assert_eq!(it.size_hint(), (3, Some(3)));
assert_eq!(it.next().unwrap(), &6);
assert_eq!(it.next().get(), &6);
assert_eq!(it.size_hint(), (2, Some(2)));
assert_eq!(it.next_back().unwrap(), &4);
assert_eq!(it.next_back().get(), &4);
assert_eq!(it.size_hint(), (1, Some(1)));
assert_eq!(it.next_back().unwrap(), &5);
assert_eq!(it.next_back().get(), &5);
assert_eq!(it.next_back(), None);
assert_eq!(it.next(), None);
}
Expand All @@ -798,7 +798,7 @@ mod tests {
n.push_front(4);
let mut it = n.rev_iter();
assert_eq!(it.size_hint(), (1, Some(1)));
assert_eq!(it.next().unwrap(), &4);
assert_eq!(it.next().get(), &4);
assert_eq!(it.size_hint(), (0, Some(0)));
assert_eq!(it.next(), None);
}
Expand Down Expand Up @@ -833,11 +833,11 @@ mod tests {
n.push_front(6);
let mut it = n.mut_iter();
assert_eq!(it.size_hint(), (3, Some(3)));
assert_eq!(*it.next().unwrap(), 6);
assert_eq!(*it.next().get(), 6);
assert_eq!(it.size_hint(), (2, Some(2)));
assert_eq!(*it.next_back().unwrap(), 4);
assert_eq!(*it.next_back().get(), 4);
assert_eq!(it.size_hint(), (1, Some(1)));
assert_eq!(*it.next_back().unwrap(), 5);
assert_eq!(*it.next_back().get(), 5);
assert!(it.next_back().is_none());
assert!(it.next().is_none());
}
Expand Down
10 changes: 4 additions & 6 deletions src/libextra/fileinput.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -224,7 +224,7 @@ impl FileInput {
let path_option = self.fi.files.shift();
let file = match path_option {
None => io::stdin(),
Some(ref path) => io::file_reader(path).unwrap()
Some(ref path) => io::file_reader(path).get()
};

self.fi.current_reader = Some(file);
Expand Down Expand Up @@ -417,7 +417,7 @@ mod test {
use std::vec;

fn make_file(path : &Path, contents: &[~str]) {
let file = io::file_writer(path, [io::Create, io::Truncate]).unwrap();
let file = io::file_writer(path, [io::Create, io::Truncate]).get();

foreach str in contents.iter() {
file.write_str(*str);
Expand Down Expand Up @@ -565,11 +565,9 @@ mod test {
let f2 =
Some(Path("tmp/lib-fileinput-test-no-trailing-newline-2.tmp"));

let wr = io::file_writer(f1.get_ref(),
[io::Create, io::Truncate]).unwrap();
let wr = io::file_writer(f1.get_ref(), [io::Create, io::Truncate]).get();
wr.write_str("1\n2");
let wr = io::file_writer(f2.get_ref(),
[io::Create, io::Truncate]).unwrap();
let wr = io::file_writer(f2.get_ref(), [io::Create, io::Truncate]).get();
wr.write_str("3\n4");

let mut lines = ~[];
Expand Down
2 changes: 1 addition & 1 deletion src/libextra/getopts.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -196,7 +196,7 @@ fn find_opt(opts: &[Opt], nm: Name) -> Option<uint> {
* The type returned when the command line does not conform to the
* expected format. Pass this value to <fail_str> to get an error message.
*/
#[deriving(Clone, Eq)]
#[deriving(Clone, Eq, ToStr)]
pub enum Fail_ {
ArgumentMissing(~str),
UnrecognizedOption(~str),
Expand Down
78 changes: 39 additions & 39 deletions src/libextra/json.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1511,8 +1511,8 @@ mod tests {

// We can't compare the strings directly because the object fields be
// printed in a different order.
assert_eq!(a.clone(), from_str(to_str(&a)).unwrap());
assert_eq!(a.clone(), from_str(to_pretty_str(&a)).unwrap());
assert_eq!(a.clone(), from_str(to_str(&a)).get());
assert_eq!(a.clone(), from_str(to_pretty_str(&a)).get());
}

#[test]
Expand Down Expand Up @@ -1631,15 +1631,15 @@ mod tests {

#[test]
fn test_decode_identifiers() {
let mut decoder = Decoder(from_str("null").unwrap());
let mut decoder = Decoder(from_str("null").get());
let v: () = Decodable::decode(&mut decoder);
assert_eq!(v, ());

let mut decoder = Decoder(from_str("true").unwrap());
let mut decoder = Decoder(from_str("true").get());
let v: bool = Decodable::decode(&mut decoder);
assert_eq!(v, true);

let mut decoder = Decoder(from_str("false").unwrap());
let mut decoder = Decoder(from_str("false").get());
let v: bool = Decodable::decode(&mut decoder);
assert_eq!(v, false);
}
Expand Down Expand Up @@ -1674,31 +1674,31 @@ mod tests {

#[test]
fn test_decode_numbers() {
let mut decoder = Decoder(from_str("3").unwrap());
let mut decoder = Decoder(from_str("3").get());
let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, 3f);

let mut decoder = Decoder(from_str("3.1").unwrap());
let mut decoder = Decoder(from_str("3.1").get());
let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, 3.1f);

let mut decoder = Decoder(from_str("-1.2").unwrap());
let mut decoder = Decoder(from_str("-1.2").get());
let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, -1.2f);

let mut decoder = Decoder(from_str("0.4").unwrap());
let mut decoder = Decoder(from_str("0.4").get());
let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4f);

let mut decoder = Decoder(from_str("0.4e5").unwrap());
let mut decoder = Decoder(from_str("0.4e5").get());
let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4e5f);

let mut decoder = Decoder(from_str("0.4e15").unwrap());
let mut decoder = Decoder(from_str("0.4e15").get());
let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4e15f);

let mut decoder = Decoder(from_str("0.4e-01").unwrap());
let mut decoder = Decoder(from_str("0.4e-01").get());
let v: float = Decodable::decode(&mut decoder);
assert_eq!(v, 0.4e-01f);
}
Expand Down Expand Up @@ -1726,39 +1726,39 @@ mod tests {

#[test]
fn test_decode_str() {
let mut decoder = Decoder(from_str("\"\"").unwrap());
let mut decoder = Decoder(from_str("\"\"").get());
let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"");

let mut decoder = Decoder(from_str("\"foo\"").unwrap());
let mut decoder = Decoder(from_str("\"foo\"").get());
let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"foo");

let mut decoder = Decoder(from_str("\"\\\"\"").unwrap());
let mut decoder = Decoder(from_str("\"\\\"\"").get());
let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\"");

let mut decoder = Decoder(from_str("\"\\b\"").unwrap());
let mut decoder = Decoder(from_str("\"\\b\"").get());
let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\x08");

let mut decoder = Decoder(from_str("\"\\n\"").unwrap());
let mut decoder = Decoder(from_str("\"\\n\"").get());
let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\n");

let mut decoder = Decoder(from_str("\"\\r\"").unwrap());
let mut decoder = Decoder(from_str("\"\\r\"").get());
let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\r");

let mut decoder = Decoder(from_str("\"\\t\"").unwrap());
let mut decoder = Decoder(from_str("\"\\t\"").get());
let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\t");

let mut decoder = Decoder(from_str("\"\\u12ab\"").unwrap());
let mut decoder = Decoder(from_str("\"\\u12ab\"").get());
let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\u12ab");

let mut decoder = Decoder(from_str("\"\\uAB12\"").unwrap());
let mut decoder = Decoder(from_str("\"\\uAB12\"").get());
let v: ~str = Decodable::decode(&mut decoder);
assert_eq!(v, ~"\uAB12");
}
Expand Down Expand Up @@ -1791,27 +1791,27 @@ mod tests {

#[test]
fn test_decode_list() {
let mut decoder = Decoder(from_str("[]").unwrap());
let mut decoder = Decoder(from_str("[]").get());
let v: ~[()] = Decodable::decode(&mut decoder);
assert_eq!(v, ~[]);

let mut decoder = Decoder(from_str("[null]").unwrap());
let mut decoder = Decoder(from_str("[null]").get());
let v: ~[()] = Decodable::decode(&mut decoder);
assert_eq!(v, ~[()]);

let mut decoder = Decoder(from_str("[true]").unwrap());
let mut decoder = Decoder(from_str("[true]").get());
let v: ~[bool] = Decodable::decode(&mut decoder);
assert_eq!(v, ~[true]);

let mut decoder = Decoder(from_str("[true]").unwrap());
let mut decoder = Decoder(from_str("[true]").get());
let v: ~[bool] = Decodable::decode(&mut decoder);
assert_eq!(v, ~[true]);

let mut decoder = Decoder(from_str("[3, 1]").unwrap());
let mut decoder = Decoder(from_str("[3, 1]").get());
let v: ~[int] = Decodable::decode(&mut decoder);
assert_eq!(v, ~[3, 1]);

let mut decoder = Decoder(from_str("[[3], [1, 2]]").unwrap());
let mut decoder = Decoder(from_str("[[3], [1, 2]]").get());
let v: ~[~[uint]] = Decodable::decode(&mut decoder);
assert_eq!(v, ~[~[3], ~[1, 2]]);
}
Expand Down Expand Up @@ -1866,21 +1866,21 @@ mod tests {
col: 8u,
msg: @~"EOF while parsing object"}));

assert_eq!(from_str("{}").unwrap(), mk_object([]));
assert_eq!(from_str("{\"a\": 3}").unwrap(),
assert_eq!(from_str("{}").get(), mk_object([]));
assert_eq!(from_str("{\"a\": 3}").get(),
mk_object([(~"a", Number(3.0f))]));

assert_eq!(from_str(
"{ \"a\": null, \"b\" : true }").unwrap(),
"{ \"a\": null, \"b\" : true }").get(),
mk_object([
(~"a", Null),
(~"b", Boolean(true))]));
assert_eq!(from_str("\n{ \"a\": null, \"b\" : true }\n").unwrap(),
assert_eq!(from_str("\n{ \"a\": null, \"b\" : true }\n").get(),
mk_object([
(~"a", Null),
(~"b", Boolean(true))]));
assert_eq!(from_str(
"{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(),
"{\"a\" : 1.0 ,\"b\": [ true ]}").get(),
mk_object([
(~"a", Number(1.0)),
(~"b", List(~[Boolean(true)]))
Expand All @@ -1893,7 +1893,7 @@ mod tests {
"\"foo\\nbar\", " +
"{ \"c\": {\"d\": null} } " +
"]" +
"}").unwrap(),
"}").get(),
mk_object([
(~"a", Number(1.0f)),
(~"b", List(~[
Expand All @@ -1913,7 +1913,7 @@ mod tests {
{ \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
]
}";
let mut decoder = Decoder(from_str(s).unwrap());
let mut decoder = Decoder(from_str(s).get());
let v: Outer = Decodable::decode(&mut decoder);
assert_eq!(
v,
Expand All @@ -1927,31 +1927,31 @@ mod tests {

#[test]
fn test_decode_option() {
let mut decoder = Decoder(from_str("null").unwrap());
let mut decoder = Decoder(from_str("null").get());
let value: Option<~str> = Decodable::decode(&mut decoder);
assert_eq!(value, None);

let mut decoder = Decoder(from_str("\"jodhpurs\"").unwrap());
let mut decoder = Decoder(from_str("\"jodhpurs\"").get());
let value: Option<~str> = Decodable::decode(&mut decoder);
assert_eq!(value, Some(~"jodhpurs"));
}

#[test]
fn test_decode_enum() {
let mut decoder = Decoder(from_str("\"Dog\"").unwrap());
let mut decoder = Decoder(from_str("\"Dog\"").get());
let value: Animal = Decodable::decode(&mut decoder);
assert_eq!(value, Dog);

let mut decoder =
Decoder(from_str("[\"Frog\",\"Henry\",349]").unwrap());
Decoder(from_str("[\"Frog\",\"Henry\",349]").get());
let value: Animal = Decodable::decode(&mut decoder);
assert_eq!(value, Frog(~"Henry", 349));
}

#[test]
fn test_decode_map() {
let s = ~"{\"a\": \"Dog\", \"b\": [\"Frog\", \"Henry\", 349]}";
let mut decoder = Decoder(from_str(s).unwrap());
let mut decoder = Decoder(from_str(s).get());
let mut map: TreeMap<~str, Animal> = Decodable::decode(&mut decoder);

assert_eq!(map.pop(&~"a"), Some(Dog));
Expand Down
Loading