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"),
_ => ~[~".rc", ~".rs"]
};
let invalid_prefixes = ~[~".", ~"#", ~"~"];
- let name = testfile.filename().get();
+ let name = testfile.filename().unwrap();
let mut valid = false;
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",
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 {
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() }
};
if opt.is_none() {
return false;
}
- *idx = opt.get();
+ *idx = opt.unwrap();
return true;
}
}
fn output_testname(testfile: &Path) -> Path {
- Path(testfile.filestem().get())
+ Path(testfile.filestem().unwrap())
}
fn output_base_name(config: &config, testfile: &Path) -> Path {
if suffix.len() == 0 {
(*p).clone()
} else {
- let stem = p.filestem().get();
+ let stem = p.filestem().unwrap();
p.with_filestem(stem + "-" + suffix)
}
}
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_()
}
priv chunks: @mut MutList<Chunk>,
}
-#[unsafe_destructor]
-impl Drop for Arena {
- fn drop(&self) {
- unsafe {
- destroy_chunk(&self.head);
- do self.chunks.each |chunk| {
- if !chunk.is_pod {
- destroy_chunk(chunk);
- }
- true
- };
+impl Arena {
+ pub fn new() -> Arena {
+ Arena::new_with_size(32u)
+ }
+
+ pub fn new_with_size(initial_size: uint) -> Arena {
+ Arena {
+ head: chunk(initial_size, false),
+ pod_head: chunk(initial_size, true),
+ chunks: @mut MutNil,
}
}
}
}
}
-pub fn arena_with_size(initial_size: uint) -> Arena {
- Arena {
- head: chunk(initial_size, false),
- pod_head: chunk(initial_size, true),
- chunks: @mut MutNil,
+#[unsafe_destructor]
+impl Drop for Arena {
+ fn drop(&self) {
+ unsafe {
+ destroy_chunk(&self.head);
+ do self.chunks.each |chunk| {
+ if !chunk.is_pod {
+ destroy_chunk(chunk);
+ }
+ true
+ };
+ }
}
}
-pub fn Arena() -> Arena {
- arena_with_size(32u)
-}
-
#[inline]
fn round_up_to(base: uint, align: uint) -> uint {
(base + (align - 1)) & !(align - 1)
#[test]
fn test_arena_destructors() {
- let arena = Arena();
+ let arena = Arena::new();
for i in range(0u, 10) {
// Arena allocate something with drop glue to make sure it
// doesn't leak.
#[should_fail]
#[ignore(cfg(windows))]
fn test_arena_destructors_fail() {
- let arena = Arena();
+ let arena = Arena::new();
// Put some stuff in the arena.
for i in range(0u, 10) {
// Arena allocate something with drop glue to make sure it
#[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]
push(random());
}
};
- assert_eq!(v.to_base64(STANDARD).from_base64().get(), v);
+ assert_eq!(v.to_base64(STANDARD).from_base64().unwrap(), v);
}
}
use std::cmp;
use std::iterator::RandomAccessIterator;
-use std::iterator::{Invert, Enumerate};
+use std::iterator::{Invert, Enumerate, Repeat, Map, Zip};
use std::num;
use std::ops;
use std::uint;
#[inline]
pub fn equals(&self, b: &BigBitv, nbits: uint) -> bool {
let len = b.storage.len();
- do uint::iterate(0, len) |i| {
+ for i in range(0, len) {
let mask = big_mask(nbits, i);
if mask & self.storage[i] != mask & b.storage[i] {
- false
- } else {
- true
+ return false;
}
}
+ true
}
}
/// w1, w2) where the bit location is the number of bits offset so far,
/// and w1/w2 are the words coming from the two vectors self, other.
fn common_iter<'a>(&'a self, other: &'a BitvSet)
- -> MapE<(uint,&uint),(uint,uint,uint), &'a ~[uint],Enumerate<vec::VecIterator<'a,uint>>> {
- let min = num::min(self.bitv.storage.len(),
- other.bitv.storage.len());
- MapE{iter: self.bitv.storage.slice(0, min).iter().enumerate(),
- env: &other.bitv.storage,
- f: |(i, &w): (uint, &uint), o_store| (i * uint::bits, w, o_store[i])
- }
+ -> Map<'static, ((uint, &'a uint), &'a ~[uint]), (uint, uint, uint),
+ Zip<Enumerate<vec::VecIterator<'a, uint>>, Repeat<&'a ~[uint]>>> {
+ let min = num::min(self.bitv.storage.len(), other.bitv.storage.len());
+ self.bitv.storage.slice(0, min).iter().enumerate()
+ .zip(Repeat::new(&other.bitv.storage))
+ .transform(|((i, &w), o_store)| (i * uint::bits, w, o_store[i]))
}
/// Visits each word in self or other that extends beyond the other. This
/// is true if the word comes from 'self', and false if it comes from
/// 'other'.
fn outlier_iter<'a>(&'a self, other: &'a BitvSet)
- -> MapE<(uint, &uint),(bool, uint, uint), uint, Enumerate<vec::VecIterator<'a, uint>>> {
- let len1 = self.bitv.storage.len();
- let len2 = other.bitv.storage.len();
- let min = num::min(len1, len2);
-
- if min < len1 {
- MapE{iter: self.bitv.storage.slice(min, len1).iter().enumerate(),
- env: min,
- f: |(i, &w): (uint, &uint), min| (true, (i + min) * uint::bits, w)
- }
+ -> Map<'static, ((uint, &'a uint), uint), (bool, uint, uint),
+ Zip<Enumerate<vec::VecIterator<'a, uint>>, Repeat<uint>>> {
+ let slen = self.bitv.storage.len();
+ let olen = other.bitv.storage.len();
+
+ if olen < slen {
+ self.bitv.storage.slice_from(olen).iter().enumerate()
+ .zip(Repeat::new(olen))
+ .transform(|((i, &w), min)| (true, (i + min) * uint::bits, w))
} else {
- MapE{iter: other.bitv.storage.slice(min, len2).iter().enumerate(),
- env: min,
- f: |(i, &w): (uint, &uint), min| (false, (i + min) * uint::bits, w)
- }
- }
- }
-}
-
-/// Like iterator::Map with explicit env capture
-struct MapE<A, B, Env, I> {
- priv env: Env,
- priv f: &'static fn(A, Env) -> B,
- priv iter: I,
-}
-
-impl<'self, A, B, Env: Clone, I: Iterator<A>> Iterator<B> for MapE<A, B, Env, I> {
- #[inline]
- fn next(&mut self) -> Option<B> {
- match self.iter.next() {
- Some(elt) => Some((self.f)(elt, self.env.clone())),
- None => None
+ other.bitv.storage.slice_from(slen).iter().enumerate()
+ .zip(Repeat::new(slen))
+ .transform(|((i, &w), min)| (false, (i + min) * uint::bits, w))
}
}
-
- #[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
- self.iter.size_hint()
- }
}
pub struct BitvSetIterator<'self> {
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::iterator::Iterator;
+
+#[deriving(Clone, Eq, IterBytes, ToStr)]
+/// A specialized Set implementation to use enum types.
+pub struct EnumSet<E> {
+ // We must maintain the invariant that no bits are set
+ // for which no variant exists
+ priv bits: uint
+}
+
+/// An iterface for casting C-like enum to uint and back.
+pub trait CLike {
+ /// Converts C-like enum to uint.
+ pub fn to_uint(&self) -> uint;
+ /// Converts uint to C-like enum.
+ pub fn from_uint(uint) -> Self;
+}
+
+fn bit<E:CLike>(e: E) -> uint {
+ 1 << e.to_uint()
+}
+
+impl<E:CLike> EnumSet<E> {
+ /// Returns an empty EnumSet.
+ pub fn empty() -> EnumSet<E> {
+ EnumSet {bits: 0}
+ }
+
+ /// Returns true if an EnumSet is empty.
+ pub fn is_empty(&self) -> bool {
+ self.bits == 0
+ }
+
+ /// Returns true if an EnumSet contains any enum of a given EnumSet
+ pub fn intersects(&self, e: EnumSet<E>) -> bool {
+ (self.bits & e.bits) != 0
+ }
+
+ /// Returns an intersection of both EnumSets.
+ pub fn intersection(&self, e: EnumSet<E>) -> EnumSet<E> {
+ EnumSet {bits: self.bits & e.bits}
+ }
+
+ /// Returns true if a given EnumSet is included in an EnumSet.
+ pub fn contains(&self, e: EnumSet<E>) -> bool {
+ (self.bits & e.bits) == e.bits
+ }
+
+ /// Returns a union of both EnumSets.
+ pub fn union(&self, e: EnumSet<E>) -> EnumSet<E> {
+ EnumSet {bits: self.bits | e.bits}
+ }
+
+ /// Add an enum to an EnumSet
+ pub fn add(&mut self, e: E) {
+ self.bits |= bit(e);
+ }
+
+ /// Returns true if an EnumSet contains a given enum
+ pub fn contains_elem(&self, e: E) -> bool {
+ (self.bits & bit(e)) != 0
+ }
+
+ /// Returns an iterator over an EnumSet
+ pub fn iter(&self) -> EnumSetIterator<E> {
+ EnumSetIterator::new(self.bits)
+ }
+}
+
+impl<E:CLike> Sub<EnumSet<E>, EnumSet<E>> for EnumSet<E> {
+ fn sub(&self, e: &EnumSet<E>) -> EnumSet<E> {
+ EnumSet {bits: self.bits & !e.bits}
+ }
+}
+
+impl<E:CLike> BitOr<EnumSet<E>, EnumSet<E>> for EnumSet<E> {
+ fn bitor(&self, e: &EnumSet<E>) -> EnumSet<E> {
+ EnumSet {bits: self.bits | e.bits}
+ }
+}
+
+impl<E:CLike> BitAnd<EnumSet<E>, EnumSet<E>> for EnumSet<E> {
+ fn bitand(&self, e: &EnumSet<E>) -> EnumSet<E> {
+ EnumSet {bits: self.bits & e.bits}
+ }
+}
+
+/// An iterator over an EnumSet
+pub struct EnumSetIterator<E> {
+ priv index: uint,
+ priv bits: uint,
+}
+
+impl<E:CLike> EnumSetIterator<E> {
+ fn new(bits: uint) -> EnumSetIterator<E> {
+ EnumSetIterator { index: 0, bits: bits }
+ }
+}
+
+impl<E:CLike> Iterator<E> for EnumSetIterator<E> {
+ fn next(&mut self) -> Option<E> {
+ if (self.bits == 0) {
+ return None;
+ }
+
+ while (self.bits & 1) == 0 {
+ self.index += 1;
+ self.bits >>= 1;
+ }
+ let elem = CLike::from_uint(self.index);
+ self.index += 1;
+ self.bits >>= 1;
+ Some(elem)
+ }
+
+ fn size_hint(&self) -> (uint, Option<uint>) {
+ let exact = self.bits.population_count();
+ (exact, Some(exact))
+ }
+}
+
+#[cfg(test)]
+mod test {
+
+ use std::cast;
+
+ use enum_set::*;
+
+ #[deriving(Eq)]
+ enum Foo {
+ A, B, C
+ }
+
+ impl CLike for Foo {
+ pub fn to_uint(&self) -> uint {
+ *self as uint
+ }
+
+ pub fn from_uint(v: uint) -> Foo {
+ unsafe { cast::transmute(v) }
+ }
+ }
+
+ #[test]
+ fn test_empty() {
+ let e: EnumSet<Foo> = EnumSet::empty();
+ assert!(e.is_empty());
+ }
+
+ ///////////////////////////////////////////////////////////////////////////
+ // intersect
+
+ #[test]
+ fn test_two_empties_do_not_intersect() {
+ let e1: EnumSet<Foo> = EnumSet::empty();
+ let e2: EnumSet<Foo> = EnumSet::empty();
+ assert!(!e1.intersects(e2));
+ }
+
+ #[test]
+ fn test_empty_does_not_intersect_with_full() {
+ let e1: EnumSet<Foo> = EnumSet::empty();
+
+ let mut e2: EnumSet<Foo> = EnumSet::empty();
+ e2.add(A);
+ e2.add(B);
+ e2.add(C);
+
+ assert!(!e1.intersects(e2));
+ }
+
+ #[test]
+ fn test_disjoint_intersects() {
+ let mut e1: EnumSet<Foo> = EnumSet::empty();
+ e1.add(A);
+
+ let mut e2: EnumSet<Foo> = EnumSet::empty();
+ e2.add(B);
+
+ assert!(!e1.intersects(e2));
+ }
+
+ #[test]
+ fn test_overlapping_intersects() {
+ let mut e1: EnumSet<Foo> = EnumSet::empty();
+ e1.add(A);
+
+ let mut e2: EnumSet<Foo> = EnumSet::empty();
+ e2.add(A);
+ e2.add(B);
+
+ assert!(e1.intersects(e2));
+ }
+
+ ///////////////////////////////////////////////////////////////////////////
+ // contains and contains_elem
+
+ #[test]
+ fn test_contains() {
+ let mut e1: EnumSet<Foo> = EnumSet::empty();
+ e1.add(A);
+
+ let mut e2: EnumSet<Foo> = EnumSet::empty();
+ e2.add(A);
+ e2.add(B);
+
+ assert!(!e1.contains(e2));
+ assert!(e2.contains(e1));
+ }
+
+ #[test]
+ fn test_contains_elem() {
+ let mut e1: EnumSet<Foo> = EnumSet::empty();
+ e1.add(A);
+ assert!(e1.contains_elem(A));
+ assert!(!e1.contains_elem(B));
+ assert!(!e1.contains_elem(C));
+
+ e1.add(A);
+ e1.add(B);
+ assert!(e1.contains_elem(A));
+ assert!(e1.contains_elem(B));
+ assert!(!e1.contains_elem(C));
+ }
+
+ ///////////////////////////////////////////////////////////////////////////
+ // iter
+
+ #[test]
+ fn test_iterator() {
+ let mut e1: EnumSet<Foo> = EnumSet::empty();
+
+ let elems: ~[Foo] = e1.iter().collect();
+ assert_eq!(~[], elems)
+
+ e1.add(A);
+ let elems: ~[Foo] = e1.iter().collect();
+ assert_eq!(~[A], elems)
+
+ e1.add(C);
+ let elems: ~[Foo] = e1.iter().collect();
+ assert_eq!(~[A,C], elems)
+
+ e1.add(C);
+ let elems: ~[Foo] = e1.iter().collect();
+ assert_eq!(~[A,C], elems)
+
+ e1.add(B);
+ let elems: ~[Foo] = e1.iter().collect();
+ assert_eq!(~[A,B,C], elems)
+ }
+
+ ///////////////////////////////////////////////////////////////////////////
+ // operators
+
+ #[test]
+ fn test_operators() {
+ let mut e1: EnumSet<Foo> = EnumSet::empty();
+ e1.add(A);
+ e1.add(C);
+
+ let mut e2: EnumSet<Foo> = EnumSet::empty();
+ e2.add(B);
+ e2.add(C);
+
+ let e_union = e1 | e2;
+ let elems: ~[Foo] = e_union.iter().collect();
+ assert_eq!(~[A,B,C], elems)
+
+ let e_intersection = e1 & e2;
+ let elems: ~[Foo] = e_intersection.iter().collect();
+ assert_eq!(~[C], elems)
+
+ let e_subtract = e1 - e2;
+ let elems: ~[Foo] = e_subtract.iter().collect();
+ assert_eq!(~[A], elems)
+ }
+}
pub mod base64;
pub mod rl;
pub mod workcache;
+pub mod enum_set;
#[path="num/bigint.rs"]
pub mod bigint;
#[path="num/rational.rs"]
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
* 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),
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,
}
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);
}
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())); }
#[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());
}
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());
}
}
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);
"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;
}
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());
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));
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);
}
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))
}
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]
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);
}
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);
}
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:
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
}
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);
}
// be rpathed
if sess.targ_cfg.os == session::os_macos {
args.push(~"-Wl,-install_name,@rpath/"
- + output.filename().get());
+ + output.filename().unwrap());
}
}
if !pass.is_some() {
failed.push(name);
} else {
- unsafe { llvm::LLVMDestroyPass(pass.get()) }
+ unsafe { llvm::LLVMDestroyPass(pass.unwrap()) }
}
}
for &(name,_) in transform_passes.iter() {
if !pass.is_some() {
failed.push(name);
} else {
- unsafe { llvm::LLVMDestroyPass(pass.get()) }
+ unsafe { llvm::LLVMDestroyPass(pass.unwrap()) }
}
}
for &(name,_) in utility_passes.iter() {
if !pass.is_some() {
failed.push(name);
} else {
- unsafe { llvm::LLVMDestroyPass(pass.get()) }
+ unsafe { llvm::LLVMDestroyPass(pass.unwrap()) }
}
}
};
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"
};
#[main];
extra::test::test_main_static(::std::os::args(), TESTS);
}
- )).get();
+ )).unwrap();
let testmod = ast::_mod {
view_items: view_items,
pub static TESTS : &'static [self::extra::test::TestDescAndFn] =
$test_descs
;
- )).get()
+ )).unwrap()
}
fn is_extra(cx: &TestCtxt) -> bool {
}
fn enc_bounds(w: @io::Writer, cx: @ctxt, bs: &ty::ParamBounds) {
- do bs.builtin_bounds.each |bound| {
+ for bound in bs.builtin_bounds.iter() {
match bound {
ty::BoundSend => w.write_char('S'),
ty::BoundFreeze => w.write_char('K'),
ty::BoundStatic => w.write_char('O'),
ty::BoundSized => w.write_char('Z'),
}
- true
- };
+ }
for &tp in bs.trait_bounds.iter() {
w.write_char('I');
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))
});
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)),
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);
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,
// 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,
}
expr_again(_) => {
if !cx.in_loop {
- tcx.sess.span_err(e.span, "`again` outside of loop");
+ tcx.sess.span_err(e.span, "`loop` outside of loop");
}
}
expr_ret(oe) => {
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
-> 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,
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
}
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) => {
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) =>
"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");
}
};
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)
}
{
let kind = ty::type_contents(cx.tcx, ty);
let mut missing = ty::EmptyBuiltinBounds();
- do bounds.each |bound| {
+ for bound in bounds.iter() {
if !kind.meets_bound(cx.tcx, bound) {
missing.add(bound);
}
- true
- };
+ }
if !missing.is_empty() {
any_missing(missing);
}
// 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);
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 \
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;
let imports: &mut ~[@ImportDirective] = &mut *module_.imports;
let import_count = imports.len();
if index != import_count {
- let sn = self.session.codemap.span_to_snippet(imports[index].span);
+ let sn = self.session.codemap.span_to_snippet(imports[index].span).unwrap();
if sn.contains("::") {
self.session.span_err(imports[index].span, "unresolved import");
} else {
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 \
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 \
}
};
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)
);
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 {
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)
}
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())); }
}
}
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
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")
}
}
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)
}
// 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);
{
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);
}
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);
// 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();
}
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);
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)
}
}
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)
}
}
} 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);
}
}
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);
if is_loop_body.is_some() {
Store(bcx,
C_bool(true),
- bcx.fcx.llretptr.get());
+ bcx.fcx.llretptr.unwrap());
}
});
rslt(bcx, llbox)
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;
self.llreturn = Some(base::mk_return_basic_block(self.llfn));
}
- self.llreturn.get()
+ self.llreturn.unwrap()
}
}
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;
// 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()),
}
}
- 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) {
// 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);
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.
} 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();
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;
});
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);
}
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);
});
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);
}
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);
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"),
};
// 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());
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())
// 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);
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));
}
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 {
//
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))
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)) => {
use util::ppaux::{trait_store_to_str, ty_to_str, vstore_to_str};
use util::ppaux::{Repr, UserString};
use util::common::{indenter};
-use util::enum_set::{EnumSet, CLike};
use std::cast;
use std::cmp;
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::*;
use syntax::opt_vec;
use syntax::abi::AbiSet;
use syntax;
+use extra::enum_set::{EnumSet, CLike};
pub static INITIAL_DISCRIMINANT_VALUE: uint = 0;
mutbl: ast::mutability,
}
-#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Eq, Encodable, Decodable, IterBytes, ToStr)]
pub enum vstore {
vstore_fixed(uint),
vstore_uniq,
vstore_slice(Region)
}
-#[deriving(Clone, Eq, IterBytes, Encodable, Decodable)]
+#[deriving(Clone, Eq, IterBytes, Encodable, Decodable, ToStr)]
pub enum TraitStore {
BoxTraitStore, // @Trait
UniqTraitStore, // ~Trait
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);
}
/// 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
}
}
-#[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,
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>),
pub type BuiltinBounds = EnumSet<BuiltinBound>;
-#[deriving(Clone, Eq, IterBytes)]
+#[deriving(Clone, Eq, IterBytes, ToStr)]
pub enum BuiltinBound {
BoundStatic,
BoundSend,
FloatVar(FloatVid)
}
-#[deriving(Clone, Encodable, Decodable, IterBytes)]
+#[deriving(Clone, Encodable, Decodable, IterBytes, ToStr)]
pub enum InferRegion {
ReVar(RegionVid),
ReSkolemized(uint, bound_region)
// This is like with typarams below, but less "pessimistic" and also
// dependent on the trait store.
let mut bt = TC_NONE;
- do (AllBuiltinBounds() - bounds).each |bound| {
+ for bound in (AllBuiltinBounds() - bounds).iter() {
bt = bt + match bound {
BoundStatic if bounds.contains_elem(BoundSend)
=> TC_NONE, // Send bound implies static bound.
BoundFreeze => TC_MUTABLE,
BoundSized => TC_NONE, // don't care if interior is sized
};
- true
- };
+ }
st + mt + bt
}
let _i = indenter();
let mut tc = TC_ALL;
- do type_param_def.bounds.builtin_bounds.each |bound| {
+ for bound in type_param_def.bounds.builtin_bounds.iter() {
debug!("tc = %s, bound = %?", tc.to_str(), bound);
tc = tc - match bound {
BoundStatic => TypeContents::nonstatic(cx),
// The dynamic-size bit can be removed at pointer-level, etc.
BoundSized => TypeContents::dynamically_sized(cx),
};
- true
- };
+ }
debug!("result = %s", tc.to_str());
return tc;
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),
}
};
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>(
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)
};
fcx.write_error(pat.id);
kind_name = "[error]";
arg_types = (*subpats).clone()
- .get_or_default(~[])
+ .unwrap_or_default(~[])
.map(|_| ty::mk_err());
}
}
fcx.write_error(pat.id);
kind_name = "[error]";
arg_types = (*subpats).clone()
- .get_or_default(~[])
+ .unwrap_or_default(~[])
.map(|_| ty::mk_err());
}
}
// 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)
}
_ => {
}
}
_ => {
- 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)
}
};
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,
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)
};
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| {
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;
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> {
use syntax::opt_vec;
use syntax::parse::token::special_idents;
+#[deriving(ToStr)]
pub struct RegionError {
msg: ~str,
replacement: ty::Region
pub mod util {
pub mod common;
pub mod ppaux;
- pub mod enum_set;
}
pub mod lib {
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::iterator::Iterator;
-
-#[deriving(Clone, Eq, IterBytes)]
-pub struct EnumSet<E> {
- // We must maintain the invariant that no bits are set
- // for which no variant exists
- priv bits: uint
-}
-
-pub trait CLike {
- pub fn to_uint(&self) -> uint;
- pub fn from_uint(uint) -> Self;
-}
-
-fn bit<E:CLike>(e: E) -> uint {
- 1 << e.to_uint()
-}
-
-impl<E:CLike> EnumSet<E> {
- pub fn empty() -> EnumSet<E> {
- EnumSet {bits: 0}
- }
-
- pub fn is_empty(&self) -> bool {
- self.bits == 0
- }
-
- pub fn intersects(&self, e: EnumSet<E>) -> bool {
- (self.bits & e.bits) != 0
- }
-
- pub fn intersection(&self, e: EnumSet<E>) -> EnumSet<E> {
- EnumSet {bits: self.bits & e.bits}
- }
-
- pub fn contains(&self, e: EnumSet<E>) -> bool {
- (self.bits & e.bits) == e.bits
- }
-
- pub fn union(&self, e: EnumSet<E>) -> EnumSet<E> {
- EnumSet {bits: self.bits | e.bits}
- }
-
- pub fn add(&mut self, e: E) {
- self.bits |= bit(e);
- }
-
- pub fn contains_elem(&self, e: E) -> bool {
- (self.bits & bit(e)) != 0
- }
-
- pub fn each(&self, f: &fn(E) -> bool) -> bool {
- let mut bits = self.bits;
- let mut index = 0;
- while bits != 0 {
- if (bits & 1) != 0 {
- let e = CLike::from_uint(index);
- if !f(e) {
- return false;
- }
- }
- index += 1;
- bits >>= 1;
- }
- return true;
- }
-
- pub fn iter(&self) -> EnumSetIterator<E> {
- EnumSetIterator::new(self.bits)
- }
-}
-
-impl<E:CLike> Sub<EnumSet<E>, EnumSet<E>> for EnumSet<E> {
- fn sub(&self, e: &EnumSet<E>) -> EnumSet<E> {
- EnumSet {bits: self.bits & !e.bits}
- }
-}
-
-impl<E:CLike> BitOr<EnumSet<E>, EnumSet<E>> for EnumSet<E> {
- fn bitor(&self, e: &EnumSet<E>) -> EnumSet<E> {
- EnumSet {bits: self.bits | e.bits}
- }
-}
-
-impl<E:CLike> BitAnd<EnumSet<E>, EnumSet<E>> for EnumSet<E> {
- fn bitand(&self, e: &EnumSet<E>) -> EnumSet<E> {
- EnumSet {bits: self.bits & e.bits}
- }
-}
-
-pub struct EnumSetIterator<E> {
- priv index: uint,
- priv bits: uint,
-}
-
-impl<E:CLike> EnumSetIterator<E> {
- fn new(bits: uint) -> EnumSetIterator<E> {
- EnumSetIterator { index: 0, bits: bits }
- }
-}
-
-impl<E:CLike> Iterator<E> for EnumSetIterator<E> {
- fn next(&mut self) -> Option<E> {
- if (self.bits == 0) {
- return None;
- }
-
- while (self.bits & 1) == 0 {
- self.index += 1;
- self.bits >>= 1;
- }
- let elem = CLike::from_uint(self.index);
- self.index += 1;
- self.bits >>= 1;
- Some(elem)
- }
-
- fn size_hint(&self) -> (uint, Option<uint>) {
- let exact = self.bits.population_count();
- (exact, Some(exact))
- }
-}
-
-#[cfg(test)]
-mod test {
-
- use std::cast;
-
- use util::enum_set::*;
-
- #[deriving(Eq)]
- enum Foo {
- A, B, C
- }
-
- impl CLike for Foo {
- pub fn to_uint(&self) -> uint {
- *self as uint
- }
-
- pub fn from_uint(v: uint) -> Foo {
- unsafe { cast::transmute(v) }
- }
- }
-
- #[test]
- fn test_empty() {
- let e: EnumSet<Foo> = EnumSet::empty();
- assert!(e.is_empty());
- }
-
- ///////////////////////////////////////////////////////////////////////////
- // intersect
-
- #[test]
- fn test_two_empties_do_not_intersect() {
- let e1: EnumSet<Foo> = EnumSet::empty();
- let e2: EnumSet<Foo> = EnumSet::empty();
- assert!(!e1.intersects(e2));
- }
-
- #[test]
- fn test_empty_does_not_intersect_with_full() {
- let e1: EnumSet<Foo> = EnumSet::empty();
-
- let mut e2: EnumSet<Foo> = EnumSet::empty();
- e2.add(A);
- e2.add(B);
- e2.add(C);
-
- assert!(!e1.intersects(e2));
- }
-
- #[test]
- fn test_disjoint_intersects() {
- let mut e1: EnumSet<Foo> = EnumSet::empty();
- e1.add(A);
-
- let mut e2: EnumSet<Foo> = EnumSet::empty();
- e2.add(B);
-
- assert!(!e1.intersects(e2));
- }
-
- #[test]
- fn test_overlapping_intersects() {
- let mut e1: EnumSet<Foo> = EnumSet::empty();
- e1.add(A);
-
- let mut e2: EnumSet<Foo> = EnumSet::empty();
- e2.add(A);
- e2.add(B);
-
- assert!(e1.intersects(e2));
- }
-
- ///////////////////////////////////////////////////////////////////////////
- // contains and contains_elem
-
- #[test]
- fn test_contains() {
- let mut e1: EnumSet<Foo> = EnumSet::empty();
- e1.add(A);
-
- let mut e2: EnumSet<Foo> = EnumSet::empty();
- e2.add(A);
- e2.add(B);
-
- assert!(!e1.contains(e2));
- assert!(e2.contains(e1));
- }
-
- #[test]
- fn test_contains_elem() {
- let mut e1: EnumSet<Foo> = EnumSet::empty();
- e1.add(A);
- assert!(e1.contains_elem(A));
- assert!(!e1.contains_elem(B));
- assert!(!e1.contains_elem(C));
-
- e1.add(A);
- e1.add(B);
- assert!(e1.contains_elem(A));
- assert!(e1.contains_elem(B));
- assert!(!e1.contains_elem(C));
- }
-
- ///////////////////////////////////////////////////////////////////////////
- // iter / each
-
- #[test]
- fn test_iterator() {
- let mut e1: EnumSet<Foo> = EnumSet::empty();
-
- let elems: ~[Foo] = e1.iter().collect();
- assert_eq!(~[], elems)
-
- e1.add(A);
- let elems: ~[Foo] = e1.iter().collect();
- assert_eq!(~[A], elems)
-
- e1.add(C);
- let elems: ~[Foo] = e1.iter().collect();
- assert_eq!(~[A,C], elems)
-
- e1.add(C);
- let elems: ~[Foo] = e1.iter().collect();
- assert_eq!(~[A,C], elems)
-
- e1.add(B);
- let elems: ~[Foo] = e1.iter().collect();
- assert_eq!(~[A,B,C], elems)
- }
-
- #[test]
- fn test_each() {
- let mut e1: EnumSet<Foo> = EnumSet::empty();
-
- assert_eq!(~[], collect(e1))
-
- e1.add(A);
- assert_eq!(~[A], collect(e1))
-
- e1.add(C);
- assert_eq!(~[A,C], collect(e1))
-
- e1.add(C);
- assert_eq!(~[A,C], collect(e1))
-
- e1.add(B);
- assert_eq!(~[A,B,C], collect(e1))
- }
-
- fn collect(e: EnumSet<Foo>) -> ~[Foo] {
- let mut elems = ~[];
- e.each(|elem| {
- elems.push(elem);
- true
- });
- elems
- }
-
- ///////////////////////////////////////////////////////////////////////////
- // operators
-
- #[test]
- fn test_operators() {
- let mut e1: EnumSet<Foo> = EnumSet::empty();
- e1.add(A);
- e1.add(C);
-
- let mut e2: EnumSet<Foo> = EnumSet::empty();
- e2.add(B);
- e2.add(C);
-
- let e_union = e1 | e2;
- let elems: ~[Foo] = e_union.iter().collect();
- assert_eq!(~[A,B,C], elems)
-
- let e_intersection = e1 & e2;
- let elems: ~[Foo] = e_intersection.iter().collect();
- assert_eq!(~[C], elems)
-
- let e_subtract = e1 - e2;
- let elems: ~[Foo] = e_subtract.iter().collect();
- assert_eq!(~[A], elems)
- }
-}
impl Repr for ty::ParamBounds {
fn repr(&self, tcx: ctxt) -> ~str {
let mut res = ~[];
- do self.builtin_bounds.each |b| {
+ for b in self.builtin_bounds.iter() {
res.push(match b {
ty::BoundStatic => ~"'static",
ty::BoundSend => ~"Send",
ty::BoundFreeze => ~"Freeze",
ty::BoundSized => ~"Sized",
});
- true
- };
+ }
for t in self.trait_bounds.iter() {
res.push(t.repr(tcx));
}
fn user_string(&self, tcx: ctxt) -> ~str {
if self.is_empty() { ~"<no-bounds>" } else {
let mut result = ~[];
- do self.each |bb| {
+ for bb in self.iter() {
result.push(bb.user_string(tcx));
- true
- };
+ }
result.connect("+")
}
}
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()
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())
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
})
};
#[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]
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]
let config = parse_config([
~"rustdoc", ~"crate.rc", ~"--output-format", ~"markdown"
]);
- assert!(config.get().output_format == Markdown);
+ assert!(config.unwrap().output_format == Markdown);
}
#[test]
let config = parse_config([
~"rustdoc", ~"crate.rc", ~"--output-format", ~"html"
]);
- assert!(config.get().output_format == PandocHtml);
+ assert!(config.unwrap().output_format == PandocHtml);
}
#[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]
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]
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]
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]
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"));
}
}
return None
}
- parse_desc(desc.clone().get())
+ parse_desc(desc.clone().unwrap())
}
fn parse_desc(desc: ~str) -> Option<~str> {
doc::CratePage(doc) => Some(doc),
_ => None
}
- }).get()
+ }).unwrap()
}
pub fn cratemod(&self) -> ModDoc {
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,
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,
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]
~"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",
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);
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]
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())
#[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 {"));
}
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"));
}
}
// 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;
}
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()
};
* in is the working directory.
*/
pub fn work_dir() -> Path {
- os::self_exe_path().get()
+ os::self_exe_path().unwrap()
}
/**
}
+ 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 },
* 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
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 {
}
}
+// 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 {
}
}
+// 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),
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)
+ #[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));
}
-}
-/// 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
+ #[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));
}
-}
-/// 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
+ #[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]);
}
-}
-/// 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())
+ #[test]
+ fn test_lefts_none() {
+ let input: ~[Either<int, int>] = ~[Right(10), Right(10)];
+ let result = lefts(input);
+ assert_eq!(result.len(), 0u);
}
-}
-/// 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())
+ #[test]
+ fn test_lefts_empty() {
+ let input: ~[Either<int, int>] = ~[];
+ let result = lefts(input);
+ assert_eq!(result.len(), 0u);
}
-}
-/// 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_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 flip(self) -> Either<U, T> { flip(self) }
-
- #[inline]
- pub fn to_result(self) -> Result<U, T> { to_result(self) }
-
- #[inline]
- pub fn is_left(&self) -> bool { is_left(self) }
-
- #[inline]
- pub fn is_right(&self) -> bool { is_right(self) }
-
- #[inline]
- pub fn expect_left(self, reason: &str) -> T { expect_left(self, reason) }
-
- #[inline]
- pub fn unwrap_left(self) -> T { unwrap_left(self) }
-
- #[inline]
- pub fn expect_right(self, reason: &str) -> U { expect_right(self, reason) }
-
- #[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_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_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() {
- 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_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_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);
+ }
-#[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);
}
use clone::Clone;
use cmp::{Eq, Equiv};
use hash::Hash;
-use iterator::{Iterator, IteratorUtil, FromIterator, Extendable, Chain, range};
+use iterator::{Iterator, IteratorUtil, FromIterator, Extendable, range};
+use iterator::{FilterMap, Chain, Repeat, Zip};
use num;
use option::{None, Option, Some};
use rand::RngUtil;
}
/// Visit the values representing the difference
- pub fn difference_iter<'a>(&'a self, other: &'a HashSet<T>)
- -> SetAlgebraIter<'a, T> {
- EnvFilterIterator{iter: self.iter(), env: other,
- filter: |elt, other| !other.contains(elt) }
+ pub fn difference_iter<'a>(&'a self, other: &'a HashSet<T>) -> SetAlgebraIter<'a, T> {
+ Repeat::new(other)
+ .zip(self.iter())
+ .filter_map(|(other, elt)| {
+ if !other.contains(elt) { Some(elt) } else { None }
+ })
}
/// Visit the values representing the symmetric difference
/// Visit the values representing the intersection
pub fn intersection_iter<'a>(&'a self, other: &'a HashSet<T>)
-> SetAlgebraIter<'a, T> {
- EnvFilterIterator{iter: self.iter(), env: other,
- filter: |elt, other| other.contains(elt) }
+ Repeat::new(other)
+ .zip(self.iter())
+ .filter_map(|(other, elt)| {
+ if other.contains(elt) { Some(elt) } else { None }
+ })
}
/// Visit the values representing the union
}
}
-// FIXME #7814: use std::iterator::FilterIterator
-/// Building block for Set operation iterators
-pub struct EnvFilterIterator<A, Env, I> {
- priv env: Env,
- priv filter: &'static fn(&A, Env) -> bool,
- priv iter: I,
-}
-
-impl<'self, A, Env: Clone, I: Iterator<&'self A>> Iterator<&'self A>
- for EnvFilterIterator<A, Env, I> {
- #[inline]
- fn next(&mut self) -> Option<&'self A> {
- loop {
- match self.iter.next() {
- Some(elt) => if (self.filter)(elt, self.env.clone()) {
- return Some(elt)
- },
- None => return None,
- }
- }
- }
-
- #[inline]
- fn size_hint(&self) -> (uint, Option<uint>) {
- let (_, upper) = self.iter.size_hint();
- (0, upper)
- }
-}
-
+// `Repeat` is used to feed the filter closure an explicit capture
+// of a reference to the other set
/// Set operations iterator
pub type SetAlgebraIter<'self, T> =
- EnvFilterIterator<T, &'self HashSet<T>, HashSetIterator<'self, T>>;
+ FilterMap<'static,(&'self HashSet<T>, &'self T), &'self T,
+ Zip<Repeat<&'self HashSet<T>>,HashSetIterator<'self,T>>>;
#[cfg(test)]
pub fn file_reader(path: &Path) -> Result<@Reader, ~str> {
let f = do path.to_str().as_c_str |pathbuf| {
- do "r".as_c_str |modebuf| {
+ do "rb".as_c_str |modebuf| {
unsafe { libc::fopen(pathbuf, modebuf as *libc::c_char) }
}
};
/// In the future these will be default methods instead of a utility trait.
impl<A, T: DoubleEndedIterator<A>> DoubleEndedIteratorUtil for T {
/// Flip the direction of the iterator
+ ///
+ /// The inverted iterator flips the ends on an iterator that can already
+ /// be iterated from the front and from the back.
+ ///
+ ///
+ /// If the iterator also implements RandomAccessIterator, the inverted
+ /// iterator is also random access, with the indices starting at the back
+ /// of the original iterator.
+ ///
+ /// Note: Random access with inverted indices still only applies to the first
+ /// `uint::max_value` elements of the original iterator.
#[inline]
fn invert(self) -> Invert<T> {
Invert{iter: self}
fn next_back(&mut self) -> Option<A> { self.iter.next() }
}
+impl<A, T: DoubleEndedIterator<A> + RandomAccessIterator<A>> RandomAccessIterator<A>
+ for Invert<T> {
+ #[inline]
+ fn indexable(&self) -> uint { self.iter.indexable() }
+ #[inline]
+ fn idx(&self, index: uint) -> Option<A> {
+ self.iter.idx(self.indexable() - index - 1)
+ }
+}
+
/// Iterator adaptors provided for every `Iterator` implementation. The adaptor objects are also
/// implementations of the `Iterator` trait.
///
}
}
+/// An iterator that repeats an element endlessly
+#[deriving(Clone, DeepClone)]
+pub struct Repeat<A> {
+ priv element: A
+}
+
+impl<A: Clone> Repeat<A> {
+ /// Create a new `Repeat` that enlessly repeats the element `elt`.
+ #[inline]
+ pub fn new(elt: A) -> Repeat<A> {
+ Repeat{element: elt}
+ }
+}
+
+impl<A: Clone> Iterator<A> for Repeat<A> {
+ #[inline]
+ fn next(&mut self) -> Option<A> { self.idx(0) }
+ #[inline]
+ fn size_hint(&self) -> (uint, Option<uint>) { (uint::max_value, None) }
+}
+
+impl<A: Clone> DoubleEndedIterator<A> for Repeat<A> {
+ #[inline]
+ fn next_back(&mut self) -> Option<A> { self.idx(0) }
+}
+
+impl<A: Clone> RandomAccessIterator<A> for Repeat<A> {
+ #[inline]
+ fn indexable(&self) -> uint { uint::max_value }
+ #[inline]
+ fn idx(&self, _: uint) -> Option<A> { Some(self.element.clone()) }
+}
+
#[cfg(test)]
mod tests {
use super::*;
check_randacc_iter(xs.iter().enumerate(), xs.len());
}
+ #[test]
+ fn test_random_access_invert() {
+ let xs = [1, 2, 3, 4, 5];
+ check_randacc_iter(xs.iter().invert(), xs.len());
+ let mut it = xs.iter().invert();
+ it.next();
+ it.next_back();
+ it.next();
+ check_randacc_iter(it, xs.len() - 3);
+ }
+
#[test]
fn test_random_access_zip() {
let xs = [1, 2, 3, 4, 5];
// 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]
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());
}
None => fail!("missing value")
}
});
- assert!(*(pop(my_key).get()) == ~"next data");
+ assert!(*(pop(my_key).unwrap()) == ~"next data");
}
#[test]
float::to_str(rng.gen());
}
}
-}
\ No newline at end of file
+}
///
pub fn div_floor(x: uint, y: uint) -> uint { return x / y; }
-///
-/// Iterate over the range [`lo`..`hi`), or stop when requested
-///
-/// # Arguments
-///
-/// * lo - The integer at which to start the loop (included)
-/// * hi - The integer at which to stop the loop (excluded)
-/// * it - A block to execute with each consecutive integer of the range.
-/// Return `true` to continue, `false` to stop.
-///
-/// # Return value
-///
-/// `true` If execution proceeded correctly, `false` if it was interrupted,
-/// that is if `it` returned `false` at any point.
-///
-pub fn iterate(lo: uint, hi: uint, it: &fn(uint) -> bool) -> bool {
- let mut i = lo;
- while i < hi {
- if (!it(i)) { return false; }
- i += 1u;
- }
- return true;
-}
-
impl iter::Times for uint {
#[inline]
///
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
}
}
-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]
- pub fn iter<'r>(&'r self) -> OptionIterator<'r, T> {
+ pub fn iter<'r>(&'r self) -> OptionIterator<&'r T> {
match *self {
Some(ref x) => OptionIterator{opt: Some(x)},
None => OptionIterator{opt: None}
/// Return a mutable iterator over the possibly contained value
#[inline]
- pub fn mut_iter<'r>(&'r mut self) -> OptionMutIterator<'r, T> {
+ pub fn mut_iter<'r>(&'r mut self) -> OptionIterator<&'r mut T> {
match *self {
- Some(ref mut x) => OptionMutIterator{opt: Some(x)},
- None => OptionMutIterator{opt: None}
+ Some(ref mut x) => OptionIterator{opt: Some(x)},
+ None => OptionIterator{opt: None}
}
}
+ /// Return a consuming iterator over the possibly contained value
+ #[inline]
+ pub fn consume(self) -> OptionIterator<T> {
+ OptionIterator{opt: self}
+ }
+
/// Returns true if the option equals `None`
#[inline]
pub fn is_none(&self) -> bool {
/// 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
/// 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
}
}
- /**
- 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()),
+ 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.
- */
+ /// Returns the contained value or a default
#[inline]
- pub fn get(self) -> T {
+ pub fn unwrap_or_default(self, def: T) -> T {
match self {
- Some(x) => return x,
- None => fail!("option::get `None`")
+ Some(x) => x,
+ None => def
}
}
- /// Returns the contained value or a default
- #[inline]
- pub fn get_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`.
#[inline]
pub fn while_some(self, blk: &fn(v: 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> {
fn is_zero(&self) -> bool { self.is_none() }
}
-/// Immutable iterator over an `Option<A>`
-pub struct OptionIterator<'self, A> {
- priv opt: Option<&'self A>
+/// An iterator that yields either one or zero elements
+pub struct OptionIterator<A> {
+ priv opt: Option<A>
}
-impl<'self, A> Iterator<&'self A> for OptionIterator<'self, A> {
- fn next(&mut self) -> Option<&'self A> {
- util::replace(&mut self.opt, None)
- }
-
- fn size_hint(&self) -> (uint, Option<uint>) {
- match self.opt {
- Some(_) => (1, Some(1)),
- None => (0, Some(0)),
- }
- }
-}
-
-/// Mutable iterator over an `Option<A>`
-pub struct OptionMutIterator<'self, A> {
- priv opt: Option<&'self mut A>
-}
-
-impl<'self, A> Iterator<&'self mut A> for OptionMutIterator<'self, A> {
- fn next(&mut self) -> Option<&'self mut A> {
- util::replace(&mut self.opt, None)
+impl<A> Iterator<A> for OptionIterator<A> {
+ #[inline]
+ fn next(&mut self) -> Option<A> {
+ self.opt.take()
}
+ #[inline]
fn size_hint(&self) -> (uint, Option<uint>) {
match self.opt {
Some(_) => (1, Some(1)),
use util;
#[test]
- fn test_unwrap_ptr() {
+ fn test_get_ptr() {
unsafe {
let x = ~0;
let addr_x: *int = ::cast::transmute(&*x);
}
#[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);
}
#[test]
- fn test_unwrap_resource() {
+ fn test_get_resource() {
struct R {
i: @mut int,
}
}
#[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());
}
#[cfg(unix)]
fn lookup() -> Path {
- getenv_nonempty("TMPDIR").get_or_default(Path("/tmp"))
+ getenv_nonempty("TMPDIR").unwrap_or_default(Path("/tmp"))
}
#[cfg(windows)]
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"))
}
}
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
use cast;
use clone::Clone;
+use iterator::{range, Iterator};
use option::{Option, Some, None};
use unstable::intrinsics;
use util::swap;
#[cfg(not(test))] use num::Int;
#[cfg(not(test))] use cmp::{Eq, Ord};
-use uint;
/// Calculate the offset from a pointer
#[inline]
fail!("ptr::array_each_with_len failure: arr input is null pointer");
}
//let start_ptr = *arr;
- uint::iterate(0, len, |e| {
+ for e in range(0, len) {
let n = offset(arr, e as int);
cb(*n);
- true
- });
+ }
debug!("array_each_with_len: after iterate");
}
/// 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
* 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()
}
/**
use cmp::Eq;
use either;
use iterator::Iterator;
-use option::{None, Option, Some};
+use option::{None, Option, Some, OptionIterator};
use vec;
use vec::{OwnedVector, ImmutableVector};
use container::Container;
-
-/// The result type
+use to_str::ToStr;
+use str::StrSlice;
+
+/// `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 {
}
}
- /**
- * 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()),
}
}
!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:
+ ///
+ /// for buf in read_file(file) {
+ /// print_buf(buf)
+ /// }
#[inline]
- pub fn iter(&self, f: &fn(&T)) {
+ pub fn iter<'r>(&'r self) -> OptionIterator<&'r T> {
match *self {
- Ok(ref t) => f(t),
- Err(_) => (),
- }
+ Ok(ref t) => Some(t),
+ Err(*) => None,
+ }.consume()
}
- /**
- * 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)) {
+ pub fn iter_err<'r>(&'r self) -> OptionIterator<&'r E> {
match *self {
- Ok(_) => (),
- Err(ref e) => f(e),
- }
+ Ok(*) => None,
+ Err(ref t) => Some(t),
+ }.consume()
}
- /// 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 {
+ Ok(t) => t,
+ Err(_) => fail!(reason.to_owned()),
+ }
+ }
+
+ /// 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!("unwrap called on an `Ok` result"),
+ 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))
- * };
- */
+ /// 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 {
}
}
- /**
- * 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 {
}
}
-impl<T: Clone, E> Result<T, E> {
- /**
- * Get the value out of a successful result
- *
- * # Failure
- *
- * If the result is 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.
- */
+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 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))
}
}
-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 {
+ pub fn map<U>(&self, op: &fn(&T) -> U) -> Result<U,E> {
match *self {
- Err(ref e) => e.clone(),
- Ok(_) => fail!("get_err called on `Ok` result")
+ Ok(ref t) => Ok(op(t)),
+ Err(ref e) => Err(e.clone())
}
}
+}
- /**
- * 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> {
- match *self {
- Ok(ref t) => Ok(op(t)),
- Err(ref e) => Err(e.clone())
+#[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)
}
}
}
-/**
- * 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]);
- * }
- */
+// 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> {
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);
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;
#[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]
pub fn test_impl_iter() {
let mut valid = false;
- Ok::<~str, ~str>(~"a").iter(|_x| valid = true);
+ let okval = Ok::<~str, ~str>(~"a");
+ do okval.iter().next().map |_| { valid = true; };
assert!(valid);
- Err::<~str, ~str>(~"b").iter(|_x| valid = false);
+ let errval = Err::<~str, ~str>(~"b");
+ do errval.iter().next().map |_| { valid = false; };
assert!(valid);
}
#[test]
pub fn test_impl_iter_err() {
let mut valid = true;
- Ok::<~str, ~str>(~"a").iter_err(|_x| valid = false);
+ let okval = Ok::<~str, ~str>(~"a");
+ do okval.iter_err().next().map |_| { valid = false };
assert!(valid);
valid = false;
- Err::<~str, ~str>(~"b").iter_err(|_x| valid = true);
+ let errval = Err::<~str, ~str>(~"b");
+ do errval.iter_err().next().map |_| { valid = true };
assert!(valid);
}
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);
*/
use prelude::*;
+use to_str::ToStr;
+use str::{StrSlice, OwnedStr};
// Reexports
pub use self::stdio::stdin;
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,
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! {
desc: "Placeholder error. You shouldn't be seeing this",
detail: None
}
-}
\ No newline at end of file
+}
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,
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");
}
}
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.
use os::getenv;
match getenv("RUST_RT_STRESS") {
- Some(val) => uint::from_str(val).get(),
+ Some(val) => uint::from_str(val).unwrap(),
None => 1
}
}
/// 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()
}
}
extern {
fn rust_get_exit_status_newrt() -> libc::uintptr_t;
}
-}
\ No newline at end of file
+}
"" => ~[],
// 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
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();
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();
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());
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 {
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 {
let new_len = s.len() + 1;
s.reserve_at_least(new_len);
do s.as_mut_buf |buf, len| {
- *ptr::mut_offset(buf, len as int) = b;
+ *ptr::mut_offset(buf, (len-1) as int) = b;
}
set_len(&mut *s, new_len);
}
assert!(!" _ ".is_whitespace());
}
+ #[test]
+ fn test_push_byte() {
+ let mut s = ~"ABC";
+ unsafe{raw::push_byte(&mut s, 'D' as u8)};
+ assert_eq!(s, ~"ABCD");
+ }
+
#[test]
fn test_shift_byte() {
let mut s = ~"ABC";
t.name(~"ada lovelace");
do t.spawn {
do with_task_name |name| {
- assert!(name.get() == "ada lovelace");
+ assert!(name.unwrap() == "ada lovelace");
}
}
}
use iterator::{IteratorUtil, FromIterator, Extendable};
use uint;
use util::{swap, replace};
+use vec;
// FIXME: #5244: need to manually update the TrieNode constructor
static SHIFT: uint = 4;
pub fn each_value_reverse(&self, f: &fn(&T) -> bool) -> bool {
self.each_reverse(|_, v| f(v))
}
+
+ /// Get an iterator over the key-value pairs in the map
+ pub fn iter<'a>(&'a self) -> TrieMapIterator<'a, T> {
+ TrieMapIterator {
+ stack: ~[self.root.children.iter()],
+ remaining_min: self.length,
+ remaining_max: self.length
+ }
+ }
}
impl<T, Iter: Iterator<(uint, T)>> FromIterator<(uint, T), Iter> for TrieMap<T> {
pub fn each_reverse(&self, f: &fn(&uint) -> bool) -> bool {
self.map.each_key_reverse(f)
}
+
+ /// Get an iterator over the values in the set
+ #[inline]
+ pub fn iter<'a>(&'a self) -> TrieSetIterator<'a> {
+ TrieSetIterator{iter: self.map.iter()}
+ }
}
impl<Iter: Iterator<uint>> FromIterator<uint, Iter> for TrieSet {
return ret;
}
+/// Forward iterator over a map
+pub struct TrieMapIterator<'self, T> {
+ priv stack: ~[vec::VecIterator<'self, Child<T>>],
+ priv remaining_min: uint,
+ priv remaining_max: uint
+}
+
+impl<'self, T> Iterator<(uint, &'self T)> for TrieMapIterator<'self, T> {
+ fn next(&mut self) -> Option<(uint, &'self T)> {
+ while !self.stack.is_empty() {
+ match self.stack[self.stack.len() - 1].next() {
+ None => {
+ self.stack.pop();
+ }
+ Some(ref child) => {
+ match **child {
+ Internal(ref node) => {
+ self.stack.push(node.children.iter());
+ }
+ External(key, ref value) => {
+ self.remaining_max -= 1;
+ if self.remaining_min > 0 {
+ self.remaining_min -= 1;
+ }
+ return Some((key, value));
+ }
+ Nothing => {}
+ }
+ }
+ }
+ }
+ return None;
+ }
+
+ #[inline]
+ fn size_hint(&self) -> (uint, Option<uint>) {
+ (self.remaining_min, Some(self.remaining_max))
+ }
+}
+
+/// Forward iterator over a set
+pub struct TrieSetIterator<'self> {
+ priv iter: TrieMapIterator<'self, ()>
+}
+
+impl<'self> Iterator<uint> for TrieSetIterator<'self> {
+ fn next(&mut self) -> Option<uint> {
+ do self.iter.next().map |&(key, _)| { key }
+ }
+
+ fn size_hint(&self) -> (uint, Option<uint>) {
+ self.iter.size_hint()
+ }
+}
+
#[cfg(test)]
pub fn check_integrity<T>(trie: &TrieNode<T>) {
assert!(trie.count != 0);
assert_eq!(map.find(&k), Some(&v));
}
}
+
+ #[test]
+ fn test_iteration() {
+ let empty_map : TrieMap<uint> = TrieMap::new();
+ assert_eq!(empty_map.iter().next(), None);
+
+ let first = uint::max_value - 10000;
+ let last = uint::max_value;
+
+ let mut map = TrieMap::new();
+ do uint::range_rev(last, first) |x| {
+ map.insert(x, x / 2);
+ true
+ };
+
+ let mut i = 0;
+ for (k, &v) in map.iter() {
+ assert_eq!(k, first + i);
+ assert_eq!(v, k / 2);
+ i += 1;
+ }
+ assert_eq!(i, last - first);
+ }
}
#[cfg(test)]
* 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
/// An iterator over the (overlapping) slices of length `size` within
/// a vector.
+#[deriving(Clone)]
pub struct WindowIter<'self, T> {
priv v: &'self [T],
priv size: uint
/// An iterator over a vector in (non-overlapping) chunks (`size`
/// elements at a time).
+///
+/// When the vector len is not evenly divided by the chunk size,
+/// the last slice of the iteration will be the remainer.
+#[deriving(Clone)]
pub struct ChunkIter<'self, T> {
priv v: &'self [T],
priv size: uint
impl<'self, T> Iterator<&'self [T]> for ChunkIter<'self, T> {
fn next(&mut self) -> Option<&'self [T]> {
- if self.size == 0 {
+ if self.v.len() == 0 {
None
- } else if self.size >= self.v.len() {
- // finished
- self.size = 0;
- Some(self.v)
} else {
- let ret = Some(self.v.slice(0, self.size));
- self.v = self.v.slice(self.size, self.v.len());
- ret
+ let chunksz = cmp::min(self.v.len(), self.size);
+ let (fst, snd) = (self.v.slice_to(chunksz),
+ self.v.slice_from(chunksz));
+ self.v = snd;
+ Some(fst)
+ }
+ }
+}
+
+impl<'self, T> DoubleEndedIterator<&'self [T]> for ChunkIter<'self, T> {
+ fn next_back(&mut self) -> Option<&'self [T]> {
+ if self.v.len() == 0 {
+ None
+ } else {
+ let remainder = self.v.len() % self.size;
+ let chunksz = if remainder != 0 { remainder } else { self.size };
+ let (fst, snd) = (self.v.slice_to(self.v.len() - chunksz),
+ self.v.slice_from(self.v.len() - chunksz));
+ self.v = fst;
+ Some(snd)
+ }
+ }
+}
+
+impl<'self, T> RandomAccessIterator<&'self [T]> for ChunkIter<'self, T> {
+ #[inline]
+ fn indexable(&self) -> uint {
+ self.v.len()/self.size + if self.v.len() % self.size != 0 { 1 } else { 0 }
+ }
+
+ #[inline]
+ fn idx(&self, index: uint) -> Option<&'self [T]> {
+ if index < self.indexable() {
+ let lo = index * self.size;
+ let mut hi = lo + self.size;
+ if hi < lo || hi > self.v.len() { hi = self.v.len(); }
+
+ Some(self.v.slice(lo, hi))
+ } else {
+ None
}
}
}
assert_eq!(v.chunk_iter(2).collect::<~[&[int]]>(), ~[&[1i,2], &[3,4], &[5]]);
assert_eq!(v.chunk_iter(3).collect::<~[&[int]]>(), ~[&[1i,2,3], &[4,5]]);
assert_eq!(v.chunk_iter(6).collect::<~[&[int]]>(), ~[&[1i,2,3,4,5]]);
+
+ assert_eq!(v.chunk_iter(2).invert().collect::<~[&[int]]>(), ~[&[5i], &[3,4], &[1,2]]);
+ let it = v.chunk_iter(2);
+ assert_eq!(it.indexable(), 3);
+ assert_eq!(it.idx(0).unwrap(), &[1,2]);
+ assert_eq!(it.idx(1).unwrap(), &[3,4]);
+ assert_eq!(it.idx(2).unwrap(), &[5]);
+ assert_eq!(it.idx(3), None);
}
#[test]
#[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]
// 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:
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,
/// 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)
return @FileLines {file: lo.file, lines: lines};
}
- pub fn span_to_snippet(&self, sp: span) -> ~str {
+ pub fn span_to_snippet(&self, sp: span) -> Option<~str> {
let begin = self.lookup_byte_offset(sp.lo);
let end = self.lookup_byte_offset(sp.hi);
- assert_eq!(begin.fm.start_pos, end.fm.start_pos);
- return begin.fm.src.slice(
- begin.pos.to_uint(), end.pos.to_uint()).to_owned();
+
+ // FIXME #8256: this used to be an assert but whatever precondition
+ // it's testing isn't true for all spans in the AST, so to allow the
+ // caller to not have to fail (and it can't catch it since the CodeMap
+ // isn't sendable), return None
+ if begin.fm.start_pos != end.fm.start_pos {
+ None
+ } else {
+ Some(begin.fm.src.slice( begin.pos.to_uint(), end.pos.to_uint()).to_owned())
+ }
}
pub fn get_filemap(&self, filename: &str) -> @FileMap {
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);
}
}
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)
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 }");
-> 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))
-> 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()))
}
-> 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))
*/
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();
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 }
}
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);
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,
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, "#[");
}
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
}
_ => {
// not sure if this can happen.
- print_expr(s, blk.get());
+ print_expr(s, blk.unwrap());
}
}
}
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
}
}
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
}
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
}
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);
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;
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 = ~[];
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 = ~[];
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);
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);
} 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));
}
// except according to those terms.
extern mod extra;
-use extra::arena;
+use extra::arena::Arena;
enum Tree<'self> {
Nil,
}
}
-fn bottom_up_tree<'r>(arena: &'r arena::Arena, item: int, depth: int)
+fn bottom_up_tree<'r>(arena: &'r Arena, item: int, depth: int)
-> &'r Tree<'r> {
if depth > 0 {
return arena.alloc(
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 {
max_depth = n;
}
- let stretch_arena = arena::Arena();
+ let stretch_arena = Arena::new();
let stretch_depth = max_depth + 1;
let stretch_tree = bottom_up_tree(&stretch_arena, 0, stretch_depth);
stretch_depth,
item_check(stretch_tree));
- let long_lived_arena = arena::Arena();
+ let long_lived_arena = Arena::new();
let long_lived_tree = bottom_up_tree(&long_lived_arena, 0, max_depth);
let mut depth = min_depth;
while depth <= max_depth {
args
};
- let nn = uint::from_str(args[1]).get();
+ let nn = uint::from_str(args[1]).unwrap();
print_complements();
io::println("");
#[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);
}
#[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";
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),
} else {
args
};
- let n = int::from_str(args[1]).get();
+ let n = int::from_str(args[1]).unwrap();
printfln!("%d\n", fib(n));
}
#[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;
}
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);
if opts.stress {
stress(2);
} else {
- let max = uint::parse_bytes(args[1].as_bytes(), 10u).get() as int;
+ let max = uint::parse_bytes(args[1].as_bytes(), 10u).unwrap() as int;
let num_trials = 10;
#[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();
let mut u = vec::from_elem(n, 1f64);
let mut v = u.clone();
let mut tmp = u.clone();
os::args()
};
let token = if args.len() > 1u {
- FromStr::from_str(args[1]).get()
+ FromStr::from_str(args[1]).unwrap()
}
else {
1000
};
let n_tasks = if args.len() > 2u {
- FromStr::from_str(args[2]).get()
+ FromStr::from_str(args[2]).unwrap()
}
else {
503
} else {
args
};
- let max = uint::from_str(args[1]).get();
- let rep = uint::from_str(args[2]).get();
+ let max = uint::from_str(args[1]).unwrap();
+ let rep = uint::from_str(args[2]).unwrap();
let mut checkf = 0.0;
let mut appendf = 0.0;
let comps: ~[&str] = line.trim().split_iter(',').collect();
if comps.len() == 3u {
- let row = uint::from_str(comps[0]).get() as u8;
- let col = uint::from_str(comps[1]).get() as u8;
- g[row][col] = uint::from_str(comps[2]).get() as u8;
+ let row = uint::from_str(comps[0]).unwrap() as u8;
+ let col = uint::from_str(comps[1]).unwrap() as u8;
+ g[row][col] = uint::from_str(comps[2]).unwrap() as u8;
}
else {
fail!("Invalid sudoku file");
};
let (p,c) = comm::stream();
- child_generation(uint::from_str(args[1]).get(), c);
+ child_generation(uint::from_str(args[1]).unwrap(), c);
if p.try_recv().is_none() {
fail!("it happened when we slumbered");
}
args.clone()
};
- let num_tasks = uint::from_str(args[1]).get();
+ let num_tasks = uint::from_str(args[1]).unwrap();
// Main group #0 waits for unsupervised group #1.
// Grandparent group #1 waits for middle group #2, then fails, killing #3.
} else {
args
};
- let n = uint::from_str(args[1]).get();
+ let n = uint::from_str(args[1]).unwrap();
let mut i = 0u;
while i < n { task::spawn(|| f(n) ); i += 1u; }
}
y = Some(x.downgrade(write_mode));
//~^ ERROR cannot infer an appropriate lifetime
}
- y.get();
+ y.unwrap();
// Adding this line causes a method unification failure instead
// do (&option::unwrap(y)).read |state| { assert!(*state == 1); }
}
do x.write_downgrade |write_mode| {
y = Some(write_mode);
}
- y.get();
+ y.unwrap();
// Adding this line causes a method unification failure instead
// do (&option::unwrap(y)).write |state| { assert!(*state == 1); }
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// error-pattern:get called on `Err` result: ~"kitty"
+// error-pattern:called `Result::unwrap()` on `Err` value: kitty
use std::result;
fn main() {
- error!(result::Err::<int,~str>(~"kitty").get());
+ error!(result::Err::<int,~str>(~"kitty").unwrap());
}
fn g(x: &Option<int>) {
- println(x.get().to_str());
+ println(x.unwrap().to_str());
}
fn f(x: &mut Option<int>) {
pub fn main() {
let x = None;
let y = Some(3);
- assert_eq!(select(&x, &y).get(), 3);
+ assert_eq!(select(&x, &y).unwrap(), 3);
}
// except according to those terms.
pub fn main() {
- let foo = 1;
- let bar = 2;
+ let foo: int = 1;
+ let bar: int = 2;
let foobar = foo + bar;
- let nope = optint(0) + optint(0);
- let somefoo = optint(foo) + optint(0);
- let somebar = optint(bar) + optint(0);
- let somefoobar = optint(foo) + optint(bar);
+ let nope = None::<int> + None::<int>;
+ let somefoo = Some(foo) + None::<int>;
+ let somebar = None::<int> + Some(bar);
+ let somefoobar = Some(foo) + Some(bar);
- match nope {
- None => (),
- Some(foo) => fail!("expected None, but found %?", foo)
- }
- assert_eq!(foo, somefoo.get());
- assert_eq!(bar, somebar.get());
- assert_eq!(foobar, somefoobar.get());
-}
-
-fn optint(input: int) -> Option<int> {
- if input == 0 {
- return None;
- }
- else {
- return Some(input);
- }
+ assert_eq!(nope, None::<int>);
+ assert_eq!(somefoo, None::<int>);
+ assert_eq!(somebar, None::<int>);
+ assert_eq!(foobar, somefoobar.unwrap());
}
// except according to those terms.
extern mod extra;
-use extra::arena;
+use extra::arena::Arena;
pub fn main() {
- let mut arena = arena::Arena();
+ let mut arena = Arena::new();
let p = &mut arena;
let x = p.alloc(|| 4u);
printf!("%u", *x);
assert_eq!(*p, a.value.v5.f);
let p = get_v6_a(&a, 1);
- assert_eq!(*p, a.value.v6.get().f);
+ assert_eq!(*p, a.value.v6.unwrap().f);
let p = get_v6_b(&a, 1);
- assert_eq!(*p, a.value.v6.get().f);
+ assert_eq!(*p, a.value.v6.unwrap().f);
let p = get_v6_c(&a, 1);
- assert_eq!(*p, a.value.v6.get().f);
+ assert_eq!(*p, a.value.v6.unwrap().f);
let p = get_v5_ref(&a, 1);
assert_eq!(*p, a.value.v5.f);
projects / rust.git / commitdiff