This lazily initializes the taskgroup structs for ```spawn_unlinked``` tasks. If such a task never spawns another task linked to it (or a descendant of it), its taskgroup is simply never initialized at all. Also if an unlinked task spawns another unlinked task, neither of them will need to initialize their taskgroups. This works for the main task too.
I benchmarked this with the following test case and observed a ~~21% speedup (average over 4 runs: 7.85 sec -> 6.20 sec, 2.5 GHz)~~ 11% speedup, see comment below.
```
use std::task;
use std::cell::Cell;
use std::rt::comm;
static NUM: uint = 1024*256;
fn run(f: ~fn()) {
let mut t = task::task();
t.unlinked();
t.spawn(f);
}
fn main() {
do NUM.times {
let (p,c) = comm::oneshot();
let c = Cell::new(c);
do run { c.take().send(()); }
p.recv();
}
}
```
| $$(TLIB$(1)_T_$(2)_H_$(3))/
@$$(call E, compile_and_link: $$@)
$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(STDLIB_GLOB_$(2)),$$(notdir $$@))
- $$(STAGE$(1)_T_$(2)_H_$(3)) $$(WFLAGS_ST$(1)) -o $$@ $$< && touch $$@
+ $$(STAGE$(1)_T_$(2)_H_$(3)) $$(WFLAGS_ST$(1)) --out-dir $$(@D) $$< && touch $$@
$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(STDLIB_GLOB_$(2)),$$(notdir $$@))
$$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_EXTRALIB_$(2)): \
| $$(TLIB$(1)_T_$(2)_H_$(3))/
@$$(call E, compile_and_link: $$@)
$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(EXTRALIB_GLOB_$(2)),$$(notdir $$@))
- $$(STAGE$(1)_T_$(2)_H_$(3)) $$(WFLAGS_ST$(1)) -o $$@ $$< && touch $$@
+ $$(STAGE$(1)_T_$(2)_H_$(3)) $$(WFLAGS_ST$(1)) --out-dir $$(@D) $$< && touch $$@
$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(EXTRALIB_GLOB_$(2)),$$(notdir $$@))
$$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_LIBSYNTAX_$(3)): \
| $$(TLIB$(1)_T_$(2)_H_$(3))/
@$$(call E, compile_and_link: $$@)
$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBSYNTAX_GLOB_$(2)),$$(notdir $$@))
- $$(STAGE$(1)_T_$(2)_H_$(3)) $(BORROWCK) -o $$@ $$< && touch $$@
+ $$(STAGE$(1)_T_$(2)_H_$(3)) $(BORROWCK) --out-dir $$(@D) $$< && touch $$@
$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBSYNTAX_GLOB_$(2)),$$(notdir $$@))
# Only build the compiler for host triples
| $$(TLIB$(1)_T_$(2)_H_$(3))/
@$$(call E, compile_and_link: $$@)
$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTC_GLOB_$(2)),$$(notdir $$@))
- $$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< && touch $$@
+ $$(STAGE$(1)_T_$(2)_H_$(3)) --out-dir $$(@D) $$< && touch $$@
$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTC_GLOB_$(2)),$$(notdir $$@))
$$(TBIN$(1)_T_$(2)_H_$(3))/rustc$$(X_$(3)): \
| $$(TLIB$(1)_T_$(4)_H_$(3))/
@$$(call E, compile_and_link: $$@)
$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTPKG_GLOB_$(4)),$$(notdir $$@))
- $$(STAGE$(1)_T_$(4)_H_$(3)) $$(WFLAGS_ST$(1)) -o $$@ $$< && touch $$@
+ $$(STAGE$(1)_T_$(4)_H_$(3)) $$(WFLAGS_ST$(1)) --out-dir $$(@D) $$< && touch $$@
$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTPKG_GLOB_$(4)),$$(notdir $$@))
$$(TBIN$(1)_T_$(4)_H_$(3))/rustpkg$$(X_$(4)): \
| $$(TLIB$(1)_T_$(4)_H_$(3))/
@$$(call E, compile_and_link: $$@)
$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTDOC_GLOB_$(4)),$$(notdir $$@))
- $$(STAGE$(1)_T_$(4)_H_$(3)) -o $$@ $$< && touch $$@
+ $$(STAGE$(1)_T_$(4)_H_$(3)) --out-dir $$(@D) $$< && touch $$@
$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTDOC_GLOB_$(4)),$$(notdir $$@))
$$(TBIN$(1)_T_$(4)_H_$(3))/rustdoc$$(X_$(4)): \
| $$(TLIB$(1)_T_$(4)_H_$(3))/
@$$(call E, compile_and_link: $$@)
$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTI_GLOB_$(4)),$$(notdir $$@))
- $$(STAGE$(1)_T_$(4)_H_$(3)) -o $$@ $$< && touch $$@
+ $$(STAGE$(1)_T_$(4)_H_$(3)) --out-dir $$(@D) $$< && touch $$@
$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTI_GLOB_$(4)),$$(notdir $$@))
$$(TBIN$(1)_T_$(4)_H_$(3))/rusti$$(X_$(4)): \
| $$(TLIB$(1)_T_$(4)_H_$(3))/
@$$(call E, compile_and_link: $$@)
$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUST_GLOB_$(4)),$$(notdir $$@))
- $$(STAGE$(1)_T_$(4)_H_$(3)) -o $$@ $$< && touch $$@
+ $$(STAGE$(1)_T_$(4)_H_$(3)) --out-dir $$(@D) $$< && touch $$@
$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUST_GLOB_$(4)),$$(notdir $$@))
$$(TBIN$(1)_T_$(4)_H_$(3))/rust$$(X_$(4)): \
#[crate_type = "bin"];
#[allow(non_camel_case_types)];
-#[allow(unrecognized_lint)]; // NOTE: remove after snapshot
#[deny(warnings)];
extern mod extra;
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_()
}
#[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())); }
use serialize::Encodable;
use serialize;
-use sort::Sort;
use treemap::TreeMap;
/// Represents a json value
Object(ref d0) => {
match *other {
Number(_) | String(_) | Boolean(_) | List(_) => false,
- Object(ref d1) => {
- let mut d0_flat = ~[];
- let mut d1_flat = ~[];
-
- // FIXME #4430: this is horribly inefficient...
- for (k, v) in d0.iter() {
- d0_flat.push((@(*k).clone(), @(*v).clone()));
- }
- d0_flat.qsort();
-
- for (k, v) in d1.iter() {
- d1_flat.push((@(*k).clone(), @(*v).clone()));
- }
- d1_flat.qsort();
-
- d0_flat < d1_flat
- }
+ Object(ref d1) => d0 < d1,
Null => true
}
}
#[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()) }
}
}
#[fixed_stack_segment]
pub fn compile_input(sess: Session, cfg: ast::CrateConfig, input: &input,
outdir: &Option<Path>, output: &Option<Path>) {
- let outputs = build_output_filenames(input, outdir, output, [], sess);
// We need nested scopes here, because the intermediate results can keep
// large chunks of memory alive and we want to free them as soon as
// possible to keep the peak memory usage low
- let trans = {
+ let (outputs, trans) = {
let expanded_crate = {
let crate = phase_1_parse_input(sess, cfg.clone(), input);
if stop_after_phase_1(sess) { return; }
};
let analysis = phase_3_run_analysis_passes(sess, expanded_crate);
if stop_after_phase_3(sess) { return; }
- phase_4_translate_to_llvm(sess, expanded_crate, &analysis, outputs)
+ let outputs = build_output_filenames(input, outdir, output, [], sess);
+ let trans = phase_4_translate_to_llvm(sess, expanded_crate,
+ &analysis, outputs);
+ (outputs, trans)
};
phase_5_run_llvm_passes(sess, &trans, outputs);
if stop_after_phase_5(sess) { return; }
};
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"
};
};
if *sess.building_library {
- // FIXME (#2401): We might want to warn here; we're actually not
- // going to respect the user's choice of library name when it
- // comes time to link, we'll be linking to
- // lib<basename>-<hash>-<version>.so no matter what.
+ sess.warn("ignoring specified output filename for library.");
}
if *odir != None {
#[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,
// Note that `break` and `loop` statements
// may cause additional edges.
- // NOTE: Is the condition considered part of the loop?
+ // Is the condition considered part of the loop?
let loopback = self.add_dummy_node([pred]); // 1
let cond_exit = self.expr(cond, loopback); // 2
let expr_exit = self.add_node(expr.id, [cond_exit]); // 3
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 {
use middle::trans::type_of;
use middle::ty;
use util::common::indenter;
+use util::ppaux::{Repr, vec_map_to_str};
use std::hashmap::HashMap;
use std::vec;
use syntax::ast_util::path_to_ident;
use syntax::ast_util;
use syntax::codemap::{span, dummy_sp};
-use syntax::print::pprust::pat_to_str;
// An option identifying a literal: either a unit-like struct or an
// expression.
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 \
data: ArmData<'self>
}
-pub fn match_to_str(bcx: @mut Block, m: &Match) -> ~str {
- if bcx.sess().verbose() {
- // for many programs, this just take too long to serialize
- fmt!("%?", m.pats.map(|p| pat_to_str(*p, bcx.sess().intr())))
- } else {
- fmt!("%u pats", m.pats.len())
+impl<'self> Repr for Match<'self> {
+ fn repr(&self, tcx: ty::ctxt) -> ~str {
+ if tcx.sess.verbose() {
+ // for many programs, this just take too long to serialize
+ self.pats.repr(tcx)
+ } else {
+ fmt!("%u pats", self.pats.len())
+ }
}
}
-pub fn matches_to_str(bcx: @mut Block, m: &[Match]) -> ~str {
- fmt!("%?", m.map(|n| match_to_str(bcx, n)))
-}
-
pub fn has_nested_bindings(m: &[Match], col: uint) -> bool {
for br in m.iter() {
match br.pats[col].node {
col: uint,
val: ValueRef)
-> ~[Match<'r>] {
- debug!("expand_nested_bindings(bcx=%s, m=%s, col=%u, val=%?)",
+ debug!("expand_nested_bindings(bcx=%s, m=%s, col=%u, val=%s)",
bcx.to_str(),
- matches_to_str(bcx, m),
+ m.repr(bcx.tcx()),
col,
bcx.val_to_str(val));
let _indenter = indenter();
bcx.sess().span_bug(
p.span,
fmt!("Expected an identifier pattern but found p: %s",
- pat_to_str(p, bcx.sess().intr())));
+ p.repr(bcx.tcx())));
}
}
val: ValueRef,
e: enter_pat)
-> ~[Match<'r>] {
- debug!("enter_match(bcx=%s, m=%s, col=%u, val=%?)",
+ debug!("enter_match(bcx=%s, m=%s, col=%u, val=%s)",
bcx.to_str(),
- matches_to_str(bcx, m),
+ m.repr(bcx.tcx()),
col,
bcx.val_to_str(val));
let _indenter = indenter();
}
}
- debug!("result=%s", matches_to_str(bcx, result));
+ debug!("result=%s", result.repr(bcx.tcx()));
return result;
}
col: uint,
val: ValueRef)
-> ~[Match<'r>] {
- debug!("enter_default(bcx=%s, m=%s, col=%u, val=%?)",
+ debug!("enter_default(bcx=%s, m=%s, col=%u, val=%s)",
bcx.to_str(),
- matches_to_str(bcx, m),
+ m.repr(bcx.tcx()),
col,
bcx.val_to_str(val));
let _indenter = indenter();
variant_size: uint,
val: ValueRef)
-> ~[Match<'r>] {
- debug!("enter_opt(bcx=%s, m=%s, col=%u, val=%?)",
+ debug!("enter_opt(bcx=%s, m=%s, col=%u, val=%s)",
bcx.to_str(),
- matches_to_str(bcx, m),
+ m.repr(bcx.tcx()),
col,
bcx.val_to_str(val));
let _indenter = indenter();
fields: &[ast::ident],
val: ValueRef)
-> ~[Match<'r>] {
- debug!("enter_rec_or_struct(bcx=%s, m=%s, col=%u, val=%?)",
+ debug!("enter_rec_or_struct(bcx=%s, m=%s, col=%u, val=%s)",
bcx.to_str(),
- matches_to_str(bcx, m),
+ m.repr(bcx.tcx()),
col,
bcx.val_to_str(val));
let _indenter = indenter();
val: ValueRef,
n_elts: uint)
-> ~[Match<'r>] {
- debug!("enter_tup(bcx=%s, m=%s, col=%u, val=%?)",
+ debug!("enter_tup(bcx=%s, m=%s, col=%u, val=%s)",
bcx.to_str(),
- matches_to_str(bcx, m),
+ m.repr(bcx.tcx()),
col,
bcx.val_to_str(val));
let _indenter = indenter();
val: ValueRef,
n_elts: uint)
-> ~[Match<'r>] {
- debug!("enter_tuple_struct(bcx=%s, m=%s, col=%u, val=%?)",
+ debug!("enter_tuple_struct(bcx=%s, m=%s, col=%u, val=%s)",
bcx.to_str(),
- matches_to_str(bcx, m),
+ m.repr(bcx.tcx()),
col,
bcx.val_to_str(val));
let _indenter = indenter();
col: uint,
val: ValueRef)
-> ~[Match<'r>] {
- debug!("enter_box(bcx=%s, m=%s, col=%u, val=%?)",
+ debug!("enter_box(bcx=%s, m=%s, col=%u, val=%s)",
bcx.to_str(),
- matches_to_str(bcx, m),
+ m.repr(bcx.tcx()),
col,
bcx.val_to_str(val));
let _indenter = indenter();
col: uint,
val: ValueRef)
-> ~[Match<'r>] {
- debug!("enter_uniq(bcx=%s, m=%s, col=%u, val=%?)",
+ debug!("enter_uniq(bcx=%s, m=%s, col=%u, val=%s)",
bcx.to_str(),
- matches_to_str(bcx, m),
+ m.repr(bcx.tcx()),
col,
bcx.val_to_str(val));
let _indenter = indenter();
col: uint,
val: ValueRef)
-> ~[Match<'r>] {
- debug!("enter_region(bcx=%s, m=%s, col=%u, val=%?)",
+ debug!("enter_region(bcx=%s, m=%s, col=%u, val=%s)",
bcx.to_str(),
- matches_to_str(bcx, m),
+ m.repr(bcx.tcx()),
col,
bcx.val_to_str(val));
let _indenter = indenter();
}
};
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)
);
vals: &[ValueRef],
chk: Option<mk_fail>)
-> @mut Block {
- debug!("compile_guard(bcx=%s, guard_expr=%s, m=%s, vals=%?)",
+ debug!("compile_guard(bcx=%s, guard_expr=%s, m=%s, vals=%s)",
bcx.to_str(),
bcx.expr_to_str(guard_expr),
- matches_to_str(bcx, m),
- vals.map(|v| bcx.val_to_str(*v)));
+ m.repr(bcx.tcx()),
+ vec_map_to_str(vals, |v| bcx.val_to_str(*v)));
let _indenter = indenter();
let mut bcx = bcx;
m: &[Match],
vals: &[ValueRef],
chk: Option<mk_fail>) {
- debug!("compile_submatch(bcx=%s, m=%s, vals=%?)",
+ debug!("compile_submatch(bcx=%s, m=%s, vals=%s)",
bcx.to_str(),
- matches_to_str(bcx, m),
- vals.map(|v| bcx.val_to_str(*v)));
+ m.repr(bcx.tcx()),
+ vec_map_to_str(vals, |v| bcx.val_to_str(*v)));
let _indenter = indenter();
/*
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 {
// Decide what kind of branch we need
let opts = get_options(bcx, m, col);
+ debug!("options=%?", opts);
let mut kind = no_branch;
let mut test_val = val;
if opts.len() > 0u {
debug!("bind_irrefutable_pat(bcx=%s, pat=%s, binding_mode=%?)",
bcx.to_str(),
- pat_to_str(pat, bcx.sess().intr()),
+ pat.repr(bcx.tcx()),
binding_mode);
if bcx.sess().asm_comments() {
add_comment(bcx, fmt!("bind_irrefutable_pat(pat=%s)",
- pat_to_str(pat, bcx.sess().intr())));
+ pat.repr(bcx.tcx())));
}
let _indenter = indenter();
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);
pub fn register_fn(ccx: @mut CrateContext,
sp: span,
sym: ~str,
- node_id: ast::NodeId)
- -> ValueRef {
- let t = ty::node_id_to_type(ccx.tcx, node_id);
- register_fn_full(ccx, sp, sym, node_id, t)
-}
-
-pub fn register_fn_full(ccx: @mut CrateContext,
- sp: span,
- sym: ~str,
- node_id: ast::NodeId,
- node_type: ty::t)
- -> ValueRef {
+ node_id: ast::NodeId,
+ node_type: ty::t)
+ -> ValueRef {
let llfty = type_of_fn_from_ty(ccx, node_type);
- register_fn_fuller(ccx, sp, sym, node_id, lib::llvm::CCallConv, llfty)
+ register_fn_llvmty(ccx, sp, sym, node_id, lib::llvm::CCallConv, llfty)
}
-pub fn register_fn_fuller(ccx: @mut CrateContext,
+pub fn register_fn_llvmty(ccx: @mut CrateContext,
sp: span,
sym: ~str,
node_id: ast::NodeId,
// 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();
ast::item_fn(_, purity, _, _, _) => {
let llfn = if purity != ast::extern_fn {
- register_fn_full(ccx, i.span, sym, i.id, ty)
+ register_fn(ccx, i.span, sym, i.id, ty)
} else {
foreign::register_foreign_fn(ccx, i.span, sym, i.id)
};
let path = vec::append((*pth).clone(), [path_name(ni.ident)]);
let sym = exported_name(ccx, path, ty, ni.attrs);
- register_fn_full(ccx, ni.span, sym, ni.id, ty)
+ register_fn(ccx, ni.span, sym, ni.id, ty)
}
ast::foreign_item_static(*) => {
let ident = token::ident_to_str(&ni.ident);
llfn = match enm.node {
ast::item_enum(_, _) => {
- register_fn_full(ccx, (*v).span, sym, id, ty)
+ register_fn(ccx, (*v).span, sym, id, ty)
}
_ => fail!("node_variant, shouldn't happen")
};
let ty = ty::node_id_to_type(ccx.tcx, ctor_id);
let sym = exported_name(ccx, (*struct_path).clone(), ty,
struct_item.attrs);
- let llfn = register_fn_full(ccx, struct_item.span, sym, ctor_id, ty);
+ let llfn = register_fn(ccx, struct_item.span,
+ sym, ctor_id, ty);
set_inline_hint(llfn);
llfn
}
let sym = exported_name(ccx, path, mty, m.attrs);
- let llfn = register_fn_full(ccx, m.span, sym, id, mty);
+ let llfn = register_fn(ccx, m.span, sym, id, mty);
set_inline_hint_if_appr(m.attrs, llfn);
llfn
}
}
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 tys = shim_types(ccx, node_id);
do tys.fn_ty.decl_fn |fnty| {
- register_fn_fuller(ccx, sp, sym.take(), node_id, lib::llvm::CCallConv, fnty)
+ register_fn_llvmty(ccx, sp, sym.take(), node_id, lib::llvm::CCallConv, fnty)
}
}
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)
- }
-}
}
}
+pub fn vec_map_to_str<T>(ts: &[T], f: &fn(t: &T) -> ~str) -> ~str {
+ let tstrs = ts.map(f);
+ fmt!("[%s]", tstrs.connect(", "))
+}
+
pub fn tys_to_str(cx: ctxt, ts: &[t]) -> ~str {
- let tstrs = ts.map(|t| ty_to_str(cx, *t));
- fmt!("(%s)", tstrs.connect(", "))
+ vec_map_to_str(ts, |t| ty_to_str(cx, *t))
}
pub fn fn_sig_to_str(cx: ctxt, typ: &ty::FnSig) -> ~str {
}
fn repr_vec<T:Repr>(tcx: ctxt, v: &[T]) -> ~str {
- fmt!("[%s]", v.map(|t| t.repr(tcx)).connect(","))
+ vec_map_to_str(v, |t| t.repr(tcx))
}
impl<'self, T:Repr> Repr for &'self [T] {
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);
}
//! Some various other I/O types
-// NOTE: These ultimately belong somewhere else
+// FIXME(#3660): should move to libextra
use prelude::*;
use super::*;
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 {
/// If begin is greater than end.
/// If end is greater than the length of the string.
#[inline]
- pub unsafe fn slice_bytes(s: &str, begin: uint, end: uint) -> &str {
+ pub unsafe fn slice_bytes<'a>(s: &'a str, begin: uint, end: uint) -> &'a str {
do s.as_imm_buf |sbuf, n| {
assert!((begin <= end));
assert!((end <= n));
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,
Some(&node_local(ident)) => {
fmt!("local (id=%?, name=%s)", id, itr.get(ident.name))
}
- Some(&node_block(_)) => {
- fmt!("block")
+ Some(&node_block(ref block)) => {
+ fmt!("block %s (id=%?)", pprust::block_to_str(block, itr), id)
}
- Some(&node_struct_ctor(*)) => {
- fmt!("struct_ctor")
+ Some(&node_struct_ctor(_, _, path)) => {
+ fmt!("struct_ctor %s (id=%?)", path_to_str(*path, itr), id)
}
}
}
impl Visitor<()> for IdVisitor {
fn visit_mod(@mut self,
module: &_mod,
- span: span,
+ _span: span,
node_id: NodeId,
env: ()) {
(self.visit_callback)(node_id);
/// 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));
}
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 {
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());
}
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