mathieu/granite-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

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

Browse source 
- Made naming schemes consistent between Option, Result and Either
- Changed Options Add implementation to work like the maybe monad (return None if any of the inputs is None)
- Removed duplicate Option::get and renamed all related functions to use the term `unwrap` instead
This commit is contained in:
Marvin Löbel 2013-08-04 01:59:24 +02:00
parent d8b299d179
commit 0ac7a219f0
115 changed files with 803 additions and 828 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/compiletest/compiletest.rs
View file

@ -131,7 +131,7 @@ pub fn parse_config(args: ~[~str]) -> config {
ratchet_noise_percent:
getopts::opt_maybe_str(matches,
"ratchet-noise-percent").map(|s|
f64::from_str(*s).get()),
f64::from_str(*s).unwrap()),
runtool: getopts::opt_maybe_str(matches, "runtool"),
rustcflags: getopts::opt_maybe_str(matches, "rustcflags"),
jit: getopts::opt_present(matches, "jit"),
@ -267,7 +267,7 @@ pub fn is_test(config: &config, testfile: &Path) -> bool {
_ => ~[~".rc", ~".rs"]
};
let invalid_prefixes = ~[~".", ~"#", ~"~"];
let name = testfile.filename().get();
let name = testfile.filename().unwrap();
let mut valid = false;
@ -300,7 +300,7 @@ pub fn make_test_name(config: &config, testfile: &Path) -> test::TestName {
fn shorten(path: &Path) -> ~str {
let filename = path.filename();
let dir = path.pop().filename();
fmt!("%s/%s", dir.get_or_default(~""), filename.get_or_default(~""))
fmt!("%s/%s", dir.unwrap_or_default(~""), filename.unwrap_or_default(~""))
}
test::DynTestName(fmt!("[%s] %s",

12
src/compiletest/runtest.rs
View file

@ -145,7 +145,7 @@ fn run_pretty_test(config: &config, props: &TestProps, testfile: &Path) {
let rounds =
match props.pp_exact { Some(_) => 1, None => 2 };
let mut srcs = ~[io::read_whole_file_str(testfile).get()];
let mut srcs = ~[io::read_whole_file_str(testfile).unwrap()];
let mut round = 0;
while round < rounds {
@ -166,7 +166,7 @@ fn run_pretty_test(config: &config, props: &TestProps, testfile: &Path) {
match props.pp_exact {
Some(ref file) => {
let filepath = testfile.dir_path().push_rel(file);
io::read_whole_file_str(&filepath).get()
io::read_whole_file_str(&filepath).unwrap()
}
None => { srcs[srcs.len() - 2u].clone() }
};
@ -448,7 +448,7 @@ fn scan_until_char(haystack: &str, needle: char, idx: &mut uint) -> bool {
if opt.is_none() {
return false;
}
*idx = opt.get();
*idx = opt.unwrap();
return true;
}
@ -709,7 +709,7 @@ fn aux_output_dir_name(config: &config, testfile: &Path) -> Path {
}
fn output_testname(testfile: &Path) -> Path {
Path(testfile.filestem().get())
Path(testfile.filestem().unwrap())
}
fn output_base_name(config: &config, testfile: &Path) -> Path {
@ -878,7 +878,7 @@ fn append_suffix_to_stem(p: &Path, suffix: &str) -> Path {
if suffix.len() == 0 {
(*p).clone()
} else {
let stem = p.filestem().get();
let stem = p.filestem().unwrap();
p.with_filestem(stem + "-" + suffix)
}
}
@ -938,7 +938,7 @@ fn disassemble_extract(config: &config, _props: &TestProps,
fn count_extracted_lines(p: &Path) -> uint {
let x = io::read_whole_file_str(&p.with_filetype("ll")).get();
let x = io::read_whole_file_str(&p.with_filetype("ll")).unwrap();
x.line_iter().len_()
}

20
src/libextra/base64.rs
View file

@ -322,24 +322,24 @@ mod test {
#[test]
fn test_from_base64_basic() {
assert_eq!("".from_base64().get(), "".as_bytes().to_owned());
assert_eq!("Zg==".from_base64().get(), "f".as_bytes().to_owned());
assert_eq!("Zm8=".from_base64().get(), "fo".as_bytes().to_owned());
assert_eq!("Zm9v".from_base64().get(), "foo".as_bytes().to_owned());
assert_eq!("Zm9vYg==".from_base64().get(), "foob".as_bytes().to_owned());
assert_eq!("Zm9vYmE=".from_base64().get(), "fooba".as_bytes().to_owned());
assert_eq!("Zm9vYmFy".from_base64().get(), "foobar".as_bytes().to_owned());
assert_eq!("".from_base64().unwrap(), "".as_bytes().to_owned());
assert_eq!("Zg==".from_base64().unwrap(), "f".as_bytes().to_owned());
assert_eq!("Zm8=".from_base64().unwrap(), "fo".as_bytes().to_owned());
assert_eq!("Zm9v".from_base64().unwrap(), "foo".as_bytes().to_owned());
assert_eq!("Zm9vYg==".from_base64().unwrap(), "foob".as_bytes().to_owned());
assert_eq!("Zm9vYmE=".from_base64().unwrap(), "fooba".as_bytes().to_owned());
assert_eq!("Zm9vYmFy".from_base64().unwrap(), "foobar".as_bytes().to_owned());
}
#[test]
fn test_from_base64_newlines() {
assert_eq!("Zm9v\r\nYmFy".from_base64().get(),
assert_eq!("Zm9v\r\nYmFy".from_base64().unwrap(),
"foobar".as_bytes().to_owned());
}
#[test]
fn test_from_base64_urlsafe() {
assert_eq!("-_8".from_base64().get(), "+/8=".from_base64().get());
assert_eq!("-_8".from_base64().unwrap(), "+/8=".from_base64().unwrap());
}
#[test]
@ -364,7 +364,7 @@ mod test {
push(random());
}
};
assert_eq!(v.to_base64(STANDARD).from_base64().get(), v);
assert_eq!(v.to_base64(STANDARD).from_base64().unwrap(), v);
}
}

4
src/libextra/fileinput.rs
View file

@ -526,8 +526,8 @@ mod test {
do input_vec_state(filenames) |line, state| {
let nums: ~[&str] = line.split_iter(' ').collect();
let file_num = uint::from_str(nums[0]).get();
let line_num = uint::from_str(nums[1]).get();
let file_num = uint::from_str(nums[0]).unwrap();
let line_num = uint::from_str(nums[1]).unwrap();
assert_eq!(line_num, state.line_num_file);
assert_eq!(file_num * 3 + line_num, state.line_num);
true

8
src/libextra/getopts.rs
View file

@ -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),
@ -288,7 +288,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
None => {
let arg_follows =
last_valid_opt_id.is_some() &&
match opts[last_valid_opt_id.get()]
match opts[last_valid_opt_id.unwrap()]
.hasarg {
Yes | Maybe => true,
@ -322,7 +322,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
}
Maybe => {
if !i_arg.is_none() {
vals[optid].push(Val((i_arg.clone()).get()));
vals[optid].push(Val((i_arg.clone()).unwrap()));
} else if name_pos < names.len() ||
i + 1 == l || is_arg(args[i + 1]) {
vals[optid].push(Given);
@ -330,7 +330,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result {
}
Yes => {
if !i_arg.is_none() {
vals[optid].push(Val(i_arg.clone().get()));
vals[optid].push(Val(i_arg.clone().unwrap()));
} else if i + 1 == l {
return Err(ArgumentMissing(name_str(nm)));
} else { i += 1; vals[optid].push(Val(args[i].clone())); }

12
src/libextra/num/bigint.rs
View file

@ -1510,11 +1510,11 @@ mod biguint_tests {
#[test]
fn test_is_even() {
assert!(FromStr::from_str::<BigUint>("1").get().is_odd());
assert!(FromStr::from_str::<BigUint>("2").get().is_even());
assert!(FromStr::from_str::<BigUint>("1000").get().is_even());
assert!(FromStr::from_str::<BigUint>("1000000000000000000000").get().is_even());
assert!(FromStr::from_str::<BigUint>("1000000000000000000001").get().is_odd());
assert!(FromStr::from_str::<BigUint>("1").unwrap().is_odd());
assert!(FromStr::from_str::<BigUint>("2").unwrap().is_even());
assert!(FromStr::from_str::<BigUint>("1000").unwrap().is_even());
assert!(FromStr::from_str::<BigUint>("1000000000000000000000").unwrap().is_even());
assert!(FromStr::from_str::<BigUint>("1000000000000000000001").unwrap().is_odd());
assert!((BigUint::from_uint(1) << 64).is_even());
assert!(((BigUint::from_uint(1) << 64) + BigUint::from_uint(1)).is_odd());
}
@ -1595,7 +1595,7 @@ mod biguint_tests {
let &(ref n, ref rs) = num_pair;
for str_pair in rs.iter() {
let &(ref radix, ref str) = str_pair;
assert_eq!(n, &FromStrRadix::from_str_radix(*str, *radix).get());
assert_eq!(n, &FromStrRadix::from_str_radix(*str, *radix).unwrap());
}
}

12
src/libextra/ringbuf.rs
View file

@ -437,12 +437,12 @@ mod tests {
assert_eq!(deq.len(), 3);
deq.push_back(d.clone());
assert_eq!(deq.len(), 4);
assert_eq!((*deq.front().get()).clone(), b.clone());
assert_eq!((*deq.back().get()).clone(), d.clone());
assert_eq!(deq.pop_front().get(), b.clone());
assert_eq!(deq.pop_back().get(), d.clone());
assert_eq!(deq.pop_back().get(), c.clone());
assert_eq!(deq.pop_back().get(), a.clone());
assert_eq!((*deq.front().unwrap()).clone(), b.clone());
assert_eq!((*deq.back().unwrap()).clone(), d.clone());
assert_eq!(deq.pop_front().unwrap(), b.clone());
assert_eq!(deq.pop_back().unwrap(), d.clone());
assert_eq!(deq.pop_back().unwrap(), c.clone());
assert_eq!(deq.pop_back().unwrap(), a.clone());
assert_eq!(deq.len(), 0);
deq.push_back(c.clone());
assert_eq!(deq.len(), 1);

4
src/libextra/semver.rs
View file

@ -386,8 +386,8 @@ fn test_spec_order() {
"1.0.0"];
let mut i = 1;
while i < vs.len() {
let a = parse(vs[i-1]).get();
let b = parse(vs[i]).get();
let a = parse(vs[i-1]).unwrap();
let b = parse(vs[i]).unwrap();
assert!(a < b);
i += 1;
}

6
src/libextra/smallintmap.rs
View file

@ -366,9 +366,9 @@ mod test_map {
map.update_with_key(3, 2, addMoreToCount);
// check the total counts
assert_eq!(map.find(&3).get(), &10);
assert_eq!(map.find(&5).get(), &3);
assert_eq!(map.find(&9).get(), &1);
assert_eq!(map.find(&3).unwrap(), &10);
assert_eq!(map.find(&5).unwrap(), &3);
assert_eq!(map.find(&9).unwrap(), &1);
// sadly, no sevens were counted
assert!(map.find(&7).is_none());

57
src/libextra/test.rs
View file

@ -247,9 +247,8 @@ pub fn parse_opts(args: &[~str]) -> OptRes {
let ratchet_metrics = getopts::opt_maybe_str(&matches, "ratchet-metrics");
let ratchet_metrics = ratchet_metrics.map(|s| Path(*s));
let ratchet_noise_percent =
getopts::opt_maybe_str(&matches, "ratchet-noise-percent");
let ratchet_noise_percent = ratchet_noise_percent.map(|s| f64::from_str(*s).get());
let ratchet_noise_percent = getopts::opt_maybe_str(&matches, "ratchet-noise-percent");
let ratchet_noise_percent = ratchet_noise_percent.map(|s| f64::from_str(*s).unwrap());
let save_metrics = getopts::opt_maybe_str(&matches, "save-metrics");
let save_metrics = save_metrics.map(|s| Path(*s));
@ -631,8 +630,8 @@ fn should_sort_failures_before_printing_them() {
st.write_failures();
};
let apos = s.find_str("a").get();
let bpos = s.find_str("b").get();
let apos = s.find_str("a").unwrap();
let bpos = s.find_str("b").unwrap();
assert!(apos < bpos);
}
@ -868,7 +867,7 @@ impl MetricMap {
pub fn load(p: &Path) -> MetricMap {
assert!(os::path_exists(p));
let f = io::file_reader(p).unwrap();
let mut decoder = json::Decoder(json::from_reader(f).get());
let mut decoder = json::Decoder(json::from_reader(f).unwrap());
MetricMap(Decodable::decode(&mut decoder))
}
@ -1207,7 +1206,7 @@ mod tests {
either::Left(o) => o,
_ => fail!("Malformed arg in first_free_arg_should_be_a_filter")
};
assert!("filter" == opts.filter.clone().get());
assert!("filter" == opts.filter.clone().unwrap());
}
#[test]
@ -1346,28 +1345,28 @@ mod tests {
let diff1 = m2.compare_to_old(&m1, None);
assert_eq!(*(diff1.find(&~"in-both-noise").get()), LikelyNoise);
assert_eq!(*(diff1.find(&~"in-first-noise").get()), MetricRemoved);
assert_eq!(*(diff1.find(&~"in-second-noise").get()), MetricAdded);
assert_eq!(*(diff1.find(&~"in-both-want-downwards-but-regressed").get()),
assert_eq!(*(diff1.find(&~"in-both-noise").unwrap()), LikelyNoise);
assert_eq!(*(diff1.find(&~"in-first-noise").unwrap()), MetricRemoved);
assert_eq!(*(diff1.find(&~"in-second-noise").unwrap()), MetricAdded);
assert_eq!(*(diff1.find(&~"in-both-want-downwards-but-regressed").unwrap()),
Regression(100.0));
assert_eq!(*(diff1.find(&~"in-both-want-downwards-and-improved").get()),
assert_eq!(*(diff1.find(&~"in-both-want-downwards-and-improved").unwrap()),
Improvement(50.0));
assert_eq!(*(diff1.find(&~"in-both-want-upwards-but-regressed").get()),
assert_eq!(*(diff1.find(&~"in-both-want-upwards-but-regressed").unwrap()),
Regression(50.0));
assert_eq!(*(diff1.find(&~"in-both-want-upwards-and-improved").get()),
assert_eq!(*(diff1.find(&~"in-both-want-upwards-and-improved").unwrap()),
Improvement(100.0));
assert_eq!(diff1.len(), 7);
let diff2 = m2.compare_to_old(&m1, Some(200.0));
assert_eq!(*(diff2.find(&~"in-both-noise").get()), LikelyNoise);
assert_eq!(*(diff2.find(&~"in-first-noise").get()), MetricRemoved);
assert_eq!(*(diff2.find(&~"in-second-noise").get()), MetricAdded);
assert_eq!(*(diff2.find(&~"in-both-want-downwards-but-regressed").get()), LikelyNoise);
assert_eq!(*(diff2.find(&~"in-both-want-downwards-and-improved").get()), LikelyNoise);
assert_eq!(*(diff2.find(&~"in-both-want-upwards-but-regressed").get()), LikelyNoise);
assert_eq!(*(diff2.find(&~"in-both-want-upwards-and-improved").get()), LikelyNoise);
assert_eq!(*(diff2.find(&~"in-both-noise").unwrap()), LikelyNoise);
assert_eq!(*(diff2.find(&~"in-first-noise").unwrap()), MetricRemoved);
assert_eq!(*(diff2.find(&~"in-second-noise").unwrap()), MetricAdded);
assert_eq!(*(diff2.find(&~"in-both-want-downwards-but-regressed").unwrap()), LikelyNoise);
assert_eq!(*(diff2.find(&~"in-both-want-downwards-and-improved").unwrap()), LikelyNoise);
assert_eq!(*(diff2.find(&~"in-both-want-upwards-but-regressed").unwrap()), LikelyNoise);
assert_eq!(*(diff2.find(&~"in-both-want-upwards-and-improved").unwrap()), LikelyNoise);
assert_eq!(diff2.len(), 7);
}
@ -1391,28 +1390,28 @@ mod tests {
let (diff1, ok1) = m2.ratchet(&pth, None);
assert_eq!(ok1, false);
assert_eq!(diff1.len(), 2);
assert_eq!(*(diff1.find(&~"runtime").get()), Regression(10.0));
assert_eq!(*(diff1.find(&~"throughput").get()), LikelyNoise);
assert_eq!(*(diff1.find(&~"runtime").unwrap()), Regression(10.0));
assert_eq!(*(diff1.find(&~"throughput").unwrap()), LikelyNoise);
// Check that it was not rewritten.
let m3 = MetricMap::load(&pth);
assert_eq!(m3.len(), 2);
assert_eq!(*(m3.find(&~"runtime").get()), Metric { value: 1000.0, noise: 2.0 });
assert_eq!(*(m3.find(&~"throughput").get()), Metric { value: 50.0, noise: 2.0 });
assert_eq!(*(m3.find(&~"runtime").unwrap()), Metric { value: 1000.0, noise: 2.0 });
assert_eq!(*(m3.find(&~"throughput").unwrap()), Metric { value: 50.0, noise: 2.0 });
// Ask for a ratchet with an explicit noise-percentage override,
// that should advance.
let (diff2, ok2) = m2.ratchet(&pth, Some(10.0));
assert_eq!(ok2, true);
assert_eq!(diff2.len(), 2);
assert_eq!(*(diff2.find(&~"runtime").get()), LikelyNoise);
assert_eq!(*(diff2.find(&~"throughput").get()), LikelyNoise);
assert_eq!(*(diff2.find(&~"runtime").unwrap()), LikelyNoise);
assert_eq!(*(diff2.find(&~"throughput").unwrap()), LikelyNoise);
// Check that it was rewritten.
let m4 = MetricMap::load(&pth);
assert_eq!(m4.len(), 2);
assert_eq!(*(m4.find(&~"runtime").get()), Metric { value: 1100.0, noise: 2.0 });
assert_eq!(*(m4.find(&~"throughput").get()), Metric { value: 50.0, noise: 2.0 });
assert_eq!(*(m4.find(&~"runtime").unwrap()), Metric { value: 1100.0, noise: 2.0 });
assert_eq!(*(m4.find(&~"throughput").unwrap()), Metric { value: 50.0, noise: 2.0 });
os::remove_dir_recursive(&dpth);
}

4
src/libextra/url.rs
View file

@ -134,7 +134,7 @@ fn decode_inner(s: &str, full_url: bool) -> ~str {
match rdr.read_char() {
'%' => {
let bytes = rdr.read_bytes(2u);
let ch = uint::parse_bytes(bytes, 16u).get() as char;
let ch = uint::parse_bytes(bytes, 16u).unwrap() as char;
if full_url {
// Only decode some characters:
@ -257,7 +257,7 @@ pub fn decode_form_urlencoded(s: &[u8]) -> HashMap<~str, ~[~str]> {
let ch = match ch {
'%' => {
let bytes = rdr.read_bytes(2u);
uint::parse_bytes(bytes, 16u).get() as char
uint::parse_bytes(bytes, 16u).unwrap() as char
}
'+' => ' ',
ch => ch

4
src/librustc/back/link.rs
View file

@ -912,7 +912,7 @@ pub fn link_args(sess: Session,
}
let dir = cratepath.dirname();
if dir != ~"" { args.push(~"-L" + dir); }
let libarg = unlib(sess.targ_cfg, cratepath.filestem().get());
let libarg = unlib(sess.targ_cfg, cratepath.filestem().unwrap());
args.push(~"-l" + libarg);
}
@ -950,7 +950,7 @@ pub fn link_args(sess: Session,
// be rpathed
if sess.targ_cfg.os == session::os_macos {
args.push(~"-Wl,-install_name,@rpath/"
+ output.filename().get());
+ output.filename().unwrap());
}
}

6
src/librustc/back/passes.rs
View file

@ -319,7 +319,7 @@ fn passes_exist() {
if !pass.is_some() {
failed.push(name);
} else {
unsafe { llvm::LLVMDestroyPass(pass.get()) }
unsafe { llvm::LLVMDestroyPass(pass.unwrap()) }
}
}
for &(name,_) in transform_passes.iter() {
@ -327,7 +327,7 @@ fn passes_exist() {
if !pass.is_some() {
failed.push(name);
} else {
unsafe { llvm::LLVMDestroyPass(pass.get()) }
unsafe { llvm::LLVMDestroyPass(pass.unwrap()) }
}
}
for &(name,_) in utility_passes.iter() {
@ -335,7 +335,7 @@ fn passes_exist() {
if !pass.is_some() {
failed.push(name);
} else {
unsafe { llvm::LLVMDestroyPass(pass.get()) }
unsafe { llvm::LLVMDestroyPass(pass.unwrap()) }
}
}

2
src/librustc/driver/driver.rs
View file

@ -922,7 +922,7 @@ pub fn build_output_filenames(input: &input,
};
let mut stem = match *input {
file_input(ref ifile) => (*ifile).filestem().get().to_managed(),
file_input(ref ifile) => (*ifile).filestem().unwrap().to_managed(),
str_input(_) => @"rust_out"
};

4
src/librustc/front/test.rs
View file

@ -308,7 +308,7 @@ fn mk_test_module(cx: &TestCtxt) -> @ast::item {
#[main];
extra::test::test_main_static(::std::os::args(), TESTS);
}
)).get();
)).unwrap();
let testmod = ast::_mod {
view_items: view_items,
@ -366,7 +366,7 @@ fn mk_tests(cx: &TestCtxt) -> @ast::item {
pub static TESTS : &'static [self::extra::test::TestDescAndFn] =
$test_descs
;
)).get()
)).unwrap()
}
fn is_extra(cx: &TestCtxt) -> bool {

10
src/librustc/middle/astencode.rs
View file

@ -328,7 +328,7 @@ fn simplify_ast(ii: &ast::inlined_item) -> ast::inlined_item {
match *ii {
//hack: we're not dropping items
ast::ii_item(i) => ast::ii_item(fld.fold_item(i).get()),
ast::ii_item(i) => ast::ii_item(fld.fold_item(i).unwrap()),
ast::ii_method(d, is_provided, m) =>
ast::ii_method(d, is_provided, fld.fold_method(m)),
ast::ii_foreign(i) => ast::ii_foreign(fld.fold_foreign_item(i))
@ -350,7 +350,7 @@ fn renumber_ast(xcx: @ExtendedDecodeContext, ii: ast::inlined_item)
});
match ii {
ast::ii_item(i) => ast::ii_item(fld.fold_item(i).get()),
ast::ii_item(i) => ast::ii_item(fld.fold_item(i).unwrap()),
ast::ii_method(d, is_provided, m) =>
ast::ii_method(xcx.tr_def_id(d), is_provided, fld.fold_method(m)),
ast::ii_foreign(i) => ast::ii_foreign(fld.fold_foreign_item(i)),
@ -1275,7 +1275,7 @@ fn mk_ctxt() -> @fake_ext_ctxt {
fn roundtrip(in_item: Option<@ast::item>) {
use std::io;
let in_item = in_item.get();
let in_item = in_item.unwrap();
let bytes = do io::with_bytes_writer |wr| {
let mut ebml_w = writer::Encoder(wr);
encode_item_ast(&mut ebml_w, in_item);
@ -1321,13 +1321,13 @@ fn test_simplification() {
fn eq_int(a: int, b: int) -> bool { a == b }
return alist {eq_fn: eq_int, data: ~[]};
}
).get());
).unwrap());
let item_out = simplify_ast(&item_in);
let item_exp = ast::ii_item(quote_item!(
fn new_int_alist<B>() -> alist<int, B> {
return alist {eq_fn: eq_int, data: ~[]};
}
).get());
).unwrap());
match (item_out, item_exp) {
(ast::ii_item(item_out), ast::ii_item(item_exp)) => {
assert!(pprust::item_to_str(item_out,

2
src/librustc/middle/borrowck/check_loans.rs
View file

@ -307,7 +307,7 @@ impl<'self> CheckLoanCtxt<'self> {
// if they cannot already have been assigned
if self.is_local_variable(cmt) {
assert!(cmt.mutbl.is_immutable()); // no "const" locals
let lp = opt_loan_path(cmt).get();
let lp = opt_loan_path(cmt).unwrap();
do self.move_data.each_assignment_of(expr.id, lp) |assign| {
self.bccx.report_reassigned_immutable_variable(
expr.span,

12
src/librustc/middle/check_match.rs
View file

@ -109,7 +109,7 @@ pub fn check_arms(cx: &MatchCheckCtxt, arms: &[arm]) {
let pat_matches_nan: &fn(@pat) -> bool = |p| {
match cx.tcx.def_map.find(&p.id) {
Some(&def_static(did, false)) => {
let const_expr = lookup_const_by_id(cx.tcx, did).get();
let const_expr = lookup_const_by_id(cx.tcx, did).unwrap();
match eval_const_expr(cx.tcx, const_expr) {
const_float(f) if f.is_NaN() => true,
_ => false
@ -304,7 +304,7 @@ pub fn is_useful_specialized(cx: &MatchCheckCtxt,
-> useful {
let ms = m.iter().filter_map(|r| specialize(cx, *r, &ctor, arity, lty)).collect::<matrix>();
let could_be_useful = is_useful(
cx, &ms, specialize(cx, v, &ctor, arity, lty).get());
cx, &ms, specialize(cx, v, &ctor, arity, lty).unwrap());
match could_be_useful {
useful_ => useful(lty, ctor),
ref u => *u,
@ -319,7 +319,7 @@ pub fn pat_ctor_id(cx: &MatchCheckCtxt, p: @pat) -> Option<ctor> {
match cx.tcx.def_map.find(&pat.id) {
Some(&def_variant(_, id)) => Some(variant(id)),
Some(&def_static(did, false)) => {
let const_expr = lookup_const_by_id(cx.tcx, did).get();
let const_expr = lookup_const_by_id(cx.tcx, did).unwrap();
Some(val(eval_const_expr(cx.tcx, const_expr)))
}
_ => None
@ -515,7 +515,7 @@ pub fn specialize(cx: &MatchCheckCtxt,
}
Some(&def_static(did, _)) => {
let const_expr =
lookup_const_by_id(cx.tcx, did).get();
lookup_const_by_id(cx.tcx, did).unwrap();
let e_v = eval_const_expr(cx.tcx, const_expr);
let match_ = match *ctor_id {
val(ref v) => {
@ -565,7 +565,7 @@ pub fn specialize(cx: &MatchCheckCtxt,
match cx.tcx.def_map.get_copy(&pat_id) {
def_static(did, _) => {
let const_expr =
lookup_const_by_id(cx.tcx, did).get();
lookup_const_by_id(cx.tcx, did).unwrap();
let e_v = eval_const_expr(cx.tcx, const_expr);
let match_ = match *ctor_id {
val(ref v) =>
@ -867,7 +867,7 @@ pub fn check_legality_of_move_bindings(cx: &MatchCheckCtxt,
"cannot bind by-move and by-ref \
in the same pattern");
tcx.sess.span_note(
by_ref_span.get(),
by_ref_span.unwrap(),
"by-ref binding occurs here");
}
};

4
src/librustc/middle/const_eval.rs
View file

@ -466,9 +466,9 @@ pub fn lit_to_const(lit: &lit) -> const_val {
lit_int(n, _) => const_int(n),
lit_uint(n, _) => const_uint(n),
lit_int_unsuffixed(n) => const_int(n),
lit_float(n, _) => const_float(float::from_str(n).get() as f64),
lit_float(n, _) => const_float(float::from_str(n).unwrap() as f64),
lit_float_unsuffixed(n) =>
const_float(float::from_str(n).get() as f64),
const_float(float::from_str(n).unwrap() as f64),
lit_nil => const_int(0i64),
lit_bool(b) => const_bool(b)
}

2
src/librustc/middle/privacy.rs
View file

@ -225,7 +225,7 @@ pub fn check_crate<'mm>(tcx: ty::ctxt,
// the default implementation.
// Having to do this this is really unfortunate.
let method_id = ty::method(tcx, method_id).provided_source
.get_or_default(method_id);
.unwrap_or_default(method_id);
if method_id.crate == LOCAL_CRATE {
let is_private = method_is_private(span, method_id.node);

4
src/librustc/middle/resolve.rs
View file

@ -1726,7 +1726,7 @@ impl Resolver {
let mut modules = HashMap::new();
// Create all the items reachable by paths.
do each_path(self.session.cstore, root.def_id.get().crate)
do each_path(self.session.cstore, root.def_id.unwrap().crate)
|path_string, def_like, visibility| {
debug!("(building reduced graph for external crate) found path \
@ -2350,7 +2350,7 @@ impl Resolver {
match type_result {
BoundResult(target_module, name_bindings) => {
debug!("(resolving single import) found type target: %?",
name_bindings.type_def.get().type_def);
name_bindings.type_def.unwrap().type_def);
import_resolution.type_target =
Some(Target(target_module, name_bindings));
import_resolution.type_id = directive.id;

8
src/librustc/middle/trans/_match.rs
View file

@ -210,7 +210,7 @@ pub fn opt_eq(tcx: ty::ctxt, a: &Opt, b: &Opt) -> bool {
ExprLit(existing_a_expr) => a_expr = existing_a_expr,
ConstLit(a_const) => {
let e = const_eval::lookup_const_by_id(tcx, a_const);
a_expr = e.get();
a_expr = e.unwrap();
}
UnitLikeStructLit(_) => {
fail!("UnitLikeStructLit should have been handled \
@ -223,7 +223,7 @@ pub fn opt_eq(tcx: ty::ctxt, a: &Opt, b: &Opt) -> bool {
ExprLit(existing_b_expr) => b_expr = existing_b_expr,
ConstLit(b_const) => {
let e = const_eval::lookup_const_by_id(tcx, b_const);
b_expr = e.get();
b_expr = e.unwrap();
}
UnitLikeStructLit(_) => {
fail!("UnitLikeStructLit should have been handled \
@ -922,7 +922,7 @@ pub fn extract_vec_elems(bcx: @mut Block,
}
};
if slice.is_some() {
let n = slice.get();
let n = slice.unwrap();
let slice_offset = Mul(bcx, vt.llunit_size,
C_int(bcx.ccx(), n as int)
);
@ -1280,7 +1280,7 @@ pub fn compile_submatch(bcx: @mut Block,
let _icx = push_ctxt("match::compile_submatch");
let mut bcx = bcx;
if m.len() == 0u {
Br(bcx, chk.get()());
Br(bcx, chk.unwrap()());
return;
}
if m[0].pats.len() == 0u {

2
src/librustc/middle/trans/adt.rs
View file

@ -260,7 +260,7 @@ fn generic_fields_of(cx: &mut CrateContext, r: &Repr, sizing: bool) -> ~[Type] {
most_aligned = Some(st);
}
}
let most_aligned = most_aligned.get();
let most_aligned = most_aligned.unwrap();
let padding = largest_size - most_aligned.size;
struct_llfields(cx, most_aligned, sizing)

22
src/librustc/middle/trans/base.rs
View file

@ -1321,7 +1321,7 @@ pub fn cleanup_and_leave(bcx: @mut Block,
}
match leave {
Some(target) => Br(bcx, target),
None => { Resume(bcx, Load(bcx, bcx.fcx.personality.get())); }
None => { Resume(bcx, Load(bcx, bcx.fcx.personality.unwrap())); }
}
}
@ -1529,7 +1529,7 @@ pub fn alloca_maybe_zeroed(cx: @mut Block, ty: Type, name: &str, zero: bool) ->
let p = Alloca(cx, ty, name);
if zero {
let b = cx.fcx.ccx.builder();
b.position_before(cx.fcx.alloca_insert_pt.get());
b.position_before(cx.fcx.alloca_insert_pt.unwrap());
memzero(&b, p, ty);
}
p
@ -1575,7 +1575,7 @@ pub fn make_return_pointer(fcx: @mut FunctionContext, output_type: ty::t) -> Val
llvm::LLVMGetParam(fcx.llfn, 0)
} else {
let lloutputtype = type_of::type_of(fcx.ccx, output_type);
let bcx = fcx.entry_bcx.get();
let bcx = fcx.entry_bcx.unwrap();
Alloca(bcx, lloutputtype, "__make_return_pointer")
}
}
@ -1793,7 +1793,7 @@ pub fn finish_fn(fcx: @mut FunctionContext, last_bcx: @mut Block) {
pub fn build_return_block(fcx: &FunctionContext, ret_cx: @mut Block) {
// Return the value if this function immediate; otherwise, return void.
if fcx.llretptr.is_some() && fcx.has_immediate_return_value {
Ret(ret_cx, Load(ret_cx, fcx.llretptr.get()))
Ret(ret_cx, Load(ret_cx, fcx.llretptr.unwrap()))
} else {
RetVoid(ret_cx)
}
@ -1843,7 +1843,7 @@ pub fn trans_closure(ccx: @mut CrateContext,
// Create the first basic block in the function and keep a handle on it to
// pass to finish_fn later.
let bcx_top = fcx.entry_bcx.get();
let bcx_top = fcx.entry_bcx.unwrap();
let mut bcx = bcx_top;
let block_ty = node_id_type(bcx, body.id);
@ -1861,7 +1861,7 @@ pub fn trans_closure(ccx: @mut CrateContext,
{
bcx = controlflow::trans_block(bcx, body, expr::Ignore);
} else {
let dest = expr::SaveIn(fcx.llretptr.get());
let dest = expr::SaveIn(fcx.llretptr.unwrap());
bcx = controlflow::trans_block(bcx, body, dest);
}
@ -2055,18 +2055,18 @@ pub fn trans_enum_variant_or_tuple_like_struct<A:IdAndTy>(
let raw_llargs = create_llargs_for_fn_args(fcx, no_self, fn_args);
let bcx = fcx.entry_bcx.get();
let bcx = fcx.entry_bcx.unwrap();
let arg_tys = ty::ty_fn_args(ctor_ty);
insert_synthetic_type_entries(bcx, fn_args, arg_tys);
let bcx = copy_args_to_allocas(fcx, bcx, fn_args, raw_llargs, arg_tys);
let repr = adt::represent_type(ccx, result_ty);
adt::trans_start_init(bcx, repr, fcx.llretptr.get(), disr);
adt::trans_start_init(bcx, repr, fcx.llretptr.unwrap(), disr);
for (i, fn_arg) in fn_args.iter().enumerate() {
let lldestptr = adt::trans_field_ptr(bcx,
repr,
fcx.llretptr.get(),
fcx.llretptr.unwrap(),
disr,
i);
let llarg = fcx.llargs.get_copy(&fn_arg.pat.id);
@ -2293,7 +2293,7 @@ pub fn create_entry_wrapper(ccx: @mut CrateContext,
// be updated if this assertion starts to fail.
assert!(fcx.has_immediate_return_value);
let bcx = fcx.entry_bcx.get();
let bcx = fcx.entry_bcx.unwrap();
// Call main.
let llenvarg = unsafe {
let env_arg = fcx.env_arg_pos();
@ -2782,7 +2782,7 @@ pub fn create_module_map(ccx: &mut CrateContext) -> ValueRef {
}
for key in keys.iter() {
let val = *ccx.module_data.find_equiv(key).get();
let val = *ccx.module_data.find_equiv(key).unwrap();
let s_const = C_cstr(ccx, *key);
let s_ptr = p2i(ccx, s_const);
let v_ptr = p2i(ccx, val);

4
src/librustc/middle/trans/build.rs
View file

@ -319,7 +319,7 @@ pub fn Alloca(cx: @mut Block, Ty: Type, name: &str) -> ValueRef {
unsafe {
if cx.unreachable { return llvm::LLVMGetUndef(Ty.ptr_to().to_ref()); }
let b = cx.fcx.ccx.builder();
b.position_before(cx.fcx.alloca_insert_pt.get());
b.position_before(cx.fcx.alloca_insert_pt.unwrap());
b.alloca(Ty, name)
}
}
@ -328,7 +328,7 @@ pub fn ArrayAlloca(cx: @mut Block, Ty: Type, Val: ValueRef) -> ValueRef {
unsafe {
if cx.unreachable { return llvm::LLVMGetUndef(Ty.ptr_to().to_ref()); }
let b = cx.fcx.ccx.builder();
b.position_before(cx.fcx.alloca_insert_pt.get());
b.position_before(cx.fcx.alloca_insert_pt.unwrap());
b.array_alloca(Ty, Val)
}
}

2
src/librustc/middle/trans/cabi.rs
View file

@ -169,7 +169,7 @@ impl FnType {
} else {
Load(bcx, llretval)
};
let llretptr = BitCast(bcx, bcx.fcx.llretptr.get(), self.ret_ty.ty.ptr_to());
let llretptr = BitCast(bcx, bcx.fcx.llretptr.unwrap(), self.ret_ty.ty.ptr_to());
Store(bcx, llretval, llretptr);
}
}

4
src/librustc/middle/trans/closure.rs
View file

@ -330,7 +330,7 @@ pub fn load_environment(fcx: @mut FunctionContext,
return;
}
let bcx = fcx.entry_bcx.get();
let bcx = fcx.entry_bcx.unwrap();
// Load a pointer to the closure data, skipping over the box header:
let llcdata = opaque_box_body(bcx, cdata_ty, fcx.llenv);
@ -443,7 +443,7 @@ pub fn trans_expr_fn(bcx: @mut Block,
if is_loop_body.is_some() {
Store(bcx,
C_bool(true),
bcx.fcx.llretptr.get());
bcx.fcx.llretptr.unwrap());
}
});
rslt(bcx, llbox)

4
src/librustc/middle/trans/common.rs
View file

@ -251,7 +251,7 @@ impl FunctionContext {
pub fn cleanup(&mut self) {
unsafe {
llvm::LLVMInstructionEraseFromParent(self.alloca_insert_pt.get());
llvm::LLVMInstructionEraseFromParent(self.alloca_insert_pt.unwrap());
}
// Remove the cycle between fcx and bcx, so memory can be freed
self.entry_bcx = None;
@ -262,7 +262,7 @@ impl FunctionContext {
self.llreturn = Some(base::mk_return_basic_block(self.llfn));
}
self.llreturn.get()
self.llreturn.unwrap()
}
}

4
src/librustc/middle/trans/controlflow.rs
View file

@ -314,7 +314,7 @@ pub fn trans_break_cont(bcx: @mut Block,
Some(bcx) => bcx,
// This is a return from a loop body block
None => {
Store(bcx, C_bool(!to_end), bcx.fcx.llretptr.get());
Store(bcx, C_bool(!to_end), bcx.fcx.llretptr.unwrap());
cleanup_and_leave(bcx, None, Some(bcx.fcx.get_llreturn()));
Unreachable(bcx);
return bcx;
@ -346,7 +346,7 @@ pub fn trans_ret(bcx: @mut Block, e: Option<@ast::expr>) -> @mut Block {
// to false, return flag to true, and then store the value in the
// parent's retptr.
Store(bcx, C_bool(true), flagptr);
Store(bcx, C_bool(false), bcx.fcx.llretptr.get());
Store(bcx, C_bool(false), bcx.fcx.llretptr.unwrap());
expr::SaveIn(match e {
Some(x) => PointerCast(bcx, retptr,
type_of(bcx.ccx(), expr_ty(bcx, x)).ptr_to()),

4
src/librustc/middle/trans/debuginfo.rs
View file

@ -485,8 +485,8 @@ fn lexical_block_metadata(bcx: @mut Block) -> DILexicalBlock {
}
}
let span = bcx.node_info.get().span;
let id = bcx.node_info.get().id;
let span = bcx.node_info.unwrap().span;
let id = bcx.node_info.unwrap().id;
// Check whether we already have a cache entry for this node id
match dbg_cx(cx).created_blocks.find(&id) {

20
src/librustc/middle/trans/foreign.rs
View file

@ -149,7 +149,7 @@ fn build_shim_fn_(ccx: @mut CrateContext,
// Declare the body of the shim function:
let fcx = new_fn_ctxt(ccx, ~[], llshimfn, tys.fn_sig.output, None);
let bcx = fcx.entry_bcx.get();
let bcx = fcx.entry_bcx.unwrap();
let llargbundle = get_param(llshimfn, 0u);
let llargvals = arg_builder(bcx, tys, llargbundle);
@ -190,7 +190,7 @@ fn build_wrap_fn_(ccx: @mut CrateContext,
ret_builder: wrap_ret_builder) {
let _icx = push_ctxt("foreign::build_wrap_fn_");
let fcx = new_fn_ctxt(ccx, ~[], llwrapfn, tys.fn_sig.output, None);
let bcx = fcx.entry_bcx.get();
let bcx = fcx.entry_bcx.unwrap();
// Patch up the return type if it's not immediate and we're returning via
// the C ABI.
@ -226,7 +226,7 @@ fn build_wrap_fn_(ccx: @mut CrateContext,
} else {
// Cast if we have to...
// XXX: This is ugly.
let llretptr = BitCast(return_context, fcx.llretptr.get(), return_type.ptr_to());
let llretptr = BitCast(return_context, fcx.llretptr.unwrap(), return_type.ptr_to());
Ret(return_context, Load(return_context, llretptr));
}
fcx.cleanup();
@ -421,7 +421,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext,
debug!("build_direct_fn(%s)", link_name(ccx, item));
let fcx = new_fn_ctxt(ccx, ~[], decl, tys.fn_sig.output, None);
let bcx = fcx.entry_bcx.get();
let bcx = fcx.entry_bcx.unwrap();
let llbasefn = base_fn(ccx, link_name(ccx, item), tys, cc);
let ty = ty::lookup_item_type(ccx.tcx,
ast_util::local_def(item.id)).ty;
@ -431,7 +431,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext,
});
let retval = Call(bcx, llbasefn, args);
if !ty::type_is_nil(ret_ty) && !ty::type_is_bot(ret_ty) {
Store(bcx, retval, fcx.llretptr.get());
Store(bcx, retval, fcx.llretptr.unwrap());
}
finish_fn(fcx, bcx);
}
@ -446,7 +446,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext,
debug!("build_fast_ffi_fn(%s)", link_name(ccx, item));
let fcx = new_fn_ctxt(ccx, ~[], decl, tys.fn_sig.output, None);
let bcx = fcx.entry_bcx.get();
let bcx = fcx.entry_bcx.unwrap();
let llbasefn = base_fn(ccx, link_name(ccx, item), tys, cc);
set_no_inline(fcx.llfn);
set_fixed_stack_segment(fcx.llfn);
@ -458,7 +458,7 @@ pub fn trans_foreign_mod(ccx: @mut CrateContext,
});
let retval = Call(bcx, llbasefn, args);
if !ty::type_is_nil(ret_ty) && !ty::type_is_bot(ret_ty) {
Store(bcx, retval, fcx.llretptr.get());
Store(bcx, retval, fcx.llretptr.unwrap());
}
finish_fn(fcx, bcx);
}
@ -618,7 +618,7 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
set_fixed_stack_segment(fcx.llfn);
}
let mut bcx = fcx.entry_bcx.get();
let mut bcx = fcx.entry_bcx.unwrap();
let first_real_arg = fcx.arg_pos(0u);
let nm = ccx.sess.str_of(item.ident);
@ -775,7 +775,7 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
let in_type_size = machine::llbitsize_of_real(ccx, llintype);
let out_type_size = machine::llbitsize_of_real(ccx, llouttype);
if in_type_size != out_type_size {
let sp = match ccx.tcx.items.get_copy(&ref_id.get()) {
let sp = match ccx.tcx.items.get_copy(&ref_id.unwrap()) {
ast_map::node_expr(e) => e.span,
_ => fail!("transmute has non-expr arg"),
};
@ -816,7 +816,7 @@ pub fn trans_intrinsic(ccx: @mut CrateContext,
// NB: Do not use a Load and Store here. This causes massive
// code bloat when `transmute` is used on large structural
// types.
let lldestptr = fcx.llretptr.get();
let lldestptr = fcx.llretptr.unwrap();
let lldestptr = PointerCast(bcx, lldestptr, Type::i8p());
let llsrcptr = PointerCast(bcx, llsrcval, Type::i8p());

4
src/librustc/middle/trans/glue.rs
View file

@ -311,7 +311,7 @@ pub fn call_tydesc_glue_full(bcx: @mut Block,
let llrawptr = if static_ti.is_none() || static_glue_fn.is_none() {
PointerCast(bcx, v, Type::i8p())
} else {
let ty = static_ti.get().ty;
let ty = static_ti.unwrap().ty;
let simpl = simplified_glue_type(ccx.tcx, field, ty);
if simpl != ty {
PointerCast(bcx, v, type_of(ccx, simpl).ptr_to())
@ -708,7 +708,7 @@ pub fn make_generic_glue_inner(ccx: @mut CrateContext,
// llfn is expected be declared to take a parameter of the appropriate
// type, so we don't need to explicitly cast the function parameter.
let bcx = fcx.entry_bcx.get();
let bcx = fcx.entry_bcx.unwrap();
let rawptr0_arg = fcx.arg_pos(0u);
let llrawptr0 = unsafe { llvm::LLVMGetParam(llfn, rawptr0_arg as c_uint) };
let bcx = helper(bcx, llrawptr0, t);

4
src/librustc/middle/trans/monomorphize.rs
View file

@ -180,7 +180,7 @@ pub fn monomorphic_fn(ccx: @mut CrateContext,
let idx = psubsts.tys.len() - num_method_ty_params;
let substs =
(psubsts.tys.slice(0, idx) +
&[psubsts.self_ty.get()] +
&[psubsts.self_ty.unwrap()] +
psubsts.tys.tailn(idx));
debug!("static default: changed substitution to %s",
substs.repr(ccx.tcx));
@ -245,7 +245,7 @@ pub fn monomorphic_fn(ccx: @mut CrateContext,
}
ast_map::node_variant(ref v, enum_item, _) => {
let tvs = ty::enum_variants(ccx.tcx, local_def(enum_item.id));
let this_tv = *tvs.iter().find_(|tv| { tv.id.node == fn_id.node}).get();
let this_tv = *tvs.iter().find_(|tv| { tv.id.node == fn_id.node}).unwrap();
let d = mk_lldecl();
set_inline_hint(d);
match v.node.kind {

4
src/librustc/middle/trans/reflect.rs
View file

@ -303,10 +303,10 @@ impl Reflector {
//
llvm::LLVMGetParam(llfdecl, fcx.arg_pos(0u) as c_uint)
};
let mut bcx = fcx.entry_bcx.get();
let mut bcx = fcx.entry_bcx.unwrap();
let arg = BitCast(bcx, arg, llptrty);
let ret = adt::trans_get_discr(bcx, repr, arg);
Store(bcx, ret, fcx.llretptr.get());
Store(bcx, ret, fcx.llretptr.unwrap());
match fcx.llreturn {
Some(llreturn) => cleanup_and_Br(bcx, bcx, llreturn),
None => bcx = cleanup_block(bcx, Some(bcx.llbb))

2
src/librustc/middle/trans/type_of.rs
View file

@ -239,7 +239,7 @@ pub fn type_of(cx: &mut CrateContext, t: ty::t) -> Type {
ty::ty_estr(ty::vstore_slice(_)) => {
// This means we get a nicer name in the output
cx.tn.find_type("str_slice").get()
cx.tn.find_type("str_slice").unwrap()
}
ty::ty_estr(ty::vstore_fixed(n)) => {

32
src/librustc/middle/ty.rs
View file

@ -33,6 +33,7 @@ use std::hashmap::{HashMap, HashSet};
use std::ops;
use std::ptr::to_unsafe_ptr;
use std::to_bytes;
use std::to_str::ToStr;
use std::u32;
use std::vec;
use syntax::ast::*;
@ -116,7 +117,7 @@ pub struct mt {
mutbl: ast::mutability,
}
#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
#[deriving(Clone, Eq, Encodable, Decodable, IterBytes, ToStr)]
pub enum vstore {
vstore_fixed(uint),
vstore_uniq,
@ -124,7 +125,7 @@ pub enum vstore {
vstore_slice(Region)
}
#[deriving(Clone, Eq, IterBytes, Encodable, Decodable)]
#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr)]
pub enum TraitStore {
BoxTraitStore, // @Trait
UniqTraitStore, // ~Trait
@ -350,6 +351,12 @@ pub struct t_box_ {
enum t_opaque {}
pub type t = *t_opaque;
impl ToStr for t {
fn to_str(&self) -> ~str {
~"*t_opaque"
}
}
pub fn get(t: t) -> t_box {
unsafe {
let t2: t_box = cast::transmute(t);
@ -410,7 +417,7 @@ pub struct param_ty {
}
/// Representation of regions:
#[deriving(Clone, Eq, IterBytes, Encodable, Decodable)]
#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr)]
pub enum Region {
/// Bound regions are found (primarily) in function types. They indicate
/// region parameters that have yet to be replaced with actual regions
@ -456,13 +463,13 @@ impl Region {
}
}
#[deriving(Clone, Eq, IterBytes, Encodable, Decodable)]
#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr)]
pub struct FreeRegion {
scope_id: NodeId,
bound_region: bound_region
}
#[deriving(Clone, Eq, IterBytes, Encodable, Decodable)]
#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr)]
pub enum bound_region {
/// The self region for structs, impls (&T in a type defn or &'self T)
br_self,
@ -620,19 +627,22 @@ pub enum IntVarValue {
UintType(ast::uint_ty),
}
#[deriving(Clone)]
#[deriving(Clone, ToStr)]
pub enum terr_vstore_kind {
terr_vec, terr_str, terr_fn, terr_trait
terr_vec,
terr_str,
terr_fn,
terr_trait
}
#[deriving(Clone)]
#[deriving(Clone, ToStr)]
pub struct expected_found<T> {
expected: T,
found: T
}
// Data structures used in type unification
#[deriving(Clone)]
#[deriving(Clone, ToStr)]
pub enum type_err {
terr_mismatch,
terr_purity_mismatch(expected_found<purity>),
@ -674,7 +684,7 @@ pub struct ParamBounds {
pub type BuiltinBounds = EnumSet<BuiltinBound>;
#[deriving(Clone, Eq, IterBytes)]
#[deriving(Clone, Eq, IterBytes, ToStr)]
pub enum BuiltinBound {
BoundStatic,
BoundSend,
@ -725,7 +735,7 @@ pub enum InferTy {
FloatVar(FloatVid)
}
#[deriving(Clone, Encodable, Decodable, IterBytes)]
#[deriving(Clone, Encodable, Decodable, IterBytes, ToStr)]
pub enum InferRegion {
ReVar(RegionVid),
ReSkolemized(uint, bound_region)

6
src/librustc/middle/typeck/astconv.rs
View file

@ -531,7 +531,7 @@ pub fn ty_of_arg<AC:AstConv,
expected_ty: Option<ty::t>)
-> ty::t {
match a.ty.node {
ast::ty_infer if expected_ty.is_some() => expected_ty.get(),
ast::ty_infer if expected_ty.is_some() => expected_ty.unwrap(),
ast::ty_infer => this.ty_infer(a.ty.span),
_ => ast_ty_to_ty(this, rscope, &a.ty),
}
@ -587,7 +587,7 @@ pub fn ty_of_method<AC:AstConv,RS:region_scope + Clone + 'static>(
};
let (a, b) = ty_of_method_or_bare_fn(
this, rscope, purity, AbiSet::Rust(), lifetimes, Some(&self_info), decl);
(a.get(), b)
(a.unwrap(), b)
}
pub fn ty_of_bare_fn<AC:AstConv,RS:region_scope + Clone + 'static>(
@ -735,7 +735,7 @@ pub fn ty_of_closure<AC:AstConv,RS:region_scope + Clone + 'static>(
let expected_ret_ty = expected_sig.map(|e| e.output);
let output_ty = match decl.output.node {
ast::ty_infer if expected_ret_ty.is_some() => expected_ret_ty.get(),
ast::ty_infer if expected_ret_ty.is_some() => expected_ret_ty.unwrap(),
ast::ty_infer => this.ty_infer(decl.output.span),
_ => ast_ty_to_ty(this, &rb, &decl.output)
};

4
src/librustc/middle/typeck/check/_match.rs
View file

@ -166,7 +166,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::pat, path: &ast::Path,
fcx.write_error(pat.id);
kind_name = "[error]";
arg_types = (*subpats).clone()
.get_or_default(~[])
.unwrap_or_default(~[])
.map(|_| ty::mk_err());
}
}
@ -209,7 +209,7 @@ pub fn check_pat_variant(pcx: &pat_ctxt, pat: @ast::pat, path: &ast::Path,
fcx.write_error(pat.id);
kind_name = "[error]";
arg_types = (*subpats).clone()
.get_or_default(~[])
.unwrap_or_default(~[])
.map(|_| ty::mk_err());
}
}

6
src/librustc/middle/typeck/check/method.rs
View file

@ -854,7 +854,7 @@ impl<'self> LookupContext<'self> {
// like &'a Self. We then perform a
// substitution which will replace Self with
// @Trait.
let t = candidate.method_ty.transformed_self_ty.get();
let t = candidate.method_ty.transformed_self_ty.unwrap();
ty::subst(tcx, &candidate.rcvr_substs, t)
}
_ => {
@ -863,7 +863,7 @@ impl<'self> LookupContext<'self> {
}
}
_ => {
let t = candidate.method_ty.transformed_self_ty.get();
let t = candidate.method_ty.transformed_self_ty.unwrap();
ty::subst(tcx, &candidate.rcvr_substs, t)
}
};
@ -922,7 +922,7 @@ impl<'self> LookupContext<'self> {
tcx, @Nil, Some(transformed_self_ty), &bare_fn_ty.sig,
|br| self.fcx.infcx().next_region_var(
infer::BoundRegionInFnCall(self.expr.span, br)));
let transformed_self_ty = opt_transformed_self_ty.get();
let transformed_self_ty = opt_transformed_self_ty.unwrap();
let fty = ty::mk_bare_fn(tcx, ty::BareFnTy {
sig: fn_sig,
purity: bare_fn_ty.purity,

4
src/librustc/middle/typeck/check/mod.rs
View file

@ -365,7 +365,7 @@ pub fn check_fn(ccx: @mut CrateCtxt,
bound_region: br}));
let opt_self_info =
opt_self_info.map(
|si| SelfInfo {self_ty: opt_self_ty.get(), ..*si});
|si| SelfInfo {self_ty: opt_self_ty.unwrap(), ..*si});
(isr, opt_self_info, fn_sig)
};
@ -2449,7 +2449,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
expected,
|x| Some((*x).clone()));
let inner_ty = match expected_sty {
Some(ty::ty_closure(_)) => expected.get(),
Some(ty::ty_closure(_)) => expected.unwrap(),
_ => match expected {
Some(expected_t) => {
fcx.type_error_message(expr.span, |actual| {

2
src/librustc/middle/typeck/infer/glb.rs
View file

@ -253,7 +253,7 @@ impl Combine for Glb {
if a_r.is_some() && b_r.is_some() && only_new_vars {
// Related to exactly one bound variable from each fn:
return rev_lookup(this, a_isr, a_r.get());
return rev_lookup(this, a_isr, a_r.unwrap());
} else if a_r.is_none() && b_r.is_none() {
// Not related to bound variables from either fn:
return r0;

2
src/librustc/middle/typeck/mod.rs
View file

@ -295,7 +295,7 @@ trait get_and_find_region {
impl get_and_find_region for isr_alist {
pub fn get(&self, br: ty::bound_region) -> ty::Region {
self.find(br).get()
self.find(br).unwrap()
}
pub fn find(&self, br: ty::bound_region) -> Option<ty::Region> {

1
src/librustc/middle/typeck/rscope.rs
View file

@ -18,6 +18,7 @@ use syntax::opt_vec::OptVec;
use syntax::opt_vec;
use syntax::parse::token::special_idents;
#[deriving(ToStr)]
pub struct RegionError {
msg: ~str,
replacement: ty::Region

2
src/librustc/util/enum_set.rs
View file

@ -10,7 +10,7 @@
use std::iterator::Iterator;
#[deriving(Clone, Eq, IterBytes)]
#[deriving(Clone, Eq, IterBytes, ToStr)]
pub struct EnumSet<E> {
// We must maintain the invariant that no bits are set
// for which no variant exists

4
src/librustdoc/attr_pass.rs
View file

@ -68,7 +68,7 @@ fn fold_crate(
doc::CrateDoc {
topmod: doc::ModDoc {
item: doc::ItemDoc {
name: attrs.name.clone().get_or_default(doc.topmod.name_()),
name: attrs.name.clone().unwrap_or_default(doc.topmod.name_()),
.. doc.topmod.item.clone()
},
.. doc.topmod.clone()
@ -135,7 +135,7 @@ fn fold_enum(
let ast_variant =
(*enum_definition.variants.iter().find_(|v| {
to_str(v.node.name) == variant.name
}).get()).clone();
}).unwrap()).clone();
attr_parser::parse_desc(
ast_variant.node.attrs.clone())

30
src/librustdoc/config.rs
View file

@ -142,7 +142,7 @@ fn config_from_opts(
let output_dir = getopts::opt_maybe_str(matches, opt_output_dir());
let output_dir = output_dir.map(|s| Path(*s));
result::Ok(Config {
output_dir: output_dir.get_or_default(config.output_dir.clone()),
output_dir: output_dir.unwrap_or_default(config.output_dir.clone()),
.. config
})
};
@ -273,20 +273,20 @@ mod test {
#[test]
fn should_error_with_no_crates() {
let config = parse_config([~"rustdoc"]);
assert!(config.get_err() == ~"no crates specified");
assert!(config.unwrap_err() == ~"no crates specified");
}
#[test]
fn should_error_with_multiple_crates() {
let config =
parse_config([~"rustdoc", ~"crate1.rc", ~"crate2.rc"]);
assert!(config.get_err() == ~"multiple crates specified");
assert!(config.unwrap_err() == ~"multiple crates specified");
}
#[test]
fn should_set_output_dir_to_cwd_if_not_provided() {
let config = parse_config([~"rustdoc", ~"crate.rc"]);
assert!(config.get().output_dir == Path("."));
assert!(config.unwrap().output_dir == Path("."));
}
#[test]
@ -294,13 +294,13 @@ mod test {
let config = parse_config([
~"rustdoc", ~"crate.rc", ~"--output-dir", ~"snuggles"
]);
assert!(config.get().output_dir == Path("snuggles"));
assert!(config.unwrap().output_dir == Path("snuggles"));
}
#[test]
fn should_set_output_format_to_pandoc_html_if_not_provided() {
let config = parse_config([~"rustdoc", ~"crate.rc"]);
assert!(config.get().output_format == PandocHtml);
assert!(config.unwrap().output_format == PandocHtml);
}
#[test]
@ -308,7 +308,7 @@ mod test {
let config = parse_config([
~"rustdoc", ~"crate.rc", ~"--output-format", ~"markdown"
]);
assert!(config.get().output_format == Markdown);
assert!(config.unwrap().output_format == Markdown);
}
#[test]
@ -316,7 +316,7 @@ mod test {
let config = parse_config([
~"rustdoc", ~"crate.rc", ~"--output-format", ~"html"
]);
assert!(config.get().output_format == PandocHtml);
assert!(config.unwrap().output_format == PandocHtml);
}
#[test]
@ -324,13 +324,13 @@ mod test {
let config = parse_config([
~"rustdoc", ~"crate.rc", ~"--output-format", ~"bogus"
]);
assert!(config.get_err() == ~"unknown output format 'bogus'");
assert!(config.unwrap_err() == ~"unknown output format 'bogus'");
}
#[test]
fn should_set_output_style_to_doc_per_mod_by_default() {
let config = parse_config([~"rustdoc", ~"crate.rc"]);
assert!(config.get().output_style == DocPerMod);
assert!(config.unwrap().output_style == DocPerMod);
}
#[test]
@ -338,7 +338,7 @@ mod test {
let config = parse_config([
~"rustdoc", ~"crate.rc", ~"--output-style", ~"doc-per-crate"
]);
assert!(config.get().output_style == DocPerCrate);
assert!(config.unwrap().output_style == DocPerCrate);
}
#[test]
@ -346,7 +346,7 @@ mod test {
let config = parse_config([
~"rustdoc", ~"crate.rc", ~"--output-style", ~"doc-per-mod"
]);
assert!(config.get().output_style == DocPerMod);
assert!(config.unwrap().output_style == DocPerMod);
}
#[test]
@ -354,7 +354,7 @@ mod test {
let config = parse_config([
~"rustdoc", ~"crate.rc", ~"--output-style", ~"bogus"
]);
assert!(config.get_err() == ~"unknown output style 'bogus'");
assert!(config.unwrap_err() == ~"unknown output style 'bogus'");
}
#[test]
@ -362,12 +362,12 @@ mod test {
let config = parse_config([
~"rustdoc", ~"crate.rc", ~"--pandoc-cmd", ~"panda-bear-doc"
]);
assert!(config.get().pandoc_cmd == Some(~"panda-bear-doc"));
assert!(config.unwrap().pandoc_cmd == Some(~"panda-bear-doc"));
}
#[test]
fn should_set_pandoc_command_when_using_pandoc() {
let config = parse_config([~"rustdoc", ~"crate.rc"]);
assert!(config.get().pandoc_cmd == Some(~"pandoc"));
assert!(config.unwrap().pandoc_cmd == Some(~"pandoc"));
}
}

2
src/librustdoc/desc_to_brief_pass.rs
View file

@ -83,7 +83,7 @@ pub fn extract(desc: Option<~str>) -> Option<~str> {
return None
}
parse_desc(desc.clone().get())
parse_desc(desc.clone().unwrap())
}
fn parse_desc(desc: ~str) -> Option<~str> {

2
src/librustdoc/doc.rs
View file

@ -176,7 +176,7 @@ impl Doc {
doc::CratePage(doc) => Some(doc),
_ => None
}
}).get()
}).unwrap()
}
pub fn cratemod(&self) -> ModDoc {

12
src/librustdoc/markdown_index_pass.rs
View file

@ -223,13 +223,13 @@ mod test {
config::DocPerCrate,
~"mod a { } fn b() { }"
);
assert!(doc.cratemod().index.get().entries[0] == doc::IndexEntry {
assert!(doc.cratemod().index.unwrap().entries[0] == doc::IndexEntry {
kind: ~"Module",
name: ~"a",
brief: None,
link: ~"#module-a"
});
assert!(doc.cratemod().index.get().entries[1] == doc::IndexEntry {
assert!(doc.cratemod().index.unwrap().entries[1] == doc::IndexEntry {
kind: ~"Function",
name: ~"b",
brief: None,
@ -243,13 +243,13 @@ mod test {
config::DocPerMod,
~"mod a { } fn b() { }"
);
assert_eq!(doc.cratemod().index.get().entries[0], doc::IndexEntry {
assert_eq!(doc.cratemod().index.unwrap().entries[0], doc::IndexEntry {
kind: ~"Module",
name: ~"a",
brief: None,
link: ~"a.html"
});
assert_eq!(doc.cratemod().index.get().entries[1], doc::IndexEntry {
assert_eq!(doc.cratemod().index.unwrap().entries[1], doc::IndexEntry {
kind: ~"Function",
name: ~"b",
brief: None,
@ -263,7 +263,7 @@ mod test {
config::DocPerMod,
~"#[doc = \"test\"] mod a { }"
);
assert_eq!(doc.cratemod().index.get().entries[0].brief, Some(~"test"));
assert_eq!(doc.cratemod().index.unwrap().entries[0].brief, Some(~"test"));
}
#[test]
@ -273,7 +273,7 @@ mod test {
~"extern { fn b(); }"
);
// hidden __std_macros module at the start.
assert_eq!(doc.cratemod().nmods()[0].index.get().entries[0],
assert_eq!(doc.cratemod().nmods()[0].index.unwrap().entries[0],
doc::IndexEntry {
kind: ~"Function",
name: ~"b",

8
src/librustdoc/markdown_pass.rs
View file

@ -617,10 +617,10 @@ mod test {
fn d() { }"
);
let idx_a = markdown.find_str("# Module `a`").get();
let idx_b = markdown.find_str("## Function `b`").get();
let idx_c = markdown.find_str("# Module `c`").get();
let idx_d = markdown.find_str("## Function `d`").get();
let idx_a = markdown.find_str("# Module `a`").unwrap();
let idx_b = markdown.find_str("## Function `b`").unwrap();
let idx_c = markdown.find_str("# Module `c`").unwrap();
let idx_d = markdown.find_str("## Function `d`").unwrap();
assert!(idx_b < idx_d);
assert!(idx_d < idx_a);

4
src/librustdoc/sectionalize_pass.rs
View file

@ -218,8 +218,8 @@ mod test {
Body\"]\
mod a {
}");
assert!(!doc.cratemod().mods()[0].desc().get().contains("Header"));
assert!(!doc.cratemod().mods()[0].desc().get().contains("Body"));
assert!(!doc.cratemod().mods()[0].desc().unwrap().contains("Header"));
assert!(!doc.cratemod().mods()[0].desc().unwrap().contains("Body"));
}
#[test]

6
src/librustdoc/tystr_pass.rs
View file

@ -135,7 +135,7 @@ fn fold_enum(
let ast_variant =
(*do enum_definition.variants.iter().find_ |v| {
to_str(v.node.name) == variant.name
}.get()).clone();
}.unwrap()).clone();
pprust::variant_to_str(
&ast_variant, extract::interner())
@ -443,7 +443,7 @@ mod test {
#[test]
fn should_add_struct_defs() {
let doc = mk_doc(~"struct S { field: () }");
assert!(doc.cratemod().structs()[0].sig.get().contains(
assert!(doc.cratemod().structs()[0].sig.unwrap().contains(
"struct S {"));
}
@ -451,6 +451,6 @@ mod test {
fn should_not_serialize_struct_attrs() {
// All we care about are the fields
let doc = mk_doc(~"#[wut] struct S { field: () }");
assert!(!doc.cratemod().structs()[0].sig.get().contains("wut"));
assert!(!doc.cratemod().structs()[0].sig.unwrap().contains("wut"));
}
}

10
src/librusti/rusti.rs
View file

@ -322,14 +322,14 @@ fn compile_crate(src_filename: ~str, binary: ~str) -> Option<bool> {
// instead we guess which file is the library by matching
// the prefix and suffix of out_filename to files in the
// directory.
let file_str = file.filename().get();
file_str.starts_with(outputs.out_filename.filestem().get())
&& file_str.ends_with(outputs.out_filename.filetype().get())
let file_str = file.filename().unwrap();
file_str.starts_with(outputs.out_filename.filestem().unwrap())
&& file_str.ends_with(outputs.out_filename.filetype().unwrap())
};
match maybe_lib_path {
Some(lib_path) => {
let (src_mtime, _) = src_path.get_mtime().get();
let (lib_mtime, _) = lib_path.get_mtime().get();
let (src_mtime, _) = src_path.get_mtime().unwrap();
let (lib_mtime, _) = lib_path.get_mtime().unwrap();
if lib_mtime >= src_mtime {
should_compile = false;
}

4
src/librustpkg/rustpkg.rs
View file

@ -102,7 +102,7 @@ impl<'self> PkgScript<'self> {
debug!("pkgscript parse: %?", os::self_exe_path());
let options = @session::options {
binary: binary,
maybe_sysroot: Some(@os::self_exe_path().get().pop()),
maybe_sysroot: Some(@os::self_exe_path().unwrap().pop()),
crate_type: session::bin_crate,
.. (*session::basic_options()).clone()
};
@ -535,7 +535,7 @@ pub fn main() {
* in is the working directory.
*/
pub fn work_dir() -> Path {
os::self_exe_path().get()
os::self_exe_path().unwrap()
}
/**

2
src/librustpkg/util.rs
View file

@ -195,7 +195,7 @@ pub fn compile_input(ctxt: &Ctx,
}
+ flags
+ cfgs.flat_map(|c| { ~[~"--cfg", (*c).clone()] }),
driver::optgroups()).get();
driver::optgroups()).unwrap();
let options = @session::options {
crate_type: crate_type,
optimize: if opt { session::Aggressive } else { session::No },

6
src/libstd/at_vec.rs
View file

@ -78,10 +78,8 @@ pub fn build<A>(builder: &fn(push: &fn(v: A))) -> @[A] {
* onto the vector being constructed.
*/
#[inline]
pub fn build_sized_opt<A>(size: Option<uint>,
builder: &fn(push: &fn(v: A)))
-> @[A] {
build_sized(size.get_or_default(4), builder)
pub fn build_sized_opt<A>(size: Option<uint>, builder: &fn(push: &fn(v: A))) -> @[A] {
build_sized(size.unwrap_or_default(4), builder)
}
// Appending

384
src/libstd/either.rs
View file

@ -23,29 +23,102 @@ use str::StrSlice;
use vec;
use vec::{OwnedVector, ImmutableVector};
/// The either type
/// `Either` is a type that represents one of two alternatives
#[deriving(Clone, Eq)]
pub enum Either<T, U> {
Left(T),
Right(U)
pub enum Either<L, R> {
Left(L),
Right(R)
}
/// Applies a function based on the given either value
///
/// If `value` is left(T) then `f_left` is applied to its contents, if
/// `value` is right(U) then `f_right` is applied to its contents, and the
/// result is returned.
#[inline]
pub fn either<T, U, V>(f_left: &fn(&T) -> V,
f_right: &fn(&U) -> V, value: &Either<T, U>) -> V {
match *value {
Left(ref l) => f_left(l),
Right(ref r) => f_right(r)
impl<L, R> Either<L, R> {
/// Applies a function based on the given either value
///
/// If `value` is `Left(L)` then `f_left` is applied to its contents, if
/// `value` is `Right(R)` then `f_right` is applied to its contents, and the
/// result is returned.
#[inline]
pub fn either<T>(&self, f_left: &fn(&L) -> T, f_right: &fn(&R) -> T) -> T {
match *self {
Left(ref l) => f_left(l),
Right(ref r) => f_right(r)
}
}
/// Flips between left and right of a given `Either`
#[inline]
pub fn flip(self) -> Either<R, L> {
match self {
Right(r) => Left(r),
Left(l) => Right(l)
}
}
/// Converts a `Either` to a `Result`
///
/// Converts an `Either` type to a `Result` type, making the "right" choice
/// an `Ok` result, and the "left" choice a `Err`
#[inline]
pub fn to_result(self) -> Result<R, L> {
match self {
Right(r) => result::Ok(r),
Left(l) => result::Err(l)
}
}
/// Checks whether the given value is a `Left`
#[inline]
pub fn is_left(&self) -> bool {
match *self {
Left(_) => true,
_ => false
}
}
/// Checks whether the given value is a `Right`
#[inline]
pub fn is_right(&self) -> bool {
match *self {
Right(_) => true,
_ => false
}
}
/// Retrieves the value from a `Left`.
/// Fails with a specified reason if the `Either` is `Right`.
#[inline]
pub fn expect_left(self, reason: &str) -> L {
match self {
Left(x) => x,
Right(_) => fail!(reason.to_owned())
}
}
/// Retrieves the value from a `Left`. Fails if the `Either` is `Right`.
#[inline]
pub fn unwrap_left(self) -> L {
self.expect_left("called Either::unwrap_left()` on `Right` value")
}
/// Retrieves the value from a `Right`.
/// Fails with a specified reason if the `Either` is `Left`.
#[inline]
pub fn expect_right(self, reason: &str) -> R {
match self {
Right(x) => x,
Left(_) => fail!(reason.to_owned())
}
}
/// Retrieves the value from a `Right`. Fails if the `Either` is `Left`.
#[inline]
pub fn unwrap_right(self) -> R {
self.expect_right("called Either::unwrap_right()` on `Left` value")
}
}
// FIXME: #8228 Replaceable by an external iterator?
/// Extracts from a vector of either all the left values
pub fn lefts<T:Clone,U>(eithers: &[Either<T, U>]) -> ~[T] {
pub fn lefts<L: Clone, R>(eithers: &[Either<L, R>]) -> ~[L] {
do vec::build_sized(eithers.len()) |push| {
for elt in eithers.iter() {
match *elt {
@ -56,8 +129,9 @@ pub fn lefts<T:Clone,U>(eithers: &[Either<T, U>]) -> ~[T] {
}
}
// FIXME: #8228 Replaceable by an external iterator?
/// Extracts from a vector of either all the right values
pub fn rights<T, U: Clone>(eithers: &[Either<T, U>]) -> ~[U] {
pub fn rights<L, R: Clone>(eithers: &[Either<L, R>]) -> ~[R] {
do vec::build_sized(eithers.len()) |push| {
for elt in eithers.iter() {
match *elt {
@ -68,13 +142,14 @@ pub fn rights<T, U: Clone>(eithers: &[Either<T, U>]) -> ~[U] {
}
}
// FIXME: #8228 Replaceable by an external iterator?
/// Extracts from a vector of either all the left values and right values
///
/// Returns a structure containing a vector of left values and a vector of
/// right values.
pub fn partition<T, U>(eithers: ~[Either<T, U>]) -> (~[T], ~[U]) {
let mut lefts: ~[T] = ~[];
let mut rights: ~[U] = ~[];
pub fn partition<L, R>(eithers: ~[Either<L, R>]) -> (~[L], ~[R]) {
let mut lefts: ~[L] = ~[];
let mut rights: ~[R] = ~[];
for elt in eithers.consume_iter() {
match elt {
Left(l) => lefts.push(l),
@ -84,196 +159,101 @@ pub fn partition<T, U>(eithers: ~[Either<T, U>]) -> (~[T], ~[U]) {
return (lefts, rights);
}
/// Flips between left and right of a given either
#[inline]
pub fn flip<T, U>(eith: Either<T, U>) -> Either<U, T> {
match eith {
Right(r) => Left(r),
Left(l) => Right(l)
}
}
#[cfg(test)]
mod tests {
use super::*;
/// Converts either::t to a result::t
///
/// Converts an `either` type to a `result` type, making the "right" choice
/// an ok result, and the "left" choice a fail
#[inline]
pub fn to_result<T, U>(eith: Either<T, U>) -> Result<U, T> {
match eith {
Right(r) => result::Ok(r),
Left(l) => result::Err(l)
}
}
/// Checks whether the given value is a left
#[inline]
pub fn is_left<T, U>(eith: &Either<T, U>) -> bool {
match *eith {
Left(_) => true,
_ => false
}
}
/// Checks whether the given value is a right
#[inline]
pub fn is_right<T, U>(eith: &Either<T, U>) -> bool {
match *eith {
Right(_) => true,
_ => false
}
}
/// Retrieves the value in the left branch.
/// Fails with a specified reason if the either is Right.
#[inline]
pub fn expect_left<T,U>(eith: Either<T,U>, reason: &str) -> T {
match eith {
Left(x) => x,
Right(_) => fail!(reason.to_owned())
}
}
/// Retrieves the value in the left branch. Fails if the either is Right.
#[inline]
pub fn unwrap_left<T,U>(eith: Either<T,U>) -> T {
expect_left(eith, "either::unwrap_left Right")
}
/// Retrieves the value in the right branch.
/// Fails with a specified reason if the either is Left.
#[inline]
pub fn expect_right<T,U>(eith: Either<T,U>, reason: &str) -> U {
match eith {
Right(x) => x,
Left(_) => fail!(reason.to_owned())
}
}
/// Retrieves the value in the right branch. Fails if the either is Left.
pub fn unwrap_right<T,U>(eith: Either<T,U>) -> U {
expect_right(eith, "either::unwrap_right Left")
}
impl<T, U> Either<T, U> {
#[inline]
pub fn either<V>(&self, f_left: &fn(&T) -> V, f_right: &fn(&U) -> V) -> V {
either(f_left, f_right, self)
#[test]
fn test_either_left() {
let val = Left(10);
fn f_left(x: &int) -> bool { *x == 10 }
fn f_right(_x: &uint) -> bool { false }
assert!(val.either(f_left, f_right));
}
#[inline]
pub fn flip(self) -> Either<U, T> { flip(self) }
#[test]
fn test_either_right() {
let val = Right(10u);
fn f_left(_x: &int) -> bool { false }
fn f_right(x: &uint) -> bool { *x == 10u }
assert!(val.either(f_left, f_right));
}
#[inline]
pub fn to_result(self) -> Result<U, T> { to_result(self) }
#[test]
fn test_lefts() {
let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)];
let result = lefts(input);
assert_eq!(result, ~[10, 12, 14]);
}
#[inline]
pub fn is_left(&self) -> bool { is_left(self) }
#[test]
fn test_lefts_none() {
let input: ~[Either<int, int>] = ~[Right(10), Right(10)];
let result = lefts(input);
assert_eq!(result.len(), 0u);
}
#[inline]
pub fn is_right(&self) -> bool { is_right(self) }
#[test]
fn test_lefts_empty() {
let input: ~[Either<int, int>] = ~[];
let result = lefts(input);
assert_eq!(result.len(), 0u);
}
#[inline]
pub fn expect_left(self, reason: &str) -> T { expect_left(self, reason) }
#[test]
fn test_rights() {
let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)];
let result = rights(input);
assert_eq!(result, ~[11, 13]);
}
#[inline]
pub fn unwrap_left(self) -> T { unwrap_left(self) }
#[test]
fn test_rights_none() {
let input: ~[Either<int, int>] = ~[Left(10), Left(10)];
let result = rights(input);
assert_eq!(result.len(), 0u);
}
#[inline]
pub fn expect_right(self, reason: &str) -> U { expect_right(self, reason) }
#[test]
fn test_rights_empty() {
let input: ~[Either<int, int>] = ~[];
let result = rights(input);
assert_eq!(result.len(), 0u);
}
#[test]
fn test_partition() {
let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)];
let (lefts, rights) = partition(input);
assert_eq!(lefts[0], 10);
assert_eq!(lefts[1], 12);
assert_eq!(lefts[2], 14);
assert_eq!(rights[0], 11);
assert_eq!(rights[1], 13);
}
#[test]
fn test_partition_no_lefts() {
let input: ~[Either<int, int>] = ~[Right(10), Right(11)];
let (lefts, rights) = partition(input);
assert_eq!(lefts.len(), 0u);
assert_eq!(rights.len(), 2u);
}
#[test]
fn test_partition_no_rights() {
let input: ~[Either<int, int>] = ~[Left(10), Left(11)];
let (lefts, rights) = partition(input);
assert_eq!(lefts.len(), 2u);
assert_eq!(rights.len(), 0u);
}
#[test]
fn test_partition_empty() {
let input: ~[Either<int, int>] = ~[];
let (lefts, rights) = partition(input);
assert_eq!(lefts.len(), 0u);
assert_eq!(rights.len(), 0u);
}
#[inline]
pub fn unwrap_right(self) -> U { unwrap_right(self) }
}
#[test]
fn test_either_left() {
let val = Left(10);
fn f_left(x: &int) -> bool { *x == 10 }
fn f_right(_x: &uint) -> bool { false }
assert!((either(f_left, f_right, &val)));
}
#[test]
fn test_either_right() {
let val = Right(10u);
fn f_left(_x: &int) -> bool { false }
fn f_right(x: &uint) -> bool { *x == 10u }
assert!((either(f_left, f_right, &val)));
}
#[test]
fn test_lefts() {
let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)];
let result = lefts(input);
assert_eq!(result, ~[10, 12, 14]);
}
#[test]
fn test_lefts_none() {
let input: ~[Either<int, int>] = ~[Right(10), Right(10)];
let result = lefts(input);
assert_eq!(result.len(), 0u);
}
#[test]
fn test_lefts_empty() {
let input: ~[Either<int, int>] = ~[];
let result = lefts(input);
assert_eq!(result.len(), 0u);
}
#[test]
fn test_rights() {
let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)];
let result = rights(input);
assert_eq!(result, ~[11, 13]);
}
#[test]
fn test_rights_none() {
let input: ~[Either<int, int>] = ~[Left(10), Left(10)];
let result = rights(input);
assert_eq!(result.len(), 0u);
}
#[test]
fn test_rights_empty() {
let input: ~[Either<int, int>] = ~[];
let result = rights(input);
assert_eq!(result.len(), 0u);
}
#[test]
fn test_partition() {
let input = ~[Left(10), Right(11), Left(12), Right(13), Left(14)];
let (lefts, rights) = partition(input);
assert_eq!(lefts[0], 10);
assert_eq!(lefts[1], 12);
assert_eq!(lefts[2], 14);
assert_eq!(rights[0], 11);
assert_eq!(rights[1], 13);
}
#[test]
fn test_partition_no_lefts() {
let input: ~[Either<int, int>] = ~[Right(10), Right(11)];
let (lefts, rights) = partition(input);
assert_eq!(lefts.len(), 0u);
assert_eq!(rights.len(), 2u);
}
#[test]
fn test_partition_no_rights() {
let input: ~[Either<int, int>] = ~[Left(10), Left(11)];
let (lefts, rights) = partition(input);
assert_eq!(lefts.len(), 2u);
assert_eq!(rights.len(), 0u);
}
#[test]
fn test_partition_empty() {
let input: ~[Either<int, int>] = ~[];
let (lefts, rights) = partition(input);
assert_eq!(lefts.len(), 0u);
assert_eq!(rights.len(), 0u);
}

14
src/libstd/local_data.rs
View file

@ -112,14 +112,14 @@ fn test_tls_multitask() {
// TLS shouldn't carry over.
assert!(get(my_key, |k| k.map(|&k| *k)).is_none());
set(my_key, @~"child data");
assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) ==
assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) ==
~"child data");
// should be cleaned up for us
}
// Must work multiple times
assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) == ~"parent data");
assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) == ~"parent data");
assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) == ~"parent data");
assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) == ~"parent data");
assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) == ~"parent data");
assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) == ~"parent data");
}
#[test]
@ -127,14 +127,14 @@ fn test_tls_overwrite() {
static my_key: Key<@~str> = &Key;
set(my_key, @~"first data");
set(my_key, @~"next data"); // Shouldn't leak.
assert!(*(get(my_key, |k| k.map(|&k| *k)).get()) == ~"next data");
assert!(*(get(my_key, |k| k.map(|&k| *k)).unwrap()) == ~"next data");
}
#[test]
fn test_tls_pop() {
static my_key: Key<@~str> = &Key;
set(my_key, @~"weasel");
assert!(*(pop(my_key).get()) == ~"weasel");
assert!(*(pop(my_key).unwrap()) == ~"weasel");
// Pop must remove the data from the map.
assert!(pop(my_key).is_none());
}
@ -155,7 +155,7 @@ fn test_tls_modify() {
None => fail!("missing value")
}
});
assert!(*(pop(my_key).get()) == ~"next data");
assert!(*(pop(my_key).unwrap()) == ~"next data");
}
#[test]

2
src/libstd/num/strconv.rs
View file

@ -726,4 +726,4 @@ mod bench {
float::to_str(rng.gen());
}
}
}
}

214
src/libstd/option.rs
View file

@ -47,7 +47,8 @@ use ops::Add;
use util;
use num::Zero;
use iterator::Iterator;
use str::StrSlice;
use str::{StrSlice, OwnedStr};
use to_str::ToStr;
use clone::DeepClone;
/// The option type
@ -85,18 +86,33 @@ impl<T:Ord> Ord for Option<T> {
}
}
impl<T:Clone+Add<T,T>> Add<Option<T>, Option<T>> for Option<T> {
impl<T: Add<T, T>> Add<Option<T>, Option<T>> for Option<T> {
#[inline]
fn add(&self, other: &Option<T>) -> Option<T> {
match (&*self, &*other) {
(&None, &None) => None,
(_, &None) => (*self).clone(),
(&None, _) => (*other).clone(),
(_, &None) => None,
(&None, _) => None,
(&Some(ref lhs), &Some(ref rhs)) => Some(*lhs + *rhs)
}
}
}
// FIXME: #8242 implementing manually because deriving doesn't work for some reason
impl<T: ToStr> ToStr for Option<T> {
fn to_str(&self) -> ~str {
match *self {
Some(ref x) => {
let mut s = ~"Some(";
s.push_str(x.to_str());
s.push_str(")");
s
}
None => ~"None"
}
}
}
impl<T> Option<T> {
/// Return an iterator over the possibly contained value
#[inline]
@ -148,8 +164,7 @@ impl<T> Option<T> {
/// Update an optional value by optionally running its content by reference
/// through a function that returns an option.
#[inline]
pub fn chain_ref<'a, U>(&'a self, f: &fn(x: &'a T) -> Option<U>)
-> Option<U> {
pub fn chain_ref<'a, U>(&'a self, f: &fn(x: &'a T) -> Option<U>) -> Option<U> {
match *self {
Some(ref x) => f(x),
None => None
@ -159,8 +174,7 @@ impl<T> Option<T> {
/// Update an optional value by optionally running its content by mut reference
/// through a function that returns an option.
#[inline]
pub fn chain_mut_ref<'a, U>(&'a mut self, f: &fn(x: &'a mut T) -> Option<U>)
-> Option<U> {
pub fn chain_mut_ref<'a, U>(&'a mut self, f: &fn(x: &'a mut T) -> Option<U>) -> Option<U> {
match *self {
Some(ref mut x) => f(x),
None => None
@ -256,130 +270,103 @@ impl<T> Option<T> {
}
}
/**
Gets an immutable reference to the value inside an option.
# Failure
Fails if the value equals `None`
# Safety note
In general, because this function may fail, its use is discouraged
(calling `get` on `None` is akin to dereferencing a null pointer).
Instead, prefer to use pattern matching and handle the `None`
case explicitly.
*/
/// Gets an immutable reference to the value inside an option.
///
/// # Failure
///
/// Fails if the value equals `None`
///
/// # Safety note
///
/// In general, because this function may fail, its use is discouraged
/// (calling `get` on `None` is akin to dereferencing a null pointer).
/// Instead, prefer to use pattern matching and handle the `None`
/// case explicitly.
#[inline]
pub fn get_ref<'a>(&'a self) -> &'a T {
match *self {
Some(ref x) => x,
None => fail!("option::get_ref `None`"),
Some(ref x) => x,
None => fail!("called `Option::get_ref()` on a `None` value"),
}
}
/**
Gets a mutable reference to the value inside an option.
# Failure
Fails if the value equals `None`
# Safety note
In general, because this function may fail, its use is discouraged
(calling `get` on `None` is akin to dereferencing a null pointer).
Instead, prefer to use pattern matching and handle the `None`
case explicitly.
*/
/// Gets a mutable reference to the value inside an option.
///
/// # Failure
///
/// Fails if the value equals `None`
///
/// # Safety note
///
/// In general, because this function may fail, its use is discouraged
/// (calling `get` on `None` is akin to dereferencing a null pointer).
/// Instead, prefer to use pattern matching and handle the `None`
/// case explicitly.
#[inline]
pub fn get_mut_ref<'a>(&'a mut self) -> &'a mut T {
match *self {
Some(ref mut x) => x,
None => fail!("option::get_mut_ref `None`"),
Some(ref mut x) => x,
None => fail!("called `Option::get_mut_ref()` on a `None` value"),
}
}
/// Moves a value out of an option type and returns it.
///
/// Useful primarily for getting strings, vectors and unique pointers out
/// of option types without copying them.
///
/// # Failure
///
/// Fails if the value equals `None`.
///
/// # Safety note
///
/// In general, because this function may fail, its use is discouraged.
/// Instead, prefer to use pattern matching and handle the `None`
/// case explicitly.
#[inline]
pub fn unwrap(self) -> T {
/*!
Moves a value out of an option type and returns it.
Useful primarily for getting strings, vectors and unique pointers out
of option types without copying them.
# Failure
Fails if the value equals `None`.
# Safety note
In general, because this function may fail, its use is discouraged.
Instead, prefer to use pattern matching and handle the `None`
case explicitly.
*/
match self {
Some(x) => x,
None => fail!("option::unwrap `None`"),
Some(x) => x,
None => fail!("called `Option::unwrap()` on a `None` value"),
}
}
/**
* The option dance. Moves a value out of an option type and returns it,
* replacing the original with `None`.
*
* # Failure
*
* Fails if the value equals `None`.
*/
/// The option dance. Moves a value out of an option type and returns it,
/// replacing the original with `None`.
///
/// # Failure
///
/// Fails if the value equals `None`.
#[inline]
pub fn take_unwrap(&mut self) -> T {
if self.is_none() { fail!("option::take_unwrap `None`") }
if self.is_none() {
fail!("called `Option::take_unwrap()` on a `None` value")
}
self.take().unwrap()
}
/**
* Gets the value out of an option, printing a specified message on
* failure
*
* # Failure
*
* Fails if the value equals `None`
*/
/// Gets the value out of an option, printing a specified message on
/// failure
///
/// # Failure
///
/// Fails if the value equals `None`
#[inline]
pub fn expect(self, reason: &str) -> T {
match self {
Some(val) => val,
None => fail!(reason.to_owned()),
}
}
/**
Gets the value out of an option
# Failure
Fails if the value equals `None`
# Safety note
In general, because this function may fail, its use is discouraged
(calling `get` on `None` is akin to dereferencing a null pointer).
Instead, prefer to use pattern matching and handle the `None`
case explicitly.
*/
#[inline]
pub fn get(self) -> T {
match self {
Some(x) => return x,
None => fail!("option::get `None`")
Some(val) => val,
None => fail!(reason.to_owned()),
}
}
/// Returns the contained value or a default
#[inline]
pub fn get_or_default(self, def: T) -> T {
match self { Some(x) => x, None => def }
pub fn unwrap_or_default(self, def: T) -> T {
match self {
Some(x) => x,
None => def
}
}
/// Applies a function zero or more times until the result is `None`.
@ -395,12 +382,21 @@ impl<T> Option<T> {
impl<T:Zero> Option<T> {
/// Returns the contained value or zero (for this type)
#[inline]
pub fn get_or_zero(self) -> T {
pub fn unwrap_or_zero(self) -> T {
match self {
Some(x) => x,
None => Zero::zero()
}
}
/// Returns self or `Some(zero)` (for this type)
#[inline]
pub fn or_zero(self) -> Option<T> {
match self {
None => Some(Zero::zero()),
x => x
}
}
}
impl<T> Zero for Option<T> {
@ -450,7 +446,7 @@ mod tests {
use util;
#[test]
fn test_unwrap_ptr() {
fn test_get_ptr() {
unsafe {
let x = ~0;
let addr_x: *int = ::cast::transmute(&*x);
@ -462,7 +458,7 @@ mod tests {
}
#[test]
fn test_unwrap_str() {
fn test_get_str() {
let x = ~"test";
let addr_x = x.as_imm_buf(|buf, _len| buf);
let opt = Some(x);
@ -472,7 +468,7 @@ mod tests {
}
#[test]
fn test_unwrap_resource() {
fn test_get_resource() {
struct R {
i: @mut int,
}
@ -530,18 +526,18 @@ mod tests {
}
#[test]
fn test_get_or_zero() {
fn test_unwrap_or_zero() {
let some_stuff = Some(42);
assert_eq!(some_stuff.get_or_zero(), 42);
assert_eq!(some_stuff.unwrap_or_zero(), 42);
let no_stuff: Option<int> = None;
assert_eq!(no_stuff.get_or_zero(), 0);
assert_eq!(no_stuff.unwrap_or_zero(), 0);
}
#[test]
fn test_filtered() {
let some_stuff = Some(42);
let modified_stuff = some_stuff.filtered(|&x| {x < 10});
assert_eq!(some_stuff.get(), 42);
assert_eq!(some_stuff.unwrap(), 42);
assert!(modified_stuff.is_none());
}

6
src/libstd/os.rs
View file

@ -571,7 +571,7 @@ pub fn tmpdir() -> Path {
#[cfg(unix)]
fn lookup() -> Path {
getenv_nonempty("TMPDIR").get_or_default(Path("/tmp"))
getenv_nonempty("TMPDIR").unwrap_or_default(Path("/tmp"))
}
#[cfg(windows)]
@ -579,7 +579,7 @@ pub fn tmpdir() -> Path {
getenv_nonempty("TMP").or(
getenv_nonempty("TEMP").or(
getenv_nonempty("USERPROFILE").or(
getenv_nonempty("WINDIR")))).get_or_default(Path("C:\\Windows"))
getenv_nonempty("WINDIR")))).unwrap_or_default(Path("C:\\Windows"))
}
}
@ -1782,7 +1782,7 @@ mod tests {
fn test_self_exe_path() {
let path = os::self_exe_path();
assert!(path.is_some());
let path = path.get();
let path = path.unwrap();
debug!(path.clone());
// Hard to test this function

4
src/libstd/rand.rs
View file

@ -533,7 +533,7 @@ impl<R: Rng> RngUtil for R {
/// Choose an item randomly, failing if values is empty
fn choose<T:Clone>(&mut self, values: &[T]) -> T {
self.choose_option(values).get()
self.choose_option(values).unwrap()
}
/// Choose Some(item) randomly, returning None if values is empty
@ -549,7 +549,7 @@ impl<R: Rng> RngUtil for R {
* the weights is 0
*/
fn choose_weighted<T:Clone>(&mut self, v: &[Weighted<T>]) -> T {
self.choose_weighted_option(v).get()
self.choose_weighted_option(v).unwrap()
}
/**

329
src/libstd/result.rs
View file

@ -20,23 +20,27 @@ use option::{None, Option, Some};
use vec;
use vec::{OwnedVector, ImmutableVector};
use container::Container;
use to_str::ToStr;
use str::StrSlice;
/// The result type
/// `Result` is a type that represents either success (`Ok`) or failure (`Err`).
///
/// In order to provide informative error messages, `E` is reqired to implement `ToStr`.
/// It is further recommended for `E` to be a descriptive error type, eg a `enum` for
/// all possible errors cases.
#[deriving(Clone, Eq)]
pub enum Result<T, U> {
pub enum Result<T, E> {
/// Contains the successful result value
Ok(T),
/// Contains the error value
Err(U)
Err(E)
}
impl<T, E> Result<T, E> {
/**
* Convert to the `either` type
*
* `Ok` result variants are converted to `either::Right` variants, `Err`
* result variants are converted to `either::Left`.
*/
impl<T, E: ToStr> Result<T, E> {
/// Convert to the `either` type
///
/// `Ok` result variants are converted to `either::Right` variants, `Err`
/// result variants are converted to `either::Left`.
#[inline]
pub fn to_either(self)-> either::Either<E, T>{
match self {
@ -45,18 +49,16 @@ impl<T, E> Result<T, E> {
}
}
/**
* Get a reference to the value out of a successful result
*
* # Failure
*
* If the result is an error
*/
/// Get a reference to the value out of a successful result
///
/// # Failure
///
/// If the result is an error
#[inline]
pub fn get_ref<'a>(&'a self) -> &'a T {
match *self {
Ok(ref t) => t,
Err(ref e) => fail!("get_ref called on `Err` result: %?", *e),
Err(ref e) => fail!("called `Result::get_ref()` on `Err` value: %s", e.to_str()),
}
}
@ -75,20 +77,18 @@ impl<T, E> Result<T, E> {
!self.is_ok()
}
/**
* Call a method based on a previous result
*
* If `self` is `Ok` then the value is extracted and passed to `op`
* whereupon `op`s result is returned. if `self` is `Err` then it is
* immediately returned. This function can be used to compose the results
* of two functions.
*
* Example:
*
* do read_file(file).iter |buf| {
* print_buf(buf)
* }
*/
/// Call a method based on a previous result
///
/// If `self` is `Ok` then the value is extracted and passed to `op`
/// whereupon `op`s result is returned. if `self` is `Err` then it is
/// immediately returned. This function can be used to compose the results
/// of two functions.
///
/// Example:
///
/// do read_file(file).iter |buf| {
/// print_buf(buf)
/// }
#[inline]
pub fn iter(&self, f: &fn(&T)) {
match *self {
@ -97,14 +97,12 @@ impl<T, E> Result<T, E> {
}
}
/**
* Call a method based on a previous result
*
* If `self` is `Err` then the value is extracted and passed to `op`
* whereupon `op`s result is returned. if `self` is `Ok` then it is
* immediately returned. This function can be used to pass through a
* successful result while handling an error.
*/
/// Call a method based on a previous result
///
/// If `self` is `Err` then the value is extracted and passed to `op`
/// whereupon `op`s result is returned. if `self` is `Ok` then it is
/// immediately returned. This function can be used to pass through a
/// successful result while handling an error.
#[inline]
pub fn iter_err(&self, f: &fn(&E)) {
match *self {
@ -113,38 +111,56 @@ impl<T, E> Result<T, E> {
}
}
/// Unwraps a result, assuming it is an `Ok(T)`
/// Unwraps a result, yielding the content of an `Ok`.
/// Fails if the value is a `Err` with an error message derived
/// from `E`'s `ToStr` implementation.
#[inline]
pub fn unwrap(self) -> T {
match self {
Ok(t) => t,
Err(_) => fail!("unwrap called on an `Err` result"),
Err(e) => fail!("called `Result::unwrap()` on `Err` value: %s", e.to_str()),
}
}
/// Unwraps a result, assuming it is an `Err(U)`
/// Unwraps a result, yielding the content of an `Err`.
/// Fails if the value is a `Ok`.
#[inline]
pub fn unwrap_err(self) -> E {
self.expect_err("called `Result::unwrap_err()` on `Ok` value")
}
/// Unwraps a result, yielding the content of an `Ok`.
/// Fails if the value is a `Err` with a custom failure message.
#[inline]
pub fn expect(self, reason: &str) -> T {
match self {
Err(e) => e,
Ok(_) => fail!("unwrap called on an `Ok` result"),
Ok(t) => t,
Err(_) => fail!(reason.to_owned()),
}
}
/**
* Call a method based on a previous result
*
* If `self` is `Ok` then the value is extracted and passed to `op`
* whereupon `op`s result is returned. if `self` is `Err` then it is
* immediately returned. This function can be used to compose the results
* of two functions.
*
* Example:
*
* let res = do read_file(file) |buf| {
* Ok(parse_bytes(buf))
* };
*/
/// Unwraps a result, yielding the content of an `Err`
/// Fails if the value is a `Ok` with a custom failure message.
#[inline]
pub fn expect_err(self, reason: &str) -> E {
match self {
Err(e) => e,
Ok(_) => fail!(reason.to_owned()),
}
}
/// Call a method based on a previous result
///
/// If `self` is `Ok` then the value is extracted and passed to `op`
/// whereupon `op`s result is returned. if `self` is `Err` then it is
/// immediately returned. This function can be used to compose the results
/// of two functions.
///
/// Example:
///
/// let res = do read_file(file) |buf| {
/// Ok(parse_bytes(buf))
/// };
#[inline]
pub fn chain<U>(self, op: &fn(T) -> Result<U, E>) -> Result<U, E> {
match self {
@ -153,14 +169,12 @@ impl<T, E> Result<T, E> {
}
}
/**
* Call a function based on a previous result
*
* If `self` is `Err` then the value is extracted and passed to `op`
* whereupon `op`s result is returned. if `self` is `Ok` then it is
* immediately returned. This function can be used to pass through a
* successful result while handling an error.
*/
/// Call a function based on a previous result
///
/// If `self` is `Err` then the value is extracted and passed to `op`
/// whereupon `op`s result is returned. if `self` is `Ok` then it is
/// immediately returned. This function can be used to pass through a
/// successful result while handling an error.
#[inline]
pub fn chain_err<F>(self, op: &fn(E) -> Result<T, F>) -> Result<T, F> {
match self {
@ -170,32 +184,15 @@ impl<T, E> Result<T, E> {
}
}
impl<T: Clone, E> Result<T, E> {
/**
* Get the value out of a successful result
*
* # Failure
*
* If the result is an error
*/
impl<T: Clone, E: ToStr> Result<T, E> {
/// Call a method based on a previous result
///
/// If `self` is `Err` then the value is extracted and passed to `op`
/// whereupon `op`s result is wrapped in an `Err` and returned. if `self` is
/// `Ok` then it is immediately returned. This function can be used to pass
/// through a successful result while handling an error.
#[inline]
pub fn get(&self) -> T {
match *self {
Ok(ref t) => t.clone(),
Err(ref e) => fail!("get called on `Err` result: %?", *e),
}
}
/**
* Call a method based on a previous result
*
* If `self` is `Err` then the value is extracted and passed to `op`
* whereupon `op`s result is wrapped in an `Err` and returned. if `self` is
* `Ok` then it is immediately returned. This function can be used to pass
* through a successful result while handling an error.
*/
#[inline]
pub fn map_err<F:Clone>(&self, op: &fn(&E) -> F) -> Result<T,F> {
pub fn map_err<F: Clone>(&self, op: &fn(&E) -> F) -> Result<T,F> {
match *self {
Ok(ref t) => Ok(t.clone()),
Err(ref e) => Err(op(e))
@ -203,38 +200,21 @@ impl<T: Clone, E> Result<T, E> {
}
}
impl<T, E: Clone> Result<T, E> {
/**
* Get the value out of an error result
*
* # Failure
*
* If the result is not an error
*/
impl<T, E: Clone + ToStr> Result<T, E> {
/// Call a method based on a previous result
///
/// If `self` is `Ok` then the value is extracted and passed to `op`
/// whereupon `op`s result is wrapped in `Ok` and returned. if `self` is
/// `Err` then it is immediately returned. This function can be used to
/// compose the results of two functions.
///
/// Example:
///
/// let res = do read_file(file).map |buf| {
/// parse_bytes(buf)
/// };
#[inline]
pub fn get_err(&self) -> E {
match *self {
Err(ref e) => e.clone(),
Ok(_) => fail!("get_err called on `Ok` result")
}
}
/**
* Call a method based on a previous result
*
* If `self` is `Ok` then the value is extracted and passed to `op`
* whereupon `op`s result is wrapped in `Ok` and returned. if `self` is
* `Err` then it is immediately returned. This function can be used to
* compose the results of two functions.
*
* Example:
*
* let res = do read_file(file).map |buf| {
* parse_bytes(buf)
* };
*/
#[inline]
pub fn map<U:Clone>(&self, op: &fn(&T) -> U) -> Result<U,E> {
pub fn map<U: Clone>(&self, op: &fn(&T) -> U) -> Result<U,E> {
match *self {
Ok(ref t) => Ok(op(t)),
Err(ref e) => Err(e.clone())
@ -242,23 +222,35 @@ impl<T, E: Clone> Result<T, E> {
}
}
/**
* Maps each element in the vector `ts` using the operation `op`. Should an
* error occur, no further mappings are performed and the error is returned.
* Should no error occur, a vector containing the result of each map is
* returned.
*
* Here is an example which increments every integer in a vector,
* checking for overflow:
*
* fn inc_conditionally(x: uint) -> result<uint,str> {
* if x == uint::max_value { return Err("overflow"); }
* else { return Ok(x+1u); }
* }
* map(~[1u, 2u, 3u], inc_conditionally).chain {|incd|
* assert!(incd == ~[2u, 3u, 4u]);
* }
*/
#[inline]
#[allow(missing_doc)]
pub fn map_opt<T, U: ToStr, V>(o_t: &Option<T>,
op: &fn(&T) -> Result<V,U>) -> Result<Option<V>,U> {
match *o_t {
None => Ok(None),
Some(ref t) => match op(t) {
Ok(v) => Ok(Some(v)),
Err(e) => Err(e)
}
}
}
// FIXME: #8228 Replaceable by an external iterator?
/// Maps each element in the vector `ts` using the operation `op`. Should an
/// error occur, no further mappings are performed and the error is returned.
/// Should no error occur, a vector containing the result of each map is
/// returned.
///
/// Here is an example which increments every integer in a vector,
/// checking for overflow:
///
/// fn inc_conditionally(x: uint) -> result<uint,str> {
/// if x == uint::max_value { return Err("overflow"); }
/// else { return Ok(x+1u); }
/// }
/// map(~[1u, 2u, 3u], inc_conditionally).chain {|incd|
/// assert!(incd == ~[2u, 3u, 4u]);
/// }
#[inline]
pub fn map_vec<T,U,V>(ts: &[T], op: &fn(&T) -> Result<V,U>)
-> Result<~[V],U> {
@ -272,36 +264,17 @@ pub fn map_vec<T,U,V>(ts: &[T], op: &fn(&T) -> Result<V,U>)
return Ok(vs);
}
// FIXME: #8228 Replaceable by an external iterator?
/// Same as map, but it operates over two parallel vectors.
///
/// A precondition is used here to ensure that the vectors are the same
/// length. While we do not often use preconditions in the standard
/// library, a precondition is used here because result::t is generally
/// used in 'careful' code contexts where it is both appropriate and easy
/// to accommodate an error like the vectors being of different lengths.
#[inline]
#[allow(missing_doc)]
pub fn map_opt<T,
U,
V>(
o_t: &Option<T>,
op: &fn(&T) -> Result<V,U>)
-> Result<Option<V>,U> {
match *o_t {
None => Ok(None),
Some(ref t) => match op(t) {
Ok(v) => Ok(Some(v)),
Err(e) => Err(e)
}
}
}
/**
* Same as map, but it operates over two parallel vectors.
*
* A precondition is used here to ensure that the vectors are the same
* length. While we do not often use preconditions in the standard
* library, a precondition is used here because result::t is generally
* used in 'careful' code contexts where it is both appropriate and easy
* to accommodate an error like the vectors being of different lengths.
*/
#[inline]
pub fn map_vec2<S,T,U,V>(ss: &[S], ts: &[T],
op: &fn(&S,&T) -> Result<V,U>) -> Result<~[V],U> {
pub fn map_vec2<S, T, U: ToStr, V>(ss: &[S], ts: &[T],
op: &fn(&S,&T) -> Result<V,U>) -> Result<~[V],U> {
assert!(vec::same_length(ss, ts));
let n = ts.len();
let mut vs = vec::with_capacity(n);
@ -316,15 +289,13 @@ pub fn map_vec2<S,T,U,V>(ss: &[S], ts: &[T],
return Ok(vs);
}
/**
* Applies op to the pairwise elements from `ss` and `ts`, aborting on
* error. This could be implemented using `map_zip()` but it is more efficient
* on its own as no result vector is built.
*/
// FIXME: #8228 Replaceable by an external iterator?
/// Applies op to the pairwise elements from `ss` and `ts`, aborting on
/// error. This could be implemented using `map_zip()` but it is more efficient
/// on its own as no result vector is built.
#[inline]
pub fn iter_vec2<S,T,U>(ss: &[S], ts: &[T],
op: &fn(&S,&T) -> Result<(),U>) -> Result<(),U> {
pub fn iter_vec2<S, T, U: ToStr>(ss: &[S], ts: &[T],
op: &fn(&S,&T) -> Result<(),U>) -> Result<(),U> {
assert!(vec::same_length(ss, ts));
let n = ts.len();
let mut i = 0u;
@ -353,12 +324,12 @@ mod tests {
#[test]
pub fn chain_success() {
assert_eq!(op1().chain(op2).get(), 667u);
assert_eq!(op1().chain(op2).unwrap(), 667u);
}
#[test]
pub fn chain_failure() {
assert_eq!(op3().chain( op2).get_err(), ~"sadface");
assert_eq!(op3().chain( op2).unwrap_err(), ~"sadface");
}
#[test]

2
src/libstd/rt/io/flate.rs
View file

@ -115,7 +115,7 @@ mod test {
let mem_reader = MemReader::new(buf);
let mut inflate_reader = InflateReader::new(mem_reader);
let mut out_bytes = [0, .. 100];
let bytes_read = inflate_reader.read(out_bytes).get();
let bytes_read = inflate_reader.read(out_bytes).unwrap();
assert_eq!(bytes_read, in_bytes.len());
let out_msg = str::from_bytes(out_bytes);
assert!(in_msg == out_msg);

36
src/libstd/rt/io/mod.rs
View file

@ -243,6 +243,8 @@ Out of scope
*/
use prelude::*;
use to_str::ToStr;
use str::{StrSlice, OwnedStr};
// Reexports
pub use self::stdio::stdin;
@ -334,6 +336,20 @@ pub struct IoError {
detail: Option<~str>
}
// FIXME: #8242 implementing manually because deriving doesn't work for some reason
impl ToStr for IoError {
fn to_str(&self) -> ~str {
let mut s = ~"IoError { kind: ";
s.push_str(self.kind.to_str());
s.push_str(", desc: ");
s.push_str(self.desc);
s.push_str(", detail: ");
s.push_str(self.detail.to_str());
s.push_str(" }");
s
}
}
#[deriving(Eq)]
pub enum IoErrorKind {
PreviousIoError,
@ -348,6 +364,24 @@ pub enum IoErrorKind {
BrokenPipe
}
// FIXME: #8242 implementing manually because deriving doesn't work for some reason
impl ToStr for IoErrorKind {
fn to_str(&self) -> ~str {
match *self {
PreviousIoError => ~"PreviousIoError",
OtherIoError => ~"OtherIoError",
EndOfFile => ~"EndOfFile",
FileNotFound => ~"FileNotFound",
PermissionDenied => ~"PermissionDenied",
ConnectionFailed => ~"ConnectionFailed",
Closed => ~"Closed",
ConnectionRefused => ~"ConnectionRefused",
ConnectionReset => ~"ConnectionReset",
BrokenPipe => ~"BrokenPipe"
}
}
}
// XXX: Can't put doc comments on macros
// Raised by `I/O` operations on error.
condition! {
@ -505,4 +539,4 @@ pub fn placeholder_error() -> IoError {
desc: "Placeholder error. You shouldn't be seeing this",
detail: None
}
}
}

2
src/libstd/rt/mod.rs
View file

@ -365,7 +365,7 @@ fn run_(main: ~fn(), use_main_sched: bool) -> int {
rtdebug!("about to create the main scheduler task");
let mut main_sched = main_sched.get();
let mut main_sched = main_sched.unwrap();
let home = Sched(main_sched.make_handle());
let mut main_task = ~Task::new_root_homed(&mut main_sched.stack_pool,

4
src/libstd/rt/task.rs
View file

@ -465,10 +465,10 @@ mod test {
do run_in_newsched_task() {
static key: local_data::Key<@~str> = &local_data::Key;
local_data::set(key, @~"data");
assert!(*local_data::get(key, |k| k.map(|&k| *k)).get() == ~"data");
assert!(*local_data::get(key, |k| k.map(|&k| *k)).unwrap() == ~"data");
static key2: local_data::Key<@~str> = &local_data::Key;
local_data::set(key2, @~"data");
assert!(*local_data::get(key2, |k| k.map(|&k| *k)).get() == ~"data");
assert!(*local_data::get(key2, |k| k.map(|&k| *k)).unwrap() == ~"data");
}
}

4
src/libstd/rt/test.rs
View file

@ -154,7 +154,7 @@ pub fn run_in_mt_newsched_task(f: ~fn()) {
do run_in_bare_thread {
let nthreads = match os::getenv("RUST_RT_TEST_THREADS") {
Some(nstr) => FromStr::from_str(nstr).get(),
Some(nstr) => FromStr::from_str(nstr).unwrap(),
None => {
// Using more threads than cores in test code
// to force the OS to preempt them frequently.
@ -362,7 +362,7 @@ pub fn stress_factor() -> uint {
use os::getenv;
match getenv("RUST_RT_STRESS") {
Some(val) => uint::from_str(val).get(),
Some(val) => uint::from_str(val).unwrap(),
None => 1
}
}

4
src/libstd/rt/util.rs
View file

@ -31,7 +31,7 @@ pub fn num_cpus() -> uint {
/// either `RUST_THREADS` or `num_cpus`.
pub fn default_sched_threads() -> uint {
match os::getenv("RUST_THREADS") {
Some(nstr) => FromStr::from_str(nstr).get(),
Some(nstr) => FromStr::from_str(nstr).unwrap(),
None => num_cpus()
}
}
@ -118,4 +118,4 @@ pub fn get_exit_status() -> int {
extern {
fn rust_get_exit_status_newrt() -> libc::uintptr_t;
}
}
}

6
src/libstd/rt/uv/net.rs
View file

@ -108,7 +108,7 @@ fn uv_socket_addr_as_socket_addr<T>(addr: UvSocketAddr, f: &fn(SocketAddr) -> T)
"" => ~[],
// IPv4-Mapped/Compatible IPv6 Address?
s if s.find('.').is_some() => {
let i = s.rfind(':').get_or_default(-1);
let i = s.rfind(':').unwrap_or_default(-1);
let b = s.slice(i + 1, s.len()); // the ipv4 part
@ -614,7 +614,7 @@ mod test {
do tcp_watcher.connect(addr) |stream_watcher, status| {
rtdebug!("tcp_watcher.connect!");
assert!(status.is_some());
assert_eq!(status.get().name(), ~"ECONNREFUSED");
assert_eq!(status.unwrap().name(), ~"ECONNREFUSED");
stream_watcher.close(||());
}
loop_.run();
@ -632,7 +632,7 @@ mod test {
do tcp_watcher.connect(addr) |stream_watcher, status| {
rtdebug!("tcp_watcher.connect!");
assert!(status.is_some());
assert_eq!(status.get().name(), ~"ECONNREFUSED");
assert_eq!(status.unwrap().name(), ~"ECONNREFUSED");
stream_watcher.close(||());
}
loop_.run();

2
src/libstd/rt/uv/uvio.rs
View file

@ -278,7 +278,7 @@ impl IoFactory for UvIoFactory {
rtdebug!("status is some");
let task_cell = Cell::new(task_cell.take());
do stream_watcher.close {
let res = Err(uv_error_to_io_error(status.get()));
let res = Err(uv_error_to_io_error(status.unwrap()));
unsafe { (*result_cell_ptr).put_back(res); }
let scheduler = Local::take::<Scheduler>();
scheduler.resume_blocked_task_immediately(task_cell.take());

4
src/libstd/str.rs
View file

@ -58,7 +58,7 @@ pub fn from_bytes(vv: &[u8]) -> ~str {
use str::not_utf8::cond;
if !is_utf8(vv) {
let first_bad_byte = *vv.iter().find_(|&b| !is_utf8([*b])).get();
let first_bad_byte = *vv.iter().find_(|&b| !is_utf8([*b])).unwrap();
cond.raise(fmt!("from_bytes: input is not UTF-8; first bad byte is %u",
first_bad_byte as uint))
} else {
@ -75,7 +75,7 @@ pub fn from_bytes_owned(vv: ~[u8]) -> ~str {
use str::not_utf8::cond;
if !is_utf8(vv) {
let first_bad_byte = *vv.iter().find_(|&b| !is_utf8([*b])).get();
let first_bad_byte = *vv.iter().find_(|&b| !is_utf8([*b])).unwrap();
cond.raise(fmt!("from_bytes: input is not UTF-8; first bad byte is %u",
first_bad_byte as uint))
} else {

2
src/libstd/task/mod.rs
View file

@ -926,7 +926,7 @@ fn test_named_task() {
t.name(~"ada lovelace");
do t.spawn {
do with_task_name |name| {
assert!(name.get() == "ada lovelace");
assert!(name.unwrap() == "ada lovelace");
}
}
}

6
src/libstd/vec.rs
View file

@ -195,10 +195,8 @@ pub fn build<A>(builder: &fn(push: &fn(v: A))) -> ~[A] {
* onto the vector being constructed.
*/
#[inline]
pub fn build_sized_opt<A>(size: Option<uint>,
builder: &fn(push: &fn(v: A)))
-> ~[A] {
build_sized(size.get_or_default(4), builder)
pub fn build_sized_opt<A>(size: Option<uint>, builder: &fn(push: &fn(v: A))) -> ~[A] {
build_sized(size.unwrap_or_default(4), builder)
}
/// An iterator over the slices of a vector separated by elements that

4
src/libsyntax/abi.rs
View file

@ -280,13 +280,13 @@ impl ToStr for AbiSet {
#[test]
fn lookup_Rust() {
let abi = lookup("Rust");
assert!(abi.is_some() && abi.get().data().name == "Rust");
assert!(abi.is_some() && abi.unwrap().data().name == "Rust");
}
#[test]
fn lookup_cdecl() {
let abi = lookup("cdecl");
assert!(abi.is_some() && abi.get().data().name == "cdecl");
assert!(abi.is_some() && abi.unwrap().data().name == "cdecl");
}
#[test]

4
src/libsyntax/ast.rs
View file

@ -24,7 +24,7 @@ use extra::serialize::{Encodable, Decodable, Encoder, Decoder};
// table) and a SyntaxContext to track renaming and
// macro expansion per Flatt et al., "Macros
// That Work Together"
#[deriving(Clone, Eq, IterBytes)]
#[deriving(Clone, Eq, IterBytes, ToStr)]
pub struct ident { name: Name, ctxt: SyntaxContext }
/// Construct an identifier with the given name and an empty context:
@ -121,7 +121,7 @@ pub type CrateNum = int;
pub type NodeId = int;
#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
#[deriving(Clone, Eq, Encodable, Decodable, IterBytes, ToStr)]
pub struct def_id {
crate: CrateNum,
node: NodeId,

2
src/libsyntax/attr.rs
View file

@ -114,7 +114,7 @@ impl AttributeMethods for Attribute {
/// non-sugared doc attributes.)
pub fn desugar_doc(&self) -> Attribute {
if self.node.is_sugared_doc {
let comment = self.value_str().get();
let comment = self.value_str().unwrap();
let meta = mk_name_value_item_str(@"doc",
strip_doc_comment_decoration(comment).to_managed());
mk_attr(meta)

16
src/libsyntax/ext/base.rs
View file

@ -538,20 +538,20 @@ mod test {
m.insert (@"def",@16);
// FIXME: #4492 (ICE) assert_eq!(m.find(&@"abc"),Some(@15));
// .... assert_eq!(m.find(&@"def"),Some(@16));
assert_eq!(*(m.find(&@"abc").get()),15);
assert_eq!(*(m.find(&@"def").get()),16);
assert_eq!(*(m.find(&@"abc").unwrap()),15);
assert_eq!(*(m.find(&@"def").unwrap()),16);
let n = m.push_frame();
// old bindings are still present:
assert_eq!(*(n.find(&@"abc").get()),15);
assert_eq!(*(n.find(&@"def").get()),16);
assert_eq!(*(n.find(&@"abc").unwrap()),15);
assert_eq!(*(n.find(&@"def").unwrap()),16);
n.insert (@"def",@17);
// n shows the new binding
assert_eq!(*(n.find(&@"abc").get()),15);
assert_eq!(*(n.find(&@"def").get()),17);
assert_eq!(*(n.find(&@"abc").unwrap()),15);
assert_eq!(*(n.find(&@"def").unwrap()),17);
// ... but m still has the old ones
// FIXME: #4492: assert_eq!(m.find(&@"abc"),Some(@15));
// FIXME: #4492: assert_eq!(m.find(&@"def"),Some(@16));
assert_eq!(*(m.find(&@"abc").get()),15);
assert_eq!(*(m.find(&@"def").get()),16);
assert_eq!(*(m.find(&@"abc").unwrap()),15);
assert_eq!(*(m.find(&@"def").unwrap()),16);
}
}

2
src/libsyntax/ext/deriving/generic.rs
View file

@ -961,7 +961,7 @@ fn create_struct_pattern(cx: @ExtCtxt,
let field_pats = do vec::build |push| {
for (&pat, &(id, _)) in subpats.iter().zip(ident_expr.iter()) {
// id is guaranteed to be Some
push(ast::field_pat { ident: id.get(), pat: pat })
push(ast::field_pat { ident: id.unwrap(), pat: pat })
}
};
cx.pat_struct(span, matching_path, field_pats)

4
src/libsyntax/ext/expand.rs
View file

@ -1182,9 +1182,9 @@ mod test {
let a2_name = intern("a2");
let renamer = new_ident_renamer(ast::ident{name:a_name,ctxt:empty_ctxt},
a2_name);
let renamed_ast = fun_to_ident_folder(renamer).fold_item(item_ast).get();
let renamed_ast = fun_to_ident_folder(renamer).fold_item(item_ast).unwrap();
let resolver = new_ident_resolver();
let resolved_ast = fun_to_ident_folder(resolver).fold_item(renamed_ast).get();
let resolved_ast = fun_to_ident_folder(resolver).fold_item(renamed_ast).unwrap();
let resolved_as_str = pprust::item_to_str(resolved_ast,
get_ident_interner());
assert_eq!(resolved_as_str,~"fn a2() -> int { let b = 13; b }");

6
src/libsyntax/ext/source_util.rs
View file

@ -31,7 +31,7 @@ pub fn expand_line(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
-> base::MacResult {
base::check_zero_tts(cx, sp, tts, "line!");
let topmost = topmost_expn_info(cx.backtrace().get());
let topmost = topmost_expn_info(cx.backtrace().unwrap());
let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo);
base::MRExpr(cx.expr_uint(topmost.call_site, loc.line))
@ -42,7 +42,7 @@ pub fn expand_col(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
-> base::MacResult {
base::check_zero_tts(cx, sp, tts, "col!");
let topmost = topmost_expn_info(cx.backtrace().get());
let topmost = topmost_expn_info(cx.backtrace().unwrap());
let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo);
base::MRExpr(cx.expr_uint(topmost.call_site, loc.col.to_uint()))
}
@ -54,7 +54,7 @@ pub fn expand_file(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
-> base::MacResult {
base::check_zero_tts(cx, sp, tts, "file!");
let topmost = topmost_expn_info(cx.backtrace().get());
let topmost = topmost_expn_info(cx.backtrace().unwrap());
let loc = cx.codemap().lookup_char_pos(topmost.call_site.lo);
let filename = loc.file.name;
base::MRExpr(cx.expr_str(topmost.call_site, filename))

8
src/libsyntax/parse/parser.rs
View file

@ -691,7 +691,7 @@ impl Parser {
*/
let opt_abis = self.parse_opt_abis();
let abis = opt_abis.get_or_default(AbiSet::Rust());
let abis = opt_abis.unwrap_or_default(AbiSet::Rust());
let purity = self.parse_unsafety();
self.expect_keyword(keywords::Fn);
let (decl, lifetimes) = self.parse_ty_fn_decl();
@ -3326,7 +3326,7 @@ impl Parser {
let ident = self.parse_ident();
let opt_bounds = self.parse_optional_ty_param_bounds();
// For typarams we don't care about the difference b/w "<T>" and "<T:>".
let bounds = opt_bounds.get_or_default(opt_vec::Empty);
let bounds = opt_bounds.unwrap_or_default(opt_vec::Empty);
ast::TyParam { ident: ident, id: self.get_id(), bounds: bounds }
}
@ -4196,7 +4196,7 @@ impl Parser {
self.obsolete(*self.last_span, ObsoleteExternVisibility);
}
let abis = opt_abis.get_or_default(AbiSet::C());
let abis = opt_abis.unwrap_or_default(AbiSet::C());
let (inner, next) = self.parse_inner_attrs_and_next();
let m = self.parse_foreign_mod_items(sort, abis, next);
@ -4463,7 +4463,7 @@ impl Parser {
if self.eat_keyword(keywords::Fn) {
// EXTERN FUNCTION ITEM
let abis = opt_abis.get_or_default(AbiSet::C());
let abis = opt_abis.unwrap_or_default(AbiSet::C());
let (ident, item_, extra_attrs) =
self.parse_item_fn(extern_fn, abis);
return iovi_item(self.mk_item(lo, self.last_span.hi, ident,

10
src/libsyntax/print/pprust.rs
View file

@ -874,7 +874,7 @@ pub fn print_attribute(s: @ps, attr: &ast::Attribute) {
hardbreak_if_not_bol(s);
maybe_print_comment(s, attr.span.lo);
if attr.node.is_sugared_doc {
let comment = attr.value_str().get();
let comment = attr.value_str().unwrap();
word(s.s, comment);
} else {
word(s.s, "#[");
@ -1085,7 +1085,7 @@ pub fn print_call_post(s: @ps,
}
if sugar != ast::NoSugar {
nbsp(s);
match blk.get().node {
match blk.unwrap().node {
// need to handle closures specifically
ast::expr_do_body(e) => {
end(s); // we close our head box; closure
@ -1095,7 +1095,7 @@ pub fn print_call_post(s: @ps,
}
_ => {
// not sure if this can happen.
print_expr(s, blk.get());
print_expr(s, blk.unwrap());
}
}
}
@ -1323,13 +1323,13 @@ pub fn print_expr(s: @ps, expr: &ast::expr) {
assert!(body.stmts.is_empty());
assert!(body.expr.is_some());
// we extract the block, so as not to create another set of boxes
match body.expr.get().node {
match body.expr.unwrap().node {
ast::expr_block(ref blk) => {
print_block_unclosed(s, blk);
}
_ => {
// this is a bare expression
print_expr(s, body.expr.get());
print_expr(s, body.expr.unwrap());
end(s); // need to close a box
}
}

2
src/test/bench/core-map.rs
View file

@ -100,7 +100,7 @@ fn main() {
let args = os::args();
let n_keys = {
if args.len() == 2 {
uint::from_str(args[1]).get()
uint::from_str(args[1]).unwrap()
} else {
1000000
}

2
src/test/bench/core-set.rs
View file

@ -159,7 +159,7 @@ fn main() {
let args = os::args();
let num_keys = {
if args.len() == 2 {
uint::from_str(args[1]).get()
uint::from_str(args[1]).unwrap()
} else {
100 // woefully inadequate for any real measurement
}

2
src/test/bench/core-uint-to-str.rs
View file

@ -21,7 +21,7 @@ fn main() {
args
};
let n = uint::from_str(args[1]).get();
let n = uint::from_str(args[1]).unwrap();
for i in range(0u, n) {
let x = uint::to_str(i);

4
src/test/bench/graph500-bfs.rs
View file

@ -418,8 +418,8 @@ fn main() {
args
};
let scale = uint::from_str(args[1]).get();
let num_keys = uint::from_str(args[2]).get();
let scale = uint::from_str(args[1]).unwrap();
let num_keys = uint::from_str(args[2]).unwrap();
let do_validate = false;
let do_sequential = true;

4
src/test/bench/msgsend-pipes-shared.rs
View file

@ -59,8 +59,8 @@ fn run(args: &[~str]) {
let to_child = SharedChan::new(to_child);
let size = uint::from_str(args[1]).get();
let workers = uint::from_str(args[2]).get();
let size = uint::from_str(args[1]).unwrap();
let workers = uint::from_str(args[2]).unwrap();
let num_bytes = 100;
let start = extra::time::precise_time_s();
let mut worker_results = ~[];

4
src/test/bench/msgsend-pipes.rs
View file

@ -53,8 +53,8 @@ fn run(args: &[~str]) {
let (from_parent, to_child) = stream();
let to_child = SharedChan::new(to_child);
let size = uint::from_str(args[1]).get();
let workers = uint::from_str(args[2]).get();
let size = uint::from_str(args[1]).unwrap();
let workers = uint::from_str(args[2]).unwrap();
let num_bytes = 100;
let start = extra::time::precise_time_s();
let mut worker_results = ~[];

4
src/test/bench/msgsend-ring-mutex-arcs.rs
View file

@ -79,8 +79,8 @@ fn main() {
args.clone()
};
let num_tasks = uint::from_str(args[1]).get();
let msg_per_task = uint::from_str(args[2]).get();
let num_tasks = uint::from_str(args[1]).unwrap();
let msg_per_task = uint::from_str(args[2]).unwrap();
let (num_chan, num_port) = init();
let num_chan = Cell::new(num_chan);

4
src/test/bench/msgsend-ring-rw-arcs.rs
View file

@ -75,8 +75,8 @@ fn main() {
args.clone()
};
let num_tasks = uint::from_str(args[1]).get();
let msg_per_task = uint::from_str(args[2]).get();
let num_tasks = uint::from_str(args[1]).unwrap();
let msg_per_task = uint::from_str(args[2]).unwrap();
let (num_chan, num_port) = init();
let num_chan = Cell::new(num_chan);

2
src/test/bench/shootout-ackermann.rs
View file

@ -35,6 +35,6 @@ fn main() {
} else {
args
};
let n = int::from_str(args[1]).get();
let n = int::from_str(args[1]).unwrap();
printfln!("Ack(3,%d): %d\n", n, ack(3, n));
}

2
src/test/bench/shootout-binarytrees.rs
View file

@ -48,7 +48,7 @@ fn main() {
args
};
let n = int::from_str(args[1]).get();
let n = int::from_str(args[1]).unwrap();
let min_depth = 4;
let mut max_depth;
if min_depth + 2 > n {

2
src/test/bench/shootout-chameneos-redux.rs
View file

@ -212,7 +212,7 @@ fn main() {
args
};
let nn = uint::from_str(args[1]).get();
let nn = uint::from_str(args[1]).unwrap();
print_complements();
io::println("");

2
src/test/bench/shootout-fannkuch-redux.rs
View file

@ -91,6 +91,6 @@ fn fannkuch_redux(n: i32) -> i32 {
#[fixed_stack_segment]
fn main() {
let n: i32 = FromStr::from_str(os::args()[1]).get();
let n: i32 = FromStr::from_str(os::args()[1]).unwrap();
printfln!("Pfannkuchen(%d) = %d", n as int, fannkuch_redux(n) as int);
}

2
src/test/bench/shootout-fasta-redux.rs
View file

@ -184,7 +184,7 @@ impl RandomFasta {
#[fixed_stack_segment]
fn main() {
let n: uint = FromStr::from_str(os::args()[1]).get();
let n: uint = FromStr::from_str(os::args()[1]).unwrap();
unsafe {
let mode = "w";

2
src/test/bench/shootout-fasta.rs
View file

@ -130,7 +130,7 @@ fn main() {
io::stdout()
};
let n = int::from_str(args[1]).get();
let n = int::from_str(args[1]).unwrap();
let iub: ~[AminoAcids] =
make_cumulative(~[acid('a', 27u32), acid('c', 12u32), acid('g', 12u32),

2
src/test/bench/shootout-fibo.rs
View file

@ -31,6 +31,6 @@ fn main() {
} else {
args
};
let n = int::from_str(args[1]).get();
let n = int::from_str(args[1]).unwrap();
printfln!("%d\n", fib(n));
}

2
src/test/bench/shootout-mandelbrot.rs
View file

@ -9,7 +9,7 @@ static LIMIT: f64 = 2.0;
#[fixed_stack_segment]
fn main() {
unsafe {
let w: i32 = FromStr::from_str(os::args()[1]).get();
let w: i32 = FromStr::from_str(os::args()[1]).unwrap();
let h = w;
let mut byte_acc: i8 = 0;
let mut bit_num: i32 = 0;

2
src/test/bench/shootout-nbody.rs
View file

@ -137,7 +137,7 @@ fn offset_momentum(bodies: &mut [Planet, ..N_BODIES]) {
}
fn main() {
let n: i32 = FromStr::from_str(os::args()[1]).get();
let n: i32 = FromStr::from_str(os::args()[1]).unwrap();
let mut bodies = BODIES;
offset_momentum(&mut bodies);

Some files were not shown because too many files have changed in this diff Show more