squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

iter: remove to_owned_vec

Browse source 
This needs to be removed as part of removing `~[T]`. Partial type hints
are now allowed, and will remove the need to add a version of this
method for `Vec<T>`. For now, this involves a few workarounds for
partial type hints not completely working.
This commit is contained in:
Daniel Micay 2014-03-22 19:18:37 -04:00
parent 7e7a5e3d3e
commit ae429056ff
18 changed files with 48 additions and 61 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/compiletest/runtest.rs
View file

@ -452,7 +452,7 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
let options_to_remove = [~"-O", ~"-g", ~"--debuginfo"]; let options_to_remove = [~"-O", ~"-g", ~"--debuginfo"];
let new_options = split_maybe_args(options).move_iter() let new_options = split_maybe_args(options).move_iter()
.filter(|x| !options_to_remove.contains(x)) .filter(|x| !options_to_remove.contains(x))
.to_owned_vec() .collect::<~[~str]>()
.connect(" "); .connect(" ");
Some(new_options) Some(new_options)
} }

2
src/libglob/lib.rs
View file

@ -223,7 +223,7 @@ impl Pattern {
*/ */
pub fn new(pattern: &str) -> Pattern { pub fn new(pattern: &str) -> Pattern {
let chars = pattern.chars().to_owned_vec(); let chars = pattern.chars().collect::<~[_]>();
let mut tokens = Vec::new(); let mut tokens = Vec::new();
let mut i = 0; let mut i = 0;

2
src/librand/lib.rs
View file

@ -826,7 +826,7 @@ mod test {
let max_val = 100; let max_val = 100;
let mut r = task_rng(); let mut r = task_rng();
let vals = range(min_val, max_val).to_owned_vec(); let vals = range(min_val, max_val).collect::<~[int]>();
let small_sample = r.sample(vals.iter(), 5); let small_sample = r.sample(vals.iter(), 5);
let large_sample = r.sample(vals.iter(), vals.len() + 5); let large_sample = r.sample(vals.iter(), vals.len() + 5);

4
src/librustc/metadata/creader.rs
View file

@ -197,7 +197,7 @@ fn visit_item(e: &Env, i: &ast::Item) {
} else { } else {
None None
}) })
.to_owned_vec(); .collect::<~[&ast::Attribute]>();
for m in link_args.iter() { for m in link_args.iter() {
match m.value_str() { match m.value_str() {
Some(linkarg) => e.sess.cstore.add_used_link_args(linkarg.get()), Some(linkarg) => e.sess.cstore.add_used_link_args(linkarg.get()),
@ -212,7 +212,7 @@ fn visit_item(e: &Env, i: &ast::Item) {
} else { } else {
None None
}) })
.to_owned_vec(); .collect::<~[&ast::Attribute]>();
for m in link_args.iter() { for m in link_args.iter() {
match m.meta_item_list() { match m.meta_item_list() {
Some(items) => { Some(items) => {

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

@ -236,7 +236,7 @@ fn get_extern_rust_fn(ccx: &CrateContext, inputs: &[ty::t], output: ty::t,
let f = decl_rust_fn(ccx, false, inputs, output, name); let f = decl_rust_fn(ccx, false, inputs, output, name);
csearch::get_item_attrs(&ccx.sess().cstore, did, |meta_items| { csearch::get_item_attrs(&ccx.sess().cstore, did, |meta_items| {
set_llvm_fn_attrs(meta_items.iter().map(|&x| attr::mk_attr(x)).to_owned_vec(), f) set_llvm_fn_attrs(meta_items.iter().map(|&x| attr::mk_attr(x)).collect::<~[_]>(), f)
}); });
ccx.externs.borrow_mut().insert(name.to_owned(), f); ccx.externs.borrow_mut().insert(name.to_owned(), f);

5
src/librustc/middle/trans/consts.rs
View file

@ -538,7 +538,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,
}; };
expr::with_field_tys(tcx, ety, Some(e.id), |discr, field_tys| { expr::with_field_tys(tcx, ety, Some(e.id), |discr, field_tys| {
let cs = field_tys.iter().enumerate() let (cs, inlineable) = slice::unzip(field_tys.iter().enumerate()
.map(|(ix, &field_ty)| { .map(|(ix, &field_ty)| {
match fs.iter().find(|f| field_ty.ident.name == f.ident.node.name) { match fs.iter().find(|f| field_ty.ident.name == f.ident.node.name) {
Some(f) => const_expr(cx, (*f).expr, is_local), Some(f) => const_expr(cx, (*f).expr, is_local),
@ -552,8 +552,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,
} }
} }
} }
}).to_owned_vec(); }));
let (cs, inlineable) = slice::unzip(cs.move_iter());
(adt::trans_const(cx, repr, discr, cs), (adt::trans_const(cx, repr, discr, cs),
inlineable.iter().fold(true, |a, &b| a && b)) inlineable.iter().fold(true, |a, &b| a && b))
}) })

6
src/librustdoc/html/markdown.rs
View file

@ -133,7 +133,7 @@ pub fn render(w: &mut io::Writer, s: &str, print_toc: bool) -> fmt::Result {
slice::raw::buf_as_slice((*text).data, (*text).size as uint, |text| { slice::raw::buf_as_slice((*text).data, (*text).size as uint, |text| {
let text = str::from_utf8(text).unwrap(); let text = str::from_utf8(text).unwrap();
let mut lines = text.lines().filter(|l| stripped_filtered_line(*l).is_none()); let mut lines = text.lines().filter(|l| stripped_filtered_line(*l).is_none());
let text = lines.to_owned_vec().connect("\n"); let text = lines.collect::<~[&str]>().connect("\n");
let buf = buf { let buf = buf {
data: text.as_bytes().as_ptr(), data: text.as_bytes().as_ptr(),
@ -186,7 +186,7 @@ pub fn render(w: &mut io::Writer, s: &str, print_toc: bool) -> fmt::Result {
Some(s) => s.to_lower().into_str(), Some(s) => s.to_lower().into_str(),
None => s.to_owned() None => s.to_owned()
} }
}).to_owned_vec().connect("-"); }).collect::<~[~str]>().connect("-");
let opaque = unsafe {&mut *(opaque as *mut my_opaque)}; let opaque = unsafe {&mut *(opaque as *mut my_opaque)};
@ -284,7 +284,7 @@ pub fn find_testable_code(doc: &str, tests: &mut ::test::Collector) {
let tests = &mut *(opaque as *mut ::test::Collector); let tests = &mut *(opaque as *mut ::test::Collector);
let text = str::from_utf8(text).unwrap(); let text = str::from_utf8(text).unwrap();
let mut lines = text.lines().map(|l| stripped_filtered_line(l).unwrap_or(l)); let mut lines = text.lines().map(|l| stripped_filtered_line(l).unwrap_or(l));
let text = lines.to_owned_vec().connect("\n"); let text = lines.collect::<~[&str]>().connect("\n");
tests.add_test(text, should_fail, no_run); tests.add_test(text, should_fail, no_run);
}) })
} }

8
src/librustdoc/html/render.rs
View file

@ -1205,8 +1205,8 @@ fn item_trait(w: &mut Writer, it: &clean::Item,
it.name.get_ref().as_slice(), it.name.get_ref().as_slice(),
t.generics, t.generics,
parents)); parents));
let required = t.methods.iter().filter(|m| m.is_req()).to_owned_vec(); let required = t.methods.iter().filter(|m| m.is_req()).collect::<~[&clean::TraitMethod]>();
let provided = t.methods.iter().filter(|m| !m.is_req()).to_owned_vec(); let provided = t.methods.iter().filter(|m| !m.is_req()).collect::<~[&clean::TraitMethod]>();
if t.methods.len() == 0 { if t.methods.len() == 0 {
try!(write!(w, "\\{ \\}")); try!(write!(w, "\\{ \\}"));
@ -1502,11 +1502,11 @@ fn render_methods(w: &mut Writer, it: &clean::Item) -> fmt::Result {
let mut non_trait = v.iter().filter(|p| { let mut non_trait = v.iter().filter(|p| {
p.ref0().trait_.is_none() p.ref0().trait_.is_none()
}); });
let non_trait = non_trait.to_owned_vec(); let non_trait = non_trait.collect::<~[&(clean::Impl, Option<~str>)]>();
let mut traits = v.iter().filter(|p| { let mut traits = v.iter().filter(|p| {
p.ref0().trait_.is_some() p.ref0().trait_.is_some()
}); });
let traits = traits.to_owned_vec(); let traits = traits.collect::<~[&(clean::Impl, Option<~str>)]>();
if non_trait.len() > 0 { if non_trait.len() > 0 {
try!(write!(w, "<h2 id='methods'>Methods</h2>")); try!(write!(w, "<h2 id='methods'>Methods</h2>"));

2
src/libstd/ascii.rs
View file

@ -400,7 +400,7 @@ unsafe fn str_map_bytes(string: ~str, map: &'static [u8]) -> ~str {
#[inline] #[inline]
unsafe fn str_copy_map_bytes(string: &str, map: &'static [u8]) -> ~str { unsafe fn str_copy_map_bytes(string: &str, map: &'static [u8]) -> ~str {
let bytes = string.bytes().map(|b| map[b]).to_owned_vec(); let bytes = string.bytes().map(|b| map[b]).collect::<~[_]>();
str::raw::from_utf8_owned(bytes) str::raw::from_utf8_owned(bytes)
} }

15
src/libstd/iter.rs
View file

@ -463,21 +463,6 @@ pub trait Iterator<A> {
FromIterator::from_iterator(self) FromIterator::from_iterator(self)
} }
/// Loops through the entire iterator, collecting all of the elements into
/// a unique vector. This is simply collect() specialized for vectors.
///
/// # Example
///
/// ```rust
/// let a = [1, 2, 3, 4, 5];
/// let b: ~[int] = a.iter().map(|&x| x).to_owned_vec();
/// assert!(a == b);
/// ```
#[inline]
fn to_owned_vec(&mut self) -> ~[A] {
self.collect()
}
/// Loops through `n` iterations, returning the `n`th element of the /// Loops through `n` iterations, returning the `n`th element of the
/// iterator. /// iterator.
/// ///

20
src/libstd/path/posix.rs
View file

@ -1177,13 +1177,13 @@ mod tests {
(s: $path:expr, $exp:expr) => ( (s: $path:expr, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::new($path);
let comps = path.components().to_owned_vec(); let comps = path.components().collect::<~[&[u8]]>();
let exp: &[&str] = $exp; let exp: &[&str] = $exp;
let exps = exp.iter().map(|x| x.as_bytes()).to_owned_vec(); let exps = exp.iter().map(|x| x.as_bytes()).collect::<~[&[u8]]>();
assert!(comps == exps, "components: Expected {:?}, found {:?}", assert!(comps == exps, "components: Expected {:?}, found {:?}",
comps, exps); comps, exps);
let comps = path.rev_components().to_owned_vec(); let comps = path.rev_components().collect::<~[&[u8]]>();
let exps = exps.move_rev_iter().to_owned_vec(); let exps = exps.move_rev_iter().collect::<~[&[u8]]>();
assert!(comps == exps, "rev_components: Expected {:?}, found {:?}", assert!(comps == exps, "rev_components: Expected {:?}, found {:?}",
comps, exps); comps, exps);
} }
@ -1191,12 +1191,12 @@ mod tests {
(v: [$($arg:expr),+], [$([$($exp:expr),*]),*]) => ( (v: [$($arg:expr),+], [$([$($exp:expr),*]),*]) => (
{ {
let path = Path::new(b!($($arg),+)); let path = Path::new(b!($($arg),+));
let comps = path.components().to_owned_vec(); let comps = path.components().collect::<~[&[u8]]>();
let exp: &[&[u8]] = [$(b!($($exp),*)),*]; let exp: &[&[u8]] = [$(b!($($exp),*)),*];
assert!(comps.as_slice() == exp, "components: Expected {:?}, found {:?}", assert!(comps.as_slice() == exp, "components: Expected {:?}, found {:?}",
comps.as_slice(), exp); comps.as_slice(), exp);
let comps = path.rev_components().to_owned_vec(); let comps = path.rev_components().collect::<~[&[u8]]>();
let exp = exp.rev_iter().map(|&x|x).to_owned_vec(); let exp = exp.rev_iter().map(|&x|x).collect::<~[&[u8]]>();
assert!(comps.as_slice() == exp, assert!(comps.as_slice() == exp,
"rev_components: Expected {:?}, found {:?}", "rev_components: Expected {:?}, found {:?}",
comps.as_slice(), exp); comps.as_slice(), exp);
@ -1226,13 +1226,13 @@ mod tests {
(v: [$($arg:expr),+], $exp:expr) => ( (v: [$($arg:expr),+], $exp:expr) => (
{ {
let path = Path::new(b!($($arg),+)); let path = Path::new(b!($($arg),+));
let comps = path.str_components().to_owned_vec(); let comps = path.str_components().collect::<~[Option<&str>]>();
let exp: &[Option<&str>] = $exp; let exp: &[Option<&str>] = $exp;
assert!(comps.as_slice() == exp, assert!(comps.as_slice() == exp,
"str_components: Expected {:?}, found {:?}", "str_components: Expected {:?}, found {:?}",
comps.as_slice(), exp); comps.as_slice(), exp);
let comps = path.rev_str_components().to_owned_vec(); let comps = path.rev_str_components().collect::<~[Option<&str>]>();
let exp = exp.rev_iter().map(|&x|x).to_owned_vec(); let exp = exp.rev_iter().map(|&x|x).collect::<~[Option<&str>]>();
assert!(comps.as_slice() == exp, assert!(comps.as_slice() == exp,
"rev_str_components: Expected {:?}, found {:?}", "rev_str_components: Expected {:?}, found {:?}",
comps.as_slice(), exp); comps.as_slice(), exp);

21
src/libstd/path/windows.rs
View file

@ -2224,13 +2224,15 @@ mod tests {
(s: $path:expr, $exp:expr) => ( (s: $path:expr, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::new($path);
let comps = path.str_components().map(|x|x.unwrap()).to_owned_vec(); let comps = path.str_components().map(|x|x.unwrap())
.collect::<~[&str]>();
let exp: &[&str] = $exp; let exp: &[&str] = $exp;
assert!(comps.as_slice() == exp, assert!(comps.as_slice() == exp,
"str_components: Expected {:?}, found {:?}", "str_components: Expected {:?}, found {:?}",
comps.as_slice(), exp); comps.as_slice(), exp);
let comps = path.rev_str_components().map(|x|x.unwrap()).to_owned_vec(); let comps = path.rev_str_components().map(|x|x.unwrap())
let exp = exp.rev_iter().map(|&x|x).to_owned_vec(); .collect::<~[&str]>();
let exp = exp.rev_iter().map(|&x|x).collect::<~[&str]>();
assert!(comps.as_slice() == exp, assert!(comps.as_slice() == exp,
"rev_str_components: Expected {:?}, found {:?}", "rev_str_components: Expected {:?}, found {:?}",
comps.as_slice(), exp); comps.as_slice(), exp);
@ -2239,13 +2241,14 @@ mod tests {
(v: [$($arg:expr),+], $exp:expr) => ( (v: [$($arg:expr),+], $exp:expr) => (
{ {
let path = Path::new(b!($($arg),+)); let path = Path::new(b!($($arg),+));
let comps = path.str_components().map(|x|x.unwrap()).to_owned_vec(); let comps = path.str_components().map(|x|x.unwrap()).collect::<~[&str]>();
let exp: &[&str] = $exp; let exp: &[&str] = $exp;
assert!(comps.as_slice() == exp, assert!(comps.as_slice() == exp,
"str_components: Expected {:?}, found {:?}", "str_components: Expected {:?}, found {:?}",
comps.as_slice(), exp); comps.as_slice(), exp);
let comps = path.rev_str_components().map(|x|x.unwrap()).to_owned_vec(); let comps = path.rev_str_components().map(|x|x.unwrap())
let exp = exp.rev_iter().map(|&x|x).to_owned_vec(); .collect::<~[&str]>();
let exp = exp.rev_iter().map(|&x|x).collect::<~[&str]>();
assert!(comps.as_slice() == exp, assert!(comps.as_slice() == exp,
"rev_str_components: Expected {:?}, found {:?}", "rev_str_components: Expected {:?}, found {:?}",
comps.as_slice(), exp); comps.as_slice(), exp);
@ -2299,12 +2302,12 @@ mod tests {
(s: $path:expr, $exp:expr) => ( (s: $path:expr, $exp:expr) => (
{ {
let path = Path::new($path); let path = Path::new($path);
let comps = path.components().to_owned_vec(); let comps = path.components().collect::<~[&[u8]]>();
let exp: &[&[u8]] = $exp; let exp: &[&[u8]] = $exp;
assert!(comps.as_slice() == exp, "components: Expected {:?}, found {:?}", assert!(comps.as_slice() == exp, "components: Expected {:?}, found {:?}",
comps.as_slice(), exp); comps.as_slice(), exp);
let comps = path.rev_components().to_owned_vec(); let comps = path.rev_components().collect::<~[&[u8]]>();
let exp = exp.rev_iter().map(|&x|x).to_owned_vec(); let exp = exp.rev_iter().map(|&x|x).collect::<~[&[u8]]>();
assert!(comps.as_slice() == exp, assert!(comps.as_slice() == exp,
"rev_components: Expected {:?}, found {:?}", "rev_components: Expected {:?}, found {:?}",
comps.as_slice(), exp); comps.as_slice(), exp);

6
src/libstd/slice.rs
View file

@ -436,7 +436,7 @@ impl ElementSwaps {
emit_reset: true, emit_reset: true,
sdir: range(0, length) sdir: range(0, length)
.map(|i| SizeDirection{ size: i, dir: Neg }) .map(|i| SizeDirection{ size: i, dir: Neg })
.to_owned_vec() .collect::<~[_]>()
} }
} }
} }
@ -3539,7 +3539,7 @@ mod tests {
let n = task_rng().gen::<uint>() % 10; let n = task_rng().gen::<uint>() % 10;
counts[n] += 1; counts[n] += 1;
(n, counts[n]) (n, counts[n])
}).to_owned_vec(); }).collect::<~[(uint, int)]>();
// only sort on the first element, so an unstable sort // only sort on the first element, so an unstable sort
// may mix up the counts. // may mix up the counts.
@ -4207,7 +4207,7 @@ mod tests {
assert_eq!(xs.capacity(), 128); assert_eq!(xs.capacity(), 128);
xs.shrink_to_fit(); xs.shrink_to_fit();
assert_eq!(xs.capacity(), 100); assert_eq!(xs.capacity(), 100);
assert_eq!(xs, range(0, 100).to_owned_vec()); assert_eq!(xs, range(0, 100).collect::<~[_]>());
} }
#[test] #[test]

2
src/libstd/str.rs
View file

@ -937,7 +937,7 @@ impl<'a> Iterator<UTF16Item> for UTF16Items<'a> {
/// 0x0073, 0xDD1E, 0x0069, 0x0063, /// 0x0073, 0xDD1E, 0x0069, 0x0063,
/// 0xD834]; /// 0xD834];
/// ///
/// assert_eq!(str::utf16_items(v).to_owned_vec(), /// assert_eq!(str::utf16_items(v).collect::<~[_]>(),
/// ~[ScalarValue('𝄞'), /// ~[ScalarValue('𝄞'),
/// ScalarValue('m'), ScalarValue('u'), ScalarValue('s'), /// ScalarValue('m'), ScalarValue('u'), ScalarValue('s'),
/// LoneSurrogate(0xDD1E), /// LoneSurrogate(0xDD1E),

6
src/libstd/sync/deque.rs
View file

@ -494,7 +494,7 @@ mod tests {
} }
} }
}) })
}).to_owned_vec(); }).collect::<~[Thread<()>]>();
while remaining.load(SeqCst) > 0 { while remaining.load(SeqCst) > 0 {
match w.pop() { match w.pop() {
@ -525,7 +525,7 @@ mod tests {
Thread::start(proc() { Thread::start(proc() {
stampede(w, s, 4, 10000); stampede(w, s, 4, 10000);
}) })
}).to_owned_vec(); }).collect::<~[Thread<()>]>();
for thread in threads.move_iter() { for thread in threads.move_iter() {
thread.join(); thread.join();
@ -556,7 +556,7 @@ mod tests {
} }
} }
}) })
}).to_owned_vec(); }).collect::<~[Thread<()>]>();
let mut rng = rand::task_rng(); let mut rng = rand::task_rng();
let mut expected = 0; let mut expected = 0;

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

@ -76,7 +76,7 @@ fn main() {
format!("{}\t trees of depth {}\t check: {}", format!("{}\t trees of depth {}\t check: {}",
iterations * 2, depth, chk) iterations * 2, depth, chk)
}) })
}).to_owned_vec(); }).collect::<~[Future<~str>]>();
for message in messages.mut_iter() { for message in messages.mut_iter() {
println!("{}", *message.get_ref()); println!("{}", *message.get_ref());

2
src/test/run-pass/send_str_treemap.rs
View file

@ -62,7 +62,7 @@ pub fn main() {
assert!(map.pop(&Slice("foo")).is_some()); assert!(map.pop(&Slice("foo")).is_some());
assert_eq!(map.move_iter().map(|(k, v)| k.to_str() + v.to_str()) assert_eq!(map.move_iter().map(|(k, v)| k.to_str() + v.to_str())
.to_owned_vec() .collect::<~[~str]>()
.concat(), .concat(),
~"abc50bcd51cde52def53"); ~"abc50bcd51cde52def53");
} }

2
src/test/run-pass/trait-to-str.rs
View file

@ -21,7 +21,7 @@ impl to_str for int {
impl<T:to_str> to_str for Vec<T> { impl<T:to_str> to_str for Vec<T> {
fn to_string(&self) -> ~str { fn to_string(&self) -> ~str {
format!("[{}]", self.iter().map(|e| e.to_string()).to_owned_vec().connect(", ")) format!("[{}]", self.iter().map(|e| e.to_string()).collect::<~[~str]>().connect(", "))
} }
} }