/// ```
#[inline]
pub fn set_all(&mut self) {
- for w in self.storage.iter_mut() { *w = !0u32; }
+ for w in &mut self.storage { *w = !0u32; }
self.fix_last_block();
}
/// ```
#[inline]
pub fn negate(&mut self) {
- for w in self.storage.iter_mut() { *w = !*w; }
+ for w in &mut self.storage { *w = !*w; }
self.fix_last_block();
}
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn clear(&mut self) {
- for w in self.storage.iter_mut() { *w = 0u32; }
+ for w in &mut self.storage { *w = 0u32; }
}
}
b.iter(|| {
let mut sum = 0;
- for i in ring.iter_mut() {
+ for i in &mut ring {
sum += *i;
}
test::black_box(sum);
self.sdir.swap(i, j);
// Swap the direction of each larger SizeDirection
- for x in self.sdir.iter_mut() {
+ for x in &mut self.sdir {
if x.size > sd.size {
x.dir = match x.dir { Pos => Neg, Neg => Pos };
}
#[test]
fn test_mut_iterator() {
let mut xs = [1, 2, 3, 4, 5];
- for x in xs.iter_mut() {
+ for x in &mut xs {
*x += 1;
}
assert!(xs == [2, 3, 4, 5, 6])
let left: &[_] = left;
assert!(left[..left.len()] == [1, 2][]);
}
- for p in left.iter_mut() {
+ for p in left {
*p += 1;
}
let right: &[_] = right;
assert!(right[..right.len()] == [3, 4, 5][]);
}
- for p in right.iter_mut() {
+ for p in right {
*p += 2;
}
}
}
assert_eq!(cnt, 5);
- for f in v.iter_mut() {
+ for f in &mut v {
assert!(*f == Foo);
cnt += 1;
}
let mut v = [0u8, 1, 2, 3, 4, 5, 6];
assert_eq!(v.chunks_mut(2).len(), 4);
for (i, chunk) in v.chunks_mut(3).enumerate() {
- for x in chunk.iter_mut() {
+ for x in chunk {
*x = i as u8;
}
}
fn test_mut_chunks_rev() {
let mut v = [0u8, 1, 2, 3, 4, 5, 6];
for (i, chunk) in v.chunks_mut(3).rev().enumerate() {
- for x in chunk.iter_mut() {
+ for x in chunk {
*x = i as u8;
}
}
b.iter(|| {
let mut i = 0;
- for x in v.iter_mut() {
+ for x in &mut v {
*x = i;
i += 1;
}
unsafe {
v.set_len(1024);
}
- for x in v.iter_mut() {
+ for x in &mut v {
*x = 0;
}
v
{
let slice = &mut values[2 ..];
assert!(slice == [3, 4, 5]);
- for p in slice.iter_mut() {
+ for p in slice {
*p += 2;
}
}
{
let slice = &mut values[.. 2];
assert!(slice == [1, 2]);
- for p in slice.iter_mut() {
+ for p in slice {
*p += 1;
}
}
let left: &[_] = left;
assert!(&left[..left.len()] == &[1, 2][]);
}
- for p in left.iter_mut() {
+ for p in left {
*p += 1;
}
let right: &[_] = right;
assert!(&right[..right.len()] == &[3, 4, 5][]);
}
- for p in right.iter_mut() {
+ for p in right {
*p += 2;
}
}
v.push(());
assert_eq!(v.iter_mut().count(), 4);
- for &mut () in v.iter_mut() {}
+ for &mut () in &mut v {}
unsafe { v.set_len(0); }
assert_eq!(v.iter_mut().count(), 0);
}
assert!(m.insert(6, 10).is_none());
assert!(m.insert(10, 11).is_none());
- for (k, v) in m.iter_mut() {
+ for (k, v) in &mut m {
*v += k as int;
}
#[inline]
fn next(&mut self) -> Option<B> {
loop {
- for inner in self.frontiter.iter_mut() {
+ if let Some(ref mut inner) = self.frontiter {
for x in inner.by_ref() {
return Some(x)
}
#[inline]
fn next_back(&mut self) -> Option<B> {
loop {
- for inner in self.backiter.iter_mut() {
+ if let Some(ref mut inner) = self.backiter {
match inner.next_back() {
None => (),
y => return y
impl Rand for ChaChaRng {
fn rand<R: Rng>(other: &mut R) -> ChaChaRng {
let mut key : [u32; KEY_WORDS] = [0; KEY_WORDS];
- for word in key.iter_mut() {
+ for word in &mut key {
*word = other.gen();
}
SeedableRng::from_seed(key.as_slice())
// we convert the list from individual weights to cumulative
// weights so we can binary search. This *could* drop elements
// with weight == 0 as an optimisation.
- for item in items.iter_mut() {
+ for item in &mut *items {
running_total = match running_total.checked_add(item.weight) {
Some(n) => n,
None => panic!("WeightedChoice::new called with a total weight \
// optimisations are on.
let mut count = 0;
let mut num = 0;
- for byte in dest.iter_mut() {
+ for byte in dest {
if count == 0 {
// we could micro-optimise here by generating a u32 if
// we only need a few more bytes to fill the vector
// Move the vector of passes out of `$cx` so that we can
// iterate over it mutably while passing `$cx` to the methods.
let mut passes = $cx.lints.passes.take().unwrap();
- for obj in passes.iter_mut() {
+ for obj in &mut passes {
obj.$f($cx, $($args),*);
}
$cx.lints.passes = Some(passes);
fn reset(&mut self, bits: &mut [uint]) {
let e = if self.dfcx.oper.initial_value() {uint::MAX} else {0};
- for b in bits.iter_mut() {
+ for b in bits {
*b = e;
}
}
same_frs: &FreeRegionsFromSameFn) {
let scope_id = same_frs.scope_id;
let (sub_fr, sup_fr) = (same_frs.sub_fr, same_frs.sup_fr);
- for sr in same_regions.iter_mut() {
+ for sr in &mut *same_regions {
if sr.contains(&sup_fr.bound_region)
&& scope_id == sr.scope_id {
sr.push(sub_fr.bound_region);
} else {
Vec::new()
};
- for ge in grouped_errors.iter_mut() {
+ for ge in &mut *grouped_errors {
if move_from_id == ge.move_from.id && error.move_to.is_some() {
debug!("appending move_to to list");
ge.move_to_places.extend(move_to.into_iter());
}
fn all_mem(cls: &mut [RegClass]) {
- for elt in cls.iter_mut() {
+ for elt in cls {
*elt = Memory;
}
}
// The `Ty` values returned by `ty::struct_fields` can still contain
// `ty_projection` variants, so normalize those away.
- for field in fields.iter_mut() {
+ for field in &mut fields {
field.mt.ty = monomorphize::normalize_associated_type(cx.tcx(), &field.mt.ty);
}
// If converting for an object type, then remove the dummy-ty from `Self` now.
// Yuckety yuck.
if self_ty.is_none() {
- for candidate in candidates.iter_mut() {
+ for candidate in &mut candidates {
let mut dummy_substs = candidate.0.substs.clone();
assert!(dummy_substs.self_ty() == Some(dummy_self_ty));
dummy_substs.types.pop(SelfSpace);
/// ! gets replaced with (), unconstrained ints with i32, and unconstrained floats with f64.
pub fn default_type_parameters(&self) {
use middle::ty::UnconstrainedNumeric::{UnconstrainedInt, UnconstrainedFloat, Neither};
- for (_, &mut ref ty) in self.inh.node_types.borrow_mut().iter_mut() {
+ for (_, &mut ref ty) in &mut *self.inh.node_types.borrow_mut() {
let resolved = self.infcx().resolve_type_vars_if_possible(ty);
if self.infcx().type_var_diverges(resolved) {
demand::eqtype(self, codemap::DUMMY_SP, *ty, ty::mk_nil(self.tcx()));
{
match self.base_scope.anon_regions(span, count) {
Ok(mut v) => {
- for r in v.iter_mut() {
+ for r in &mut v {
*r = ty_fold::shift_region(*r, 1);
}
Ok(v)
_ => unreachable!(),
};
let mut tmp = Vec::new();
- for child in m.items.iter_mut() {
+ for child in &mut m.items {
match child.inner {
ModuleItem(..) => {}
_ => continue,
v.push(NameDoc(myname, Some(shorter_line(item.doc_value()))));
}
- for (_, items) in map.iter_mut() {
+ for (_, items) in &mut map {
items.sort();
}
return map;
impl OwnedAsciiExt for Vec<u8> {
#[inline]
fn into_ascii_uppercase(mut self) -> Vec<u8> {
- for byte in self.iter_mut() {
+ for byte in &mut self {
*byte = byte.to_ascii_uppercase();
}
self
#[inline]
fn into_ascii_lowercase(mut self) -> Vec<u8> {
- for byte in self.iter_mut() {
+ for byte in &mut self {
*byte = byte.to_ascii_lowercase();
}
self
// Return result of first successful parser
fn read_or<T>(&mut self, parsers: &mut [Box<FnMut(&mut Parser) -> Option<T>>])
-> Option<T> {
- for pf in parsers.iter_mut() {
+ for pf in parsers {
match self.read_atomically(|p: &mut Parser| pf.call_mut((p,))) {
Some(r) => return Some(r),
None => {}
impl<W> Writer for MultiWriter<W> where W: Writer {
#[inline]
fn write_all(&mut self, buf: &[u8]) -> old_io::IoResult<()> {
- for writer in self.writers.iter_mut() {
+ for writer in &mut self.writers {
try!(writer.write_all(buf));
}
Ok(())
#[inline]
fn flush(&mut self) -> old_io::IoResult<()> {
- for writer in self.writers.iter_mut() {
+ for writer in &mut self.writers {
try!(writer.flush());
}
Ok(())
if token_name_eq(&tok, &token::Eof) {
if eof_eis.len() == 1us {
let mut v = Vec::new();
- for dv in (&mut eof_eis[0]).matches.iter_mut() {
+ for dv in &mut (&mut eof_eis[0]).matches {
v.push(dv.pop().unwrap());
}
return Success(nameize(sess, ms, &v[]));
impl<T> MoveMap<T> for Vec<T> {
fn move_map<F>(mut self, mut f: F) -> Vec<T> where F: FnMut(T) -> T {
- for p in self.iter_mut() {
+ for p in &mut self {
unsafe {
// FIXME(#5016) this shouldn't need to zero to be safe.
ptr::write(p, f(ptr::read_and_zero(p)));
}, vec![], span)
};
- for def in exported_macros.iter_mut() {
+ for def in &mut exported_macros {
def.id = folder.new_id(def.id);
}
let loop_run = Duration::span(|| {
- for p in samples.iter_mut() {
+ for p in &mut *samples {
self.bench_n(n, |x| f(x));
*p = self.ns_per_iter() as f64;
};
stats::winsorize(samples, 5.0);
summ = Some(stats::Summary::new(samples));
- for p in samples.iter_mut() {
+ for p in &mut *samples {
self.bench_n(5 * n, |x| f(x));
*p = self.ns_per_iter() as f64;
};
let lo = percentile_of_sorted(tmp.as_slice(), pct);
let hundred: T = FromPrimitive::from_uint(100).unwrap();
let hi = percentile_of_sorted(tmp.as_slice(), hundred-pct);
- for samp in samples.iter_mut() {
+ for samp in samples {
if *samp > hi {
*samp = hi
} else if *samp < lo {
thread_ring(0, msg_per_task, num_chan, num_port);
// synchronize
- for f in futures.iter_mut() {
+ for f in &mut futures {
f.get()
}
});
let mut rng = StdRng::new().unwrap();
let mut rgradients = [Vec2 { x: 0.0, y: 0.0 }; 256];
- for x in rgradients.iter_mut() {
+ for x in &mut rgradients[] {
*x = random_gradient(&mut rng);
}
}).collect();
// translating to (0, 0) as minimum coordinates.
- for cur_piece in res.iter_mut() {
+ for cur_piece in &mut res {
let (dy, dx) = *cur_piece.iter().min_by(|e| *e).unwrap();
- for &mut (ref mut y, ref mut x) in cur_piece.iter_mut() {
+ for &mut (ref mut y, ref mut x) in cur_piece {
*y -= dy; *x -= dx;
}
}
Some(bi) => bi,
None => break
};
- for bj in b_slice.iter_mut() {
+ for bj in &mut *b_slice {
let dx = bi.x - bj.x;
let dy = bi.y - bj.y;
let dz = bi.z - bj.z;
fn main() {
let mut xs: Vec<isize> = vec!();
- for x in xs.iter_mut() {
+ for x in &mut xs {
xs.push(1) //~ ERROR cannot borrow `xs`
}
}
pub fn main() {
unsafe {
for &bare_fn in bare_fns { bare_fn() }
- for closure in closures.iter_mut() {
+ for closure in &mut *closures {
let S(ref mut closure) = *closure;
(*closure)()
}
fn test2() {
let mut ints = [0; 32];
- for i in ints.iter_mut() { *i += 22; }
+ for i in &mut ints { *i += 22; }
for i in &ints { assert!(*i == 22); }
}
projects / rust.git / commitdiff