};
// Wait on each port, accumulating the results
-let result = ports.foldl(0, |accum, port| *accum + port.recv() );
+let result = ports.iter().fold(0, |accum, port| accum + port.recv() );
# fn some_expensive_computation(_i: uint) -> int { 42 }
~~~
if self.capacity() < other.capacity() {
self.bitv.storage.grow(other.capacity() / uint::bits, &0);
}
- for other.bitv.storage.eachi |i, &w| {
+ for other.bitv.storage.iter().enumerate().advance |(i, &w)| {
let old = self.bitv.storage[i];
let new = f(old, w);
self.bitv.storage[i] = new;
fn size_hint(&self) -> Option<uint> { Some(self.len()) }
fn each(&self, blk: &fn(v: &uint) -> bool) -> bool {
- for self.bitv.storage.eachi |i, &w| {
+ for self.bitv.storage.iter().enumerate().advance |(i, &w)| {
if !iterate_bits(i * uint::bits, w, |b| blk(&b)) {
return false;
}
f: &fn(uint, uint, uint) -> bool) -> bool {
let min = uint::min(self.bitv.storage.len(),
other.bitv.storage.len());
- self.bitv.storage.slice(0, min).eachi(|i, &w| {
+ self.bitv.storage.slice(0, min).iter().enumerate().advance(|(i, &w)| {
f(i * uint::bits, w, other.bitv.storage[i])
})
}
let min = uint::min(len1, len2);
/* only one of these loops will execute and that's the point */
- for self.bitv.storage.slice(min, len1).eachi |i, &w| {
+ for self.bitv.storage.slice(min, len1).iter().enumerate().advance |(i, &w)| {
if !f(true, (i + min) * uint::bits, w) {
return false;
}
}
- for other.bitv.storage.slice(min, len2).eachi |i, &w| {
+ for other.bitv.storage.slice(min, len2).iter().enumerate().advance |(i, &w)| {
if !f(false, (i + min) * uint::bits, w) {
return false;
}
|i| fmt!("tmp/lib-fileinput-test-fileinput-read-byte-%u.tmp", i)), true);
// 3 files containing 0\n, 1\n, and 2\n respectively
- for filenames.eachi |i, &filename| {
+ for filenames.iter().enumerate().advance |(i, &filename)| {
make_file(filename.get_ref(), [fmt!("%u", i)]);
}
|i| fmt!("tmp/lib-fileinput-test-fileinput-read-%u.tmp", i)), true);
// 3 files containing 1\n, 2\n, and 3\n respectively
- for filenames.eachi |i, &filename| {
+ for filenames.iter().enumerate().advance |(i, &filename)| {
make_file(filename.get_ref(), [fmt!("%u", i)]);
}
3,
|i| fmt!("tmp/lib-fileinput-test-input-vec-%u.tmp", i)), true);
- for filenames.eachi |i, &filename| {
+ for filenames.iter().enumerate().advance |(i, &filename)| {
let contents =
vec::from_fn(3, |j| fmt!("%u %u", i, j));
make_file(filename.get_ref(), contents);
3,
|i| fmt!("tmp/lib-fileinput-test-input-vec-state-%u.tmp", i)),true);
- for filenames.eachi |i, &filename| {
+ for filenames.iter().enumerate().advance |(i, &filename)| {
let contents =
vec::from_fn(3, |j| fmt!("%u %u", i, j + 1));
make_file(filename.get_ref(), contents);
3,
|i| fmt!("tmp/lib-fileinput-test-next-file-%u.tmp", i)),true);
- for filenames.eachi |i, &filename| {
+ for filenames.iter().enumerate().advance |(i, &filename)| {
let contents =
vec::from_fn(3, |j| fmt!("%u %u", i, j + 1));
make_file(&filename.get(), contents);
impl<T,F:Flattener<T>,C:ByteChan> GenericChan<T> for FlatChan<T, F, C> {
fn send(&self, val: T) {
- self.byte_chan.send(CONTINUE.to_vec());
+ self.byte_chan.send(CONTINUE.to_owned());
let bytes = self.flattener.flatten(val);
let len = bytes.len() as u64;
do io::u64_to_be_bytes(len, size_of::<u64>()) |len_bytes| {
- self.byte_chan.send(len_bytes.to_vec());
+ self.byte_chan.send(len_bytes.to_owned());
}
self.byte_chan.send(bytes);
}
fn test_try_recv_none3<P:BytePort>(loader: PortLoader<P>) {
static CONTINUE: [u8, ..4] = [0xAA, 0xBB, 0xCC, 0xDD];
// The control word is followed by garbage
- let bytes = CONTINUE.to_vec() + [0];
+ let bytes = CONTINUE.to_owned() + [0];
let port = loader(bytes);
let res: Option<int> = port.try_recv();
assert!(res.is_none());
// then undeserializable garbage
let len_bytes = do io::u64_to_be_bytes(
1, sys::size_of::<u64>()) |len_bytes| {
- len_bytes.to_vec()
+ len_bytes.to_owned()
};
- let bytes = CONTINUE.to_vec() + len_bytes + [0, 0, 0, 0];
+ let bytes = CONTINUE.to_owned() + len_bytes + [0, 0, 0, 0];
let port = loader(bytes);
}).collect();
if parts.len() != 4 {
Err(fmt!("'%s' doesn't have 4 parts", ip))
- } else if parts.contains(&256) {
+ } else if parts.iter().any_(|x| *x == 256u) {
Err(fmt!("invalid octal in addr '%s'", ip))
} else {
Ok(Ipv4Rep {
let w_result = write_common_impl(socket_data_ptr,
vec::slice(data,
0,
- data.len()).to_vec());
+ data.len()).to_owned());
if w_result.is_err() {
let err_data = w_result.get_err();
debug!(
let end = end; // make end immutable so it can be captured
let host_is_end_plus_one: &fn() -> bool = || {
+ let xs = ['?', '#', '/'];
end+1 == len
- && !['?', '#', '/'].contains(&(rawurl[end] as char))
+ && !xs.iter().any_(|x| *x == (rawurl[end] as char))
};
// finish up
fn test_cmp() {
let data = [ &[], &[1], &[2], &[-1], &[0, 1], &[2, 1], &[1, 1, 1] ]
.map(|v| BigUint::from_slice(*v));
- for data.eachi |i, ni| {
- for vec::slice(data, i, data.len()).eachi |j0, nj| {
+ for data.iter().enumerate().advance |(i, ni)| {
+ for vec::slice(data, i, data.len()).iter().enumerate().advance |(j0, nj)| {
let j = j0 + i;
if i == j {
assert_eq!(ni.cmp(nj), Equal);
nums.push(Zero::zero());
nums.push_all_move(vs.map(|s| BigInt::from_slice(Plus, *s)));
- for nums.eachi |i, ni| {
- for vec::slice(nums, i, nums.len()).eachi |j0, nj| {
+ for nums.iter().enumerate().advance |(i, ni)| {
+ for vec::slice(nums, i, nums.len()).iter().enumerate().advance |(j0, nj)| {
let j = i + j0;
if i == j {
assert_eq!(ni.cmp(nj), Equal);
impl<'self, S:Encoder,T:Encodable<S>> Encodable<S> for &'self [T] {
fn encode(&self, s: &mut S) {
do s.emit_seq(self.len()) |s| {
- for self.eachi |i, e| {
+ for self.iter().enumerate().advance |(i, e)| {
s.emit_seq_elt(i, |s| e.encode(s))
}
}
impl<S:Encoder,T:Encodable<S>> Encodable<S> for ~[T] {
fn encode(&self, s: &mut S) {
do s.emit_seq(self.len()) |s| {
- for self.eachi |i, e| {
+ for self.iter().enumerate().advance |(i, e)| {
s.emit_seq_elt(i, |s| e.encode(s))
}
}
impl<S:Encoder,T:Encodable<S>> Encodable<S> for @[T] {
fn encode(&self, s: &mut S) {
do s.emit_seq(self.len()) |s| {
- for self.eachi |i, e| {
+ for self.iter().enumerate().advance |(i, e)| {
s.emit_seq_elt(i, |s| e.encode(s))
}
}
impl<S:Encoder> EncoderHelpers for S {
fn emit_from_vec<T>(&mut self, v: &[T], f: &fn(&mut S, &T)) {
do self.emit_seq(v.len()) |this| {
- for v.eachi |i, e| {
+ for v.iter().enumerate().advance |(i, e)| {
do this.emit_seq_elt(i) |this| {
f(this, e)
}
from: &[T]) {
assert!(s1+from.len() <= dest.len());
- for from.eachi |i, v| {
+ for from.iter().enumerate().advance |(i, v)| {
dest[s1+i] = copy *v;
}
}
len: uint) {
assert!(s1+len <= dest.len());
- let tmp = dest.slice(s2, s2+len).to_vec();
+ let tmp = dest.slice(s2, s2+len).to_owned();
copy_vec(dest, s1, tmp);
}
return Err(~"error: hit EOF before end of string table");
}
- for string_offsets.eachi |i, v| {
+ for string_offsets.iter().enumerate().advance |(i, v)| {
let offset = *v;
if offset == 0xFFFF { // non-entry
loop;
for 90.times {
let k = rng.gen();
let v = rng.gen();
- if !ctrl.contains(&(k, v)) {
+ if !ctrl.iter().any_(|x| x == &(k, v)) {
assert!(map.insert(k, v));
ctrl.push((k, v));
check_structure(&map);
}
fn find_cmd(command_string: &str) -> Option<Command> {
- do commands.find |command| {
+ do commands.iter().find_ |command| {
command.cmd == command_string
- }
+ }.map_consume(|x| copy *x)
}
fn cmd_help(args: &[~str]) -> ValidUsage {
// which the item is valid
let cfg_metas = vec::filter_map(cfg_metas, |i| attr::get_meta_item_list(i));
- if cfg_metas.all(|c| c.is_empty()) { return true; }
+ if cfg_metas.iter().all(|c| c.is_empty()) { return true; }
- cfg_metas.any(|cfg_meta| {
- cfg_meta.all(|cfg_mi| {
+ cfg_metas.iter().any_(|cfg_meta| {
+ cfg_meta.iter().all(|cfg_mi| {
match cfg_mi.node {
ast::meta_list(s, ref it) if "not" == s
- => it.all(|mi| !attr::contains(cfg, *mi)),
+ => it.iter().all(|mi| !attr::contains(cfg, *mi)),
_ => attr::contains(cfg, *cfg_mi)
}
})
_ => {}
}
- let outer = vec::append_one(outer0.to_vec(), ty);
+ let outer = vec::append_one(outer0.to_owned(), ty);
let kind = llvm::LLVMGetTypeKind(ty);
*crate_cache[crate_cache.len() - 1].metas
);
- let (matches, non_matches) =
- partition(crate_cache.map_to_vec(|&entry| {
- let othername = loader::crate_name_from_metas(
- copy *entry.metas);
- if name == othername {
- Left(entry)
- } else {
- Right(entry)
- }
- }));
+ let vec: ~[Either<cache_entry, cache_entry>] = crate_cache.iter().transform(|&entry| {
+ let othername = loader::crate_name_from_metas(
+ copy *entry.metas);
+ if name == othername {
+ Left(entry)
+ } else {
+ Right(entry)
+ }
+ }).collect();
+ let (matches, non_matches) = partition(vec);
assert!(!matches.is_empty());
pub fn add_used_library(cstore: &mut CStore, lib: @str) -> bool {
assert!(!lib.is_empty());
- if cstore.used_libraries.contains(&lib) { return false; }
+ if cstore.used_libraries.iter().any_(|x| x == &lib) { return false; }
cstore.used_libraries.push(lib);
true
}
ebml_w.end_tag();
// Now output the method info for each method.
- for ty::trait_method_def_ids(tcx, local_def(item.id)).eachi |i, &method_def_id| {
+ let r = ty::trait_method_def_ids(tcx, local_def(item.id));
+ for r.iter().enumerate().advance |(i, &method_def_id)| {
assert_eq!(method_def_id.crate, ast::local_crate);
let method_ty = ty::method(tcx, method_def_id);
LoanDataFlowOperator,
id_range,
all_loans.len());
- for all_loans.eachi |loan_idx, loan| {
+ for all_loans.iter().enumerate().advance |(loan_idx, loan)| {
loan_dfcx.add_gen(loan.gen_scope, loan_idx);
loan_dfcx.add_kill(loan.kill_scope, loan_idx);
}
* killed by scoping. See `doc.rs` for more details.
*/
- for self.moves.eachi |i, move| {
+ for self.moves.iter().enumerate().advance |(i, move)| {
dfcx_moves.add_gen(move.id, i);
}
- for self.var_assignments.eachi |i, assignment| {
+ for self.var_assignments.iter().enumerate().advance |(i, assignment)| {
dfcx_assign.add_gen(assignment.id, i);
self.kill_moves(assignment.path, assignment.id, dfcx_moves);
}
}
// Kill all assignments when the variable goes out of scope:
- for self.var_assignments.eachi |assignment_index, assignment| {
+ for self.var_assignments.iter().enumerate().advance |(assignment_index, assignment)| {
match *self.path(assignment.path).loan_path {
LpVar(id) => {
let kill_id = tcx.region_maps.encl_scope(id);
(visitor.visit_item)(it, (env, visitor));
fn visit_item(it: @item, (env, v): (env, visit::vt<env>)) {
- if env.idstack.contains(&(it.id)) {
+ if env.idstack.iter().any_(|x| x == &(it.id)) {
env.sess.span_fatal(env.root_it.span, "recursive constant");
}
env.idstack.push(it.id);
};
let variants = ty::enum_variants(cx.tcx, id);
- match variants.find(|v| v.id == vid) {
+ match variants.iter().find_(|v| v.id == vid) {
Some(v) => Some(cx.tcx.sess.str_of(v.name)),
None => {
fail!("check_exhaustive: bad variant in ctor")
pub fn is_useful(cx: @MatchCheckCtxt, m: &matrix, v: &[@pat]) -> useful {
if m.len() == 0u { return useful_; }
if m[0].len() == 0u { return not_useful; }
- let real_pat = match m.find(|r| r[0].id != 0) {
+ let real_pat = match m.iter().find_(|r| r[0].id != 0) {
Some(r) => r[0], None => v[0]
};
let left_ty = if real_pat.id == 0 { ty::mk_nil() }
let variants = ty::enum_variants(cx.tcx, eid);
if found.len() != (*variants).len() {
for (*variants).each |v| {
- if !found.contains(&(variant(v.id))) {
+ if !found.iter().any_(|x| x == &(variant(v.id))) {
return Some(variant(v.id));
}
}
if variant(variant_id) == *ctor_id {
// FIXME #4731: Is this right? --pcw
let args = flds.map(|ty_field| {
- match flds.find(|f|
+ match flds.iter().find_(|f|
f.ident == ty_field.ident) {
Some(f) => f.pat,
_ => wild()
}
}
let args = vec::map(class_fields, |class_field| {
- match flds.find(|f|
+ match flds.iter().find_(|f|
f.ident == class_field.ident) {
Some(f) => f.pat,
_ => wild()
}
pat_lit(_) | pat_range(_, _) => { true }
pat_struct(_, ref fields, _) => {
- fields.any(|f| is_refutable(cx, f.pat))
+ fields.iter().any_(|f| is_refutable(cx, f.pat))
}
pat_tup(ref elts) => {
- elts.any(|elt| is_refutable(cx, *elt))
+ elts.iter().any_(|elt| is_refutable(cx, *elt))
}
pat_enum(_, Some(ref args)) => {
- args.any(|a| is_refutable(cx, *a))
+ args.iter().any_(|a| is_refutable(cx, *a))
}
pat_enum(_,_) => { false }
pat_vec(*) => { true }
f: &fn(uint) -> bool) -> bool {
//! Helper for iterating over the bits in a bit set.
- for words.eachi |word_index, &word| {
+ for words.iter().enumerate().advance |(word_index, &word)| {
if word != 0 {
let base_index = word_index * uint::bits;
for uint::range(0, uint::bits) |offset| {
let entry_str = bits_to_str(on_entry);
let gens = vec::slice(self.gens, start, end);
- let gens_str = if gens.any(|&u| u != 0) {
+ let gens_str = if gens.iter().any_(|&u| u != 0) {
fmt!(" gen: %s", bits_to_str(gens))
} else {
~""
};
let kills = vec::slice(self.kills, start, end);
- let kills_str = if kills.any(|&u| u != 0) {
+ let kills_str = if kills.iter().any_(|&u| u != 0) {
fmt!(" kill: %s", bits_to_str(kills))
} else {
~""
// func_bits represents the state when the function
// returns
- let mut func_bits = reslice(in_out).to_vec();
+ let mut func_bits = reslice(in_out).to_owned();
loop_scopes.push(LoopScope {
loop_id: expr.id,
loop_kind: ForLoop,
- break_bits: reslice(in_out).to_vec()
+ break_bits: reslice(in_out).to_owned()
});
for decl.inputs.each |input| {
self.walk_pat(input.pat, func_bits, loop_scopes);
//
self.walk_expr(cond, in_out, loop_scopes);
- let mut then_bits = reslice(in_out).to_vec();
+ let mut then_bits = reslice(in_out).to_owned();
self.walk_block(then, then_bits, loop_scopes);
self.walk_opt_expr(els, in_out, loop_scopes);
self.walk_expr(cond, in_out, loop_scopes);
- let mut body_bits = reslice(in_out).to_vec();
+ let mut body_bits = reslice(in_out).to_owned();
loop_scopes.push(LoopScope {
loop_id: expr.id,
loop_kind: TrueLoop,
- break_bits: reslice(in_out).to_vec()
+ break_bits: reslice(in_out).to_owned()
});
self.walk_block(blk, body_bits, loop_scopes);
self.add_to_entry_set(expr.id, body_bits);
// <--+ (break)
//
- let mut body_bits = reslice(in_out).to_vec();
+ let mut body_bits = reslice(in_out).to_owned();
self.reset(in_out);
loop_scopes.push(LoopScope {
loop_id: expr.id,
loop_kind: TrueLoop,
- break_bits: reslice(in_out).to_vec()
+ break_bits: reslice(in_out).to_owned()
});
self.walk_block(blk, body_bits, loop_scopes);
self.add_to_entry_set(expr.id, body_bits);
//
self.walk_expr(discr, in_out, loop_scopes);
- let mut guards = reslice(in_out).to_vec();
+ let mut guards = reslice(in_out).to_owned();
// We know that exactly one arm will be taken, so we
// can start out with a blank slate and just union
// determine the bits for the body and then union
// them into `in_out`, which reflects all bodies to date
- let mut body = reslice(guards).to_vec();
+ let mut body = reslice(guards).to_owned();
self.walk_pat_alternatives(arm.pats, body, loop_scopes);
self.walk_block(&arm.body, body, loop_scopes);
join_bits(&self.dfcx.oper, body, in_out);
self.walk_opt_expr(o_e, in_out, loop_scopes);
// is this a return from a `for`-loop closure?
- match loop_scopes.position(|s| s.loop_kind == ForLoop) {
+ match loop_scopes.iter().position_(|s| s.loop_kind == ForLoop) {
Some(i) => {
// if so, add the in_out bits to the state
// upon exit. Remember that we cannot count
ast::expr_binary(_, op, l, r) if ast_util::lazy_binop(op) => {
self.walk_expr(l, in_out, loop_scopes);
- let temp = reslice(in_out).to_vec();
+ let temp = reslice(in_out).to_owned();
self.walk_expr(r, in_out, loop_scopes);
join_bits(&self.dfcx.oper, temp, in_out);
}
// In the general case, the patterns in `pats` are
// alternatives, so we must treat this like an N-way select
// statement.
- let initial_state = reslice(in_out).to_vec();
+ let initial_state = reslice(in_out).to_owned();
for pats.each |&pat| {
let mut temp = copy initial_state;
self.walk_pat(pat, temp, loop_scopes);
Some(_) => {
match self.tcx().def_map.find(&expr.id) {
Some(&ast::def_label(loop_id)) => {
- match loop_scopes.position(|l| l.loop_id == loop_id) {
+ match loop_scopes.iter().position_(|l| l.loop_id == loop_id) {
Some(i) => i,
None => {
self.tcx().sess.span_bug(
// Check, based on the region associated with the trait, whether it can
// possibly escape the enclosing fn item (note that all type parameters
// must have been declared on the enclosing fn item).
- if target_regions.any(|r| is_re_scope(*r)) {
+ if target_regions.iter().any_(|r| is_re_scope(*r)) {
return; /* case (1) */
}
|_r| {
// FIXME(#5723) --- turn this check on once &Objects are usable
//
- // if !target_regions.any(|t_r| is_subregion_of(cx, *t_r, r)) {
+ // if !target_regions.iter().any_(|t_r| is_subregion_of(cx, *t_r, r)) {
// cx.tcx.sess.span_err(
// source.span,
// fmt!("source contains borrowed pointer with lifetime \
|ty| {
match ty::get(ty).sty {
ty::ty_param(source_param) => {
- if target_params.contains(&source_param) {
+ if target_params.iter().any_(|x| x == &source_param) {
/* case (2) */
} else {
check_durable(cx.tcx, ty, source.span); /* case (3) */
}
pub fn each_item(&self, f: &fn(def_id: def_id, i: uint) -> bool) -> bool {
- self.items.eachi(|i, &item| f(item.get(), i))
+ self.items.iter().enumerate().advance(|(i, &item)| f(item.get(), i))
}
pub fn item_name(index: uint) -> &'static str {
// If we have doc(hidden), nothing to do
if cx.doc_hidden { return }
// If we're documented, nothing to do
- if attrs.any(|a| a.node.is_sugared_doc) { return }
+ if attrs.iter().any_(|a| a.node.is_sugared_doc) { return }
// otherwise, warn!
cx.span_lint(missing_doc, sp, msg);
}
};
- for subpats.eachi |i, &subpat| {
+ for subpats.iter().enumerate().advance |(i, &subpat)| {
let subpat_ty = self.pat_ty(subpat); // see (*)
let subcmt =
}
Some(&ast::def_fn(*)) |
Some(&ast::def_struct(*)) => {
- for subpats.eachi |i, &subpat| {
+ for subpats.iter().enumerate().advance |(i, &subpat)| {
let subpat_ty = self.pat_ty(subpat); // see (*)
let cmt_field =
self.cat_imm_interior(
ast::pat_tup(ref subpats) => {
// (p1, ..., pN)
- for subpats.eachi |i, &subpat| {
+ for subpats.iter().enumerate().advance |(i, &subpat)| {
let subpat_ty = self.pat_ty(subpat); // see (*)
let subcmt =
self.cat_imm_interior(
// any fields which (1) were not explicitly
// specified and (2) have a type that
// moves-by-default:
- let consume_with = with_fields.any(|tf| {
- !fields.any(|f| f.node.ident == tf.ident) &&
+ let consume_with = with_fields.iter().any_(|tf| {
+ !fields.iter().any_(|f| f.node.ident == tf.ident) &&
ty::type_moves_by_default(self.tcx, tf.mt.ty)
});
method_id.node);
if is_private &&
(container_id.crate != local_crate ||
- !privileged_items.contains(&(container_id.node))) {
+ !privileged_items.iter().any_(|x| x == &(container_id.node))) {
tcx.sess.span_err(span,
fmt!("method `%s` is private",
token::ident_to_str(name)));
def_fn(def_id, _) => {
if def_id.crate == local_crate {
if local_item_is_private(span, def_id.node) &&
- !privileged_items.contains(&def_id.node) {
+ !privileged_items.iter().any_(|x| x == &def_id.node) {
tcx.sess.span_err(span,
fmt!("function `%s` is private",
token::ident_to_str(path.idents.last())));
match (*methods)[method_num] {
provided(method)
if method.vis == private &&
- !privileged_items
- .contains(&(trait_id.node)) => {
+ !privileged_items.iter()
+ .any_(|x| x == &(trait_id.node)) => {
tcx.sess.span_err(span,
fmt!("method `%s` is private",
token::ident_to_str(&method
match ty::get(ty::type_autoderef(tcx, ty::expr_ty(tcx,
base))).sty {
ty_struct(id, _)
- if id.crate != local_crate || !privileged_items.contains(&(id.node)) => {
+ if id.crate != local_crate || !privileged_items.iter()
+ .any_(|x| x == &(id.node)) => {
debug!("(privacy checking) checking field access");
check_field(expr.span, id, ident);
}
base))).sty {
ty_struct(id, _)
if id.crate != local_crate ||
- !privileged_items.contains(&(id.node)) => {
+ !privileged_items.iter().any_(|x| x == &(id.node)) => {
match method_map.find(&expr.id) {
None => {
tcx.sess.span_bug(expr.span,
match ty::get(ty::expr_ty(tcx, expr)).sty {
ty_struct(id, _) => {
if id.crate != local_crate ||
- !privileged_items.contains(&(id.node)) {
+ !privileged_items.iter().any_(|x| x == &(id.node)) {
for (*fields).each |field| {
debug!("(privacy checking) checking \
field in struct literal");
}
ty_enum(id, _) => {
if id.crate != local_crate ||
- !privileged_items.contains(&(id.node)) {
+ !privileged_items.iter().any_(|x| x == &(id.node)) {
match tcx.def_map.get_copy(&expr.id) {
def_variant(_, variant_id) => {
for (*fields).each |field| {
match ty::get(ty::expr_ty(tcx, operand)).sty {
ty_enum(id, _) => {
if id.crate != local_crate ||
- !privileged_items.contains(&(id.node)) {
+ !privileged_items.iter().any_(|x| x == &(id.node)) {
check_variant(expr.span, id);
}
}
match ty::get(ty::pat_ty(tcx, pattern)).sty {
ty_struct(id, _) => {
if id.crate != local_crate ||
- !privileged_items.contains(&(id.node)) {
+ !privileged_items.iter().any_(|x| x == &(id.node)) {
for fields.each |field| {
debug!("(privacy checking) checking \
struct pattern");
}
ty_enum(enum_id, _) => {
if enum_id.crate != local_crate ||
- !privileged_items.contains(
- &enum_id.node) {
+ !privileged_items.iter().any_(|x| x == &enum_id.node) {
match tcx.def_map.find(&pattern.id) {
Some(&def_variant(_, variant_id)) => {
for fields.each |field| {
pub fn relate_free_regions(&mut self, sub: FreeRegion, sup: FreeRegion) {
match self.free_region_map.find_mut(&sub) {
Some(sups) => {
- if !sups.contains(&sup) {
+ if !sups.iter().any_(|x| x == &sup) {
sups.push(sup);
}
return;
return true;
}
- if !queue.contains(parent) {
+ if !queue.iter().any_(|x| x == parent) {
queue.push(*parent);
}
}
ambient_variance: self.ambient_variance,
id: self.item_id
};
- if !vec.contains(&dep) { vec.push(dep); }
+ if !vec.iter().any_(|x| x == &dep) { vec.push(dep); }
}
// Determines whether a reference to a region that appears in the
let path_len = full_path.idents.len();
assert!(path_len != 0);
- for full_path.idents.eachi |i, ident| {
+ for full_path.idents.iter().enumerate().advance |(i, ident)| {
if i != path_len - 1 {
module_path.push(*ident);
}
pub fn check_consistent_bindings(@mut self, arm: &arm) {
if arm.pats.len() == 0 { return; }
let map_0 = self.binding_mode_map(arm.pats[0]);
- for arm.pats.eachi() |i, p| {
+ for arm.pats.iter().enumerate().advance |(i, p)| {
let map_i = self.binding_mode_map(*p);
for map_0.each |&key, &binding_0| {
pub fn intern_module_part_of_path(@mut self, path: @Path) -> ~[ident] {
let mut module_path_idents = ~[];
- for path.idents.eachi |index, ident| {
+ for path.idents.iter().enumerate().advance |(index, ident)| {
if index == path.idents.len() - 1 {
break;
}
}
let mut smallest = 0;
- for maybes.eachi |i, &other| {
-
+ for maybes.iter().enumerate().advance |(i, &other)| {
values[i] = name.lev_distance(other);
if values[i] <= values[smallest] {
match br.pats[col].node {
ast::pat_ident(_, path, Some(inner)) => {
let pats = vec::append(
- vec::slice(br.pats, 0u, col).to_vec(),
+ vec::slice(br.pats, 0u, col).to_owned(),
vec::append(~[inner],
vec::slice(br.pats, col + 1u,
br.pats.len())));
let mut reordered_patterns = ~[];
for ty::lookup_struct_fields(tcx, struct_id).each
|field| {
- match field_pats.find(|p|
- p.ident == field.ident) {
+ match field_pats.iter().find_(|p| p.ident == field.ident) {
None => reordered_patterns.push(dummy),
Some(fp) => reordered_patterns.push(fp.pat)
}
ast::pat_struct(_, ref fpats, _) => {
let mut pats = ~[];
for fields.each |fname| {
- match fpats.find(|p| p.ident == *fname) {
+ match fpats.iter().find_(|p| p.ident == *fname) {
None => pats.push(dummy),
Some(pat) => pats.push(pat.pat)
}
if has_nested_bindings(m, col) {
expand_nested_bindings(bcx, m, col, val)
} else {
- m.to_vec()
+ m.to_owned()
}
};
- let vals_left = vec::append(vec::slice(vals, 0u, col).to_vec(),
+ let vals_left = vec::append(vec::slice(vals, 0u, col).to_owned(),
vec::slice(vals, col + 1u, vals.len()));
let ccx = bcx.fcx.ccx;
let mut pat_id = 0;
vinfo.disr_val,
val);
for sub_pats.iter().advance |sub_pat| {
- for args.vals.eachi |i, argval| {
+ for args.vals.iter().enumerate().advance |(i, argval)| {
bcx = bind_irrefutable_pat(bcx,
sub_pat[i],
*argval,
Some(ref elems) => {
// This is the tuple struct case.
let repr = adt::represent_node(bcx, pat.id);
- for elems.eachi |i, elem| {
+ for elems.iter().enumerate().advance |(i, elem)| {
let fldptr = adt::trans_field_ptr(bcx, repr,
val, 0, i);
bcx = bind_irrefutable_pat(bcx,
}
ast::pat_tup(ref elems) => {
let repr = adt::represent_node(bcx, pat.id);
- for elems.eachi |i, elem| {
+ for elems.iter().enumerate().advance |(i, elem)| {
let fldptr = adt::trans_field_ptr(bcx, repr, val, 0, i);
bcx = bind_irrefutable_pat(bcx,
*elem,
mk_struct(cx, self.tys, false).size == 0
}
fn find_ptr(&self) -> Option<uint> {
- self.tys.position(|&ty| mono_data_classify(ty) == MonoNonNull)
+ self.tys.iter().position_(|&ty| mono_data_classify(ty) == MonoNonNull)
}
}
return Univariant(mk_struct(cx, [], false), false);
}
- if cases.all(|c| c.tys.len() == 0) {
+ if cases.iter().all(|c| c.tys.len() == 0) {
// All bodies empty -> intlike
let discrs = cases.map(|c| c.discr);
return CEnum(*discrs.iter().min().unwrap(), *discrs.iter().max().unwrap());
let mut offset = 0;
let mut cfields = ~[];
- for st.fields.eachi |i, &ty| {
+ for st.fields.iter().enumerate().advance |(i, &ty)| {
let llty = type_of::sizing_type_of(ccx, ty);
let type_align = machine::llalign_of_min(ccx, llty)
/*bad*/as u64;
let op = PointerCast(bcx, aoutputs[0], T_ptr(val_ty(outputs[0])));
Store(bcx, r, op);
} else {
- for aoutputs.eachi |i, o| {
+ for aoutputs.iter().enumerate().advance |(i, o)| {
let v = ExtractValue(bcx, r, i);
let op = PointerCast(bcx, *o, T_ptr(val_ty(outputs[i])));
Store(bcx, v, op);
let tcx = cx.tcx();
let mut cx = cx;
- for variant.args.eachi |i, &arg| {
+ for variant.args.iter().enumerate().advance |(i, &arg)| {
cx = f(cx,
adt::trans_field_ptr(cx, repr, av, variant.disr_val, i),
ty::subst_tps(tcx, tps, None, arg));
ty::ty_struct(*) => {
let repr = adt::represent_type(cx.ccx(), t);
do expr::with_field_tys(cx.tcx(), t, None) |discr, field_tys| {
- for field_tys.eachi |i, field_ty| {
+ for field_tys.iter().enumerate().advance |(i, field_ty)| {
let llfld_a = adt::trans_field_ptr(cx, repr, av, discr, i);
cx = f(cx, llfld_a, field_ty.mt.ty);
}
}
ty::ty_tup(ref args) => {
let repr = adt::represent_type(cx.ccx(), t);
- for args.eachi |i, arg| {
+ for args.iter().enumerate().advance |(i, arg)| {
let llfld_a = adt::trans_field_ptr(cx, repr, av, 0, i);
cx = f(cx, llfld_a, *arg);
}
repr, ty_to_str(ccx.tcx, enum_ty));
adt::trans_start_init(bcx, repr, fcx.llretptr.get(), disr);
- for args.eachi |i, va| {
+ for args.iter().enumerate().advance |(i, va)| {
let lldestptr = adt::trans_field_ptr(bcx,
repr,
fcx.llretptr.get(),
let repr = adt::represent_type(ccx, tup_ty);
adt::trans_start_init(bcx, repr, fcx.llretptr.get(), 0);
- for fields.eachi |i, field| {
+ for fields.iter().enumerate().advance |(i, field)| {
let lldestptr = adt::trans_field_ptr(bcx,
repr,
fcx.llretptr.get(),
type_params.repr(bcx.tcx()),
vtables.repr(bcx.tcx()));
- assert!(type_params.all(|t| !ty::type_needs_infer(*t)));
+ assert!(type_params.iter().all(|t| !ty::type_needs_infer(*t)));
// Polytype of the function item (may have type params)
let fn_tpt = ty::lookup_item_type(tcx, def_id);
match args {
ArgExprs(arg_exprs) => {
let last = arg_exprs.len() - 1u;
- for arg_exprs.eachi |i, arg_expr| {
+ for arg_exprs.iter().enumerate().advance |(i, arg_expr)| {
let arg_val = unpack_result!(bcx, {
trans_arg_expr(bcx,
arg_tys[i],
});
for cleanup_pos.iter().advance |i| {
scope_info.cleanups =
- vec::append(vec::slice(scope_info.cleanups, 0u, *i).to_vec(),
+ vec::append(vec::slice(scope_info.cleanups, 0u, *i).to_owned(),
vec::slice(scope_info.cleanups,
*i + 1u,
scope_info.cleanups.len()));
let tcx = bcx.tcx();
let params = ty::node_id_to_type_params(tcx, id);
- if !params.all(|t| !ty::type_needs_infer(*t)) {
+ if !params.iter().all(|t| !ty::type_needs_infer(*t)) {
bcx.sess().bug(
fmt!("Type parameters for node %d include inference types: %s",
id, params.map(|t| bcx.ty_to_str(*t)).connect(",")));
let sz = llvm::LLVMConstMul(C_uint(cx, es.len()), unit_sz);
let vs = es.map(|e| const_expr(cx, *e));
// If the vector contains enums, an LLVM array won't work.
- let v = if vs.any(|vi| val_ty(*vi) != llunitty) {
+ let v = if vs.iter().any_(|vi| val_ty(*vi) != llunitty) {
C_struct(vs)
} else {
C_array(llunitty, vs)
do expr::with_field_tys(tcx, ety, Some(e.id))
|discr, field_tys| {
let cs = field_tys.map(|field_ty| {
- match fs.find(|f| field_ty.ident == f.node.ident) {
- Some(ref f) => const_expr(cx, (*f).node.expr),
+ match fs.iter().find_(|f| field_ty.ident == f.node.ident) {
+ Some(f) => const_expr(cx, (*f).node.expr),
None => {
cx.tcx.sess.span_bug(e.span, "missing struct field");
}
let optbase = match base {
Some(base_expr) => {
let mut leftovers = ~[];
- for need_base.eachi |i, b| {
+ for need_base.iter().enumerate().advance |(i, b)| {
if *b {
leftovers.push((i, field_tys[i].mt.ty))
}
fields: leftovers })
}
None => {
- if need_base.any(|b| *b) {
+ if need_base.iter().any_(|b| *b) {
tcx.sess.span_bug(expr_span, "missing fields and no base expr")
}
None
match vtbls[bound_index] {
typeck::vtable_static(impl_did, ref rcvr_substs, rcvr_origins) => {
- assert!(rcvr_substs.all(|t| !ty::type_needs_infer(*t)));
+ assert!(rcvr_substs.iter().all(|t| !ty::type_needs_infer(*t)));
let mth_id = method_with_name_or_default(bcx.ccx(),
impl_did,
pub fn method_from_methods(ms: &[@ast::method], name: ast::ident)
-> Option<ast::def_id> {
- ms.find(|m| m.ident == name).map(|m| ast_util::local_def(m.id))
+ ms.iter().find_(|m| m.ident == name).map(|m| ast_util::local_def(m.id))
}
pub fn method_with_name_or_default(ccx: @mut CrateContext,
let node_substs = node_id_type_params(bcx, callee_id);
debug!("rcvr_substs=%?", rcvr_substs.map(|t| bcx.ty_to_str(*t)));
let ty_substs
- = vec::append(rcvr_substs.to_vec(),
+ = vec::append(rcvr_substs.to_owned(),
vec::tailn(node_substs,
node_substs.len() - n_m_tps));
debug!("n_m_tps=%?", n_m_tps);
impl_did_opt.repr(ccx.tcx),
ref_id);
- assert!(real_substs.tps.all(|t| !ty::type_needs_infer(*t)));
+ assert!(real_substs.tps.iter().all(|t| !ty::type_needs_infer(*t)));
let _icx = ccx.insn_ctxt("monomorphic_fn");
let mut must_cast = false;
let substs = vec::map(real_substs.tps, |t| {
let v = self.visitor_val;
debug!("passing %u args:", args.len());
let bcx = self.bcx;
- for args.eachi |i, a| {
+ for args.iter().enumerate().advance |(i, a)| {
debug!("arg %u: %s", i, val_str(bcx.ccx().tn, *a));
}
let bool_ty = ty::mk_bool();
let extra = ~[self.c_uint(tys.len())]
+ self.c_size_and_align(t);
do self.bracketed(~"tup", extra) |this| {
- for tys.eachi |i, t| {
+ for tys.iter().enumerate().advance |(i, t)| {
let extra = ~[this.c_uint(i), this.c_tydesc(*t)];
this.visit(~"tup_field", extra);
}
let extra = ~[self.c_uint(fields.len())]
+ self.c_size_and_align(t);
do self.bracketed(~"class", extra) |this| {
- for fields.eachi |i, field| {
+ for fields.iter().enumerate().advance |(i, field)| {
let extra = ~[this.c_uint(i),
this.c_slice(
bcx.ccx().sess.str_of(field.ident))]
let enum_args = ~[self.c_uint(variants.len()), make_get_disr()]
+ self.c_size_and_align(t);
do self.bracketed(~"enum", enum_args) |this| {
- for variants.eachi |i, v| {
+ for variants.iter().enumerate().advance |(i, v)| {
let name = ccx.sess.str_of(v.name);
let variant_args = ~[this.c_uint(i),
this.c_int(v.disr_val),
this.c_uint(v.args.len()),
this.c_slice(name)];
do this.bracketed(~"enum_variant", variant_args) |this| {
- for v.args.eachi |j, a| {
+ for v.args.iter().enumerate().advance |(j, a)| {
let bcx = this.bcx;
let null = C_null(llptrty);
let ptr = adt::trans_field_ptr(bcx, repr, null, v.disr_val, j);
}
pub fn visit_sig(&mut self, retval: uint, sig: &ty::FnSig) {
- for sig.inputs.eachi |i, arg| {
+ for sig.inputs.iter().enumerate().advance |(i, arg)| {
let modeval = 5u; // "by copy"
let extra = ~[self.c_uint(i),
self.c_uint(modeval),
SaveIn(lldest) => {
let mut temp_cleanups = ~[];
- for elements.eachi |i, element| {
+ for elements.iter().enumerate().advance |(i, element)| {
let lleltptr = GEPi(bcx, lldest, [i]);
debug!("writing index %? with lleltptr=%?",
i, bcx.val_str(lleltptr));
ty_struct(did, ref substs) => {
let flds = struct_fields(cx, did, substs);
- let mut res = flds.foldl(
+ let mut res = flds.iter().fold(
TC_NONE,
|tc, f| tc + tc_mt(cx, f.mt, cache));
if ty::has_dtor(cx, did) {
}
ty_tup(ref tys) => {
- tys.foldl(TC_NONE, |tc, ty| *tc + tc_ty(cx, *ty, cache))
+ tys.iter().fold(TC_NONE, |tc, ty| tc + tc_ty(cx, *ty, cache))
}
ty_enum(did, ref substs) => {
// are non-copyable
TC_EMPTY_ENUM
} else {
- variants.foldl(TC_NONE, |tc, variant| {
- variant.args.foldl(
- *tc,
- |tc, arg_ty| *tc + tc_ty(cx, *arg_ty, cache))
+ variants.iter().fold(TC_NONE, |tc, variant| {
+ variant.args.iter().fold(tc,
+ |tc, arg_ty| tc + tc_ty(cx, *arg_ty, cache))
})
};
apply_tc_attr(cx, did, res)
}
ty_tup(ref ts) => {
- ts.any(|t| type_requires(cx, seen, r_ty, *t))
+ ts.iter().any_(|t| type_requires(cx, seen, r_ty, *t))
}
ty_enum(ref did, _) if vec::contains(*seen, did) => {
let special_idents = [special_idents::statik, special_idents::self_];
let mut bound_lifetime_names = opt_vec::Empty;
ast_lifetimes.map_to_vec(|ast_lifetime| {
- if special_idents.any(|&i| i == ast_lifetime.ident) {
+ if special_idents.iter().any_(|&i| i == ast_lifetime.ident) {
this.tcx().sess.span_err(
ast_lifetime.span,
fmt!("illegal lifetime parameter name: `%s`",
// Index the class fields.
let mut field_map = HashMap::new();
- for class_fields.eachi |i, class_field| {
+ for class_fields.iter().enumerate().advance |(i, class_field)| {
field_map.insert(class_field.ident, i);
}
// Report an error if not all the fields were specified.
if !etc {
- for class_fields.eachi |i, field| {
+ for class_fields.iter().enumerate().advance |(i, field)| {
if found_fields.contains(&i) {
loop;
}
let e_count = elts.len();
match s {
ty::ty_tup(ref ex_elts) if e_count == ex_elts.len() => {
- for elts.eachi |i, elt| {
+ for elts.iter().enumerate().advance |(i, elt)| {
check_pat(pcx, *elt, ex_elts[i]);
}
fcx.write_ty(pat.id, expected);
ty_enum(did, _) => {
// Watch out for newtype'd enums like "enum t = @T".
// See discussion in typeck::check::do_autoderef().
- if enum_dids.contains(&did) {
+ if enum_dids.iter().any_(|x| x == &did) {
return None;
}
enum_dids.push(did);
let trait_methods = ty::trait_methods(tcx, bound_trait_ref.def_id);
let pos = {
- match trait_methods.position(|m| {
+ match trait_methods.iter().position_(|m| {
m.explicit_self != ast::sty_static &&
m.ident == self.m_name })
{
}
let idx = {
- match impl_info.methods.position(|m| m.ident == self.m_name) {
+ match impl_info.methods.iter().position_(|m| m.ident == self.m_name) {
Some(idx) => idx,
None => { return; } // No method with the right name.
}
rcvr_ty: ty::t,
candidates: &mut ~[Candidate])
-> Option<method_map_entry> {
- let relevant_candidates =
- candidates.filter_to_vec(|c| self.is_relevant(rcvr_ty, c));
+ let relevant_candidates: ~[Candidate] =
+ candidates.iter().transform(|c| copy *c).
+ filter(|c| self.is_relevant(rcvr_ty, c)).collect();
let relevant_candidates = self.merge_candidates(relevant_candidates);
parameters given for this method");
self.fcx.infcx().next_ty_vars(num_method_tps)
} else {
- self.supplied_tps.to_vec()
+ self.supplied_tps.to_owned()
}
};
vtable::early_resolve_expr(callee_expr, fcx, true);
}
- for args.eachi |i, arg| {
+ for args.iter().enumerate().advance |(i, arg)| {
let is_block = match arg.node {
ast::expr_fn_block(*) | ast::expr_loop_body(*) |
ast::expr_do_body(*) => true,
let discrim_ty = fcx.expr_ty(discrim);
let arm_tys = arms.map(|a| fcx.node_ty(a.body.node.id));
if ty::type_is_error(discrim_ty) ||
- arm_tys.any(|t| ty::type_is_error(*t)) {
+ arm_tys.iter().any_(|t| ty::type_is_error(*t)) {
fcx.write_error(id);
}
// keep in mind that `all` returns true in the empty vec case,
// which is what we want
else if ty::type_is_bot(discrim_ty) ||
- arm_tys.all(|t| ty::type_is_bot(*t)) {
+ arm_tys.iter().all(|t| ty::type_is_bot(*t)) {
fcx.write_bot(id);
}
else {
ast::expr_call(f, ref args, sugar) => {
check_call(fcx, expr.id, expr, f, *args, sugar);
let f_ty = fcx.expr_ty(f);
- let (args_bot, args_err) = args.foldl((false, false),
- |&(rest_bot, rest_err), a| {
+ let (args_bot, args_err) = args.iter().fold((false, false),
+ |(rest_bot, rest_err), a| {
// is this not working?
let a_ty = fcx.expr_ty(*a);
(rest_bot || ty::type_is_bot(a_ty),
check_method_call(fcx, callee_id, expr, rcvr, ident, *args, *tps, sugar);
let f_ty = fcx.expr_ty(rcvr);
let arg_tys = args.map(|a| fcx.expr_ty(*a));
- let (args_bot, args_err) = arg_tys.foldl((false, false),
- |&(rest_bot, rest_err), a| {
+ let (args_bot, args_err) = arg_tys.iter().fold((false, false),
+ |(rest_bot, rest_err), a| {
(rest_bot || ty::type_is_bot(*a),
rest_err || ty::type_is_error(*a))});
if ty::type_is_error(f_ty) || args_err {
true
});
- for tps_used.eachi |i, b| {
+ for tps_used.iter().enumerate().advance |(i, b)| {
if !*b {
ccx.tcx.sess.span_err(
span, fmt!("type parameter `%s` is unused",
}
// For each type `ty` in `tys`...
- do tys.foldl(isr) |isr, ty| {
- let mut isr = *isr;
+ do tys.iter().fold(isr) |isr, ty| {
+ let mut isr = isr;
// Using fold_regions is inefficient, because it
// constructs new types, but it avoids code duplication in
}
fn has_trait_bounds(type_param_defs: &[ty::TypeParameterDef]) -> bool {
- type_param_defs.any(
+ type_param_defs.iter().any_(
|type_param_def| !type_param_def.bounds.trait_bounds.is_empty())
}
generics, self_ty);
// FIXME(#5527) Could have same trait multiple times
- if ty_trait_refs.any(|other_trait| other_trait.def_id == trait_ref.def_id) {
+ if ty_trait_refs.iter().any_(|other_trait| other_trait.def_id == trait_ref.def_id) {
// This means a trait inherited from the same supertrait more
// than once.
tcx.sess.span_err(sp, "Duplicate supertrait in trait declaration");
return;
}
- for trait_m.generics.type_param_defs.eachi |i, trait_param_def| {
+ for trait_m.generics.type_param_defs.iter().enumerate().advance |(i, trait_param_def)| {
// For each of the corresponding impl ty param's bounds...
let impl_param_def = &impl_m.generics.type_param_defs[i];
// we'll catch it in coherence
let trait_ms = ty::trait_methods(tcx, trait_ref.def_id);
for impl_ms.each |impl_m| {
- match trait_ms.find(|trait_m| trait_m.ident == impl_m.mty.ident) {
+ match trait_ms.iter().find_(|trait_m| trait_m.ident == impl_m.mty.ident) {
Some(trait_m) => {
let num_impl_tps = generics.ty_params.len();
compare_impl_method(
- ccx.tcx, num_impl_tps, impl_m, trait_m,
+ ccx.tcx, num_impl_tps, impl_m, *trait_m,
&trait_ref.substs, selfty);
}
None => {
if vec::same_length(as_, bs) {
iter_vec2(as_, bs, |a, b| {
eq_tys(this, *a, *b)
- }).then(|| Ok(as_.to_vec()) )
+ }).then(|| Ok(as_.to_owned()) )
} else {
Err(ty::terr_ty_param_size(
expected_found(this, as_.len(), bs.len())))
pub fn is_var_in_set(new_vars: &[RegionVid], r: ty::Region) -> bool {
match r {
- ty::re_infer(ty::ReVar(ref v)) => new_vars.contains(v),
+ ty::re_infer(ty::ReVar(ref v)) => new_vars.iter().any_(|x| x == v),
_ => false
}
}
// Variables created during LUB computation which are
// *related* to regions that pre-date the LUB computation
// stay as they are.
- if !tainted.all(|r| is_var_in_set(new_vars, *r)) {
+ if !tainted.iter().all(|r| is_var_in_set(new_vars, *r)) {
debug!("generalize_region(r0=%?): \
non-new-variables found in %?",
r0, tainted);
// with.
for list::each(a_isr) |pair| {
let (a_br, a_r) = *pair;
- if tainted.contains(&a_r) {
+ if tainted.iter().any_(|x| x == &a_r) {
debug!("generalize_region(r0=%?): \
replacing with %?, tainted=%?",
r0, a_br, tainted);
{
let mut result_set = result_set;
if *r == *r1 { // Clearly, this is potentially inefficient.
- if !result_set.contains(r2) {
+ if !result_set.iter().any_(|x| x == r2) {
result_set.push(*r2);
}
}
// or new variables:
match *tainted_region {
ty::re_infer(ty::ReVar(ref vid)) => {
- if new_vars.contains(vid) { loop; }
+ if new_vars.iter().any_(|x| x == vid) { loop; }
}
_ => {
if *tainted_region == skol { loop; }
if substs.len() > 0u {
debug!("write_substs_to_tcx(%d, %?)", node_id,
substs.map(|t| ppaux::ty_to_str(tcx, *t)));
- assert!(substs.all(|t| !ty::type_needs_infer(*t)));
+ assert!(substs.iter().all(|t| !ty::type_needs_infer(*t)));
tcx.node_type_substs.insert(node_id, substs);
}
}
let lint_flags = vec::append(getopts::opt_strs(matches, "W"),
getopts::opt_strs(matches, "warn"));
- let show_lint_options = lint_flags.contains(&~"help") ||
+ let show_lint_options = lint_flags.iter().any_(|x| x == &~"help") ||
(opt_present(matches, "W") && lint_flags.is_empty());
if show_lint_options {
return;
}
- if getopts::opt_strs(matches, "Z").contains(&~"help") {
+ let r = getopts::opt_strs(matches, "Z");
+ if r.iter().any_(|x| x == &~"help") {
describe_debug_flags();
return;
}
}
pub fn parse_hidden(attrs: ~[ast::attribute]) -> bool {
- do doc_metas(attrs).find |meta| {
+ let r = doc_metas(attrs);
+ do r.iter().any_ |meta| {
match attr::get_meta_item_list(*meta) {
Some(metas) => {
let hiddens = attr::find_meta_items_by_name(metas, "hidden");
}
None => false
}
- }.is_some()
+ }
}
#[cfg(test)]
};
let self_ty = doc.self_ty.get_ref();
let mut trait_part = ~"";
- for doc.trait_types.eachi |i, trait_type| {
+ for doc.trait_types.iter().enumerate().advance |(i, trait_type)| {
if i == 0 {
trait_part += " of ";
} else {
item_vis: ast::visibility
) -> doc::ImplDoc {
let methods = do (&doc.methods).filtered |method| {
- let ast_method = do methods.find |m| {
+ let ast_method = do methods.iter().find_ |m| {
extract::to_str(m.ident) == method.name
};
assert!(ast_method.is_some());
pub fn main() {
let args = os::args();
- if args.contains(&~"-h") || args.contains(&~"--help") {
+ if args.iter().any_(|x| "-h" == *x) || args.iter().any_(|x| "--help" == *x) {
config::usage();
return;
}
// file, skip compilation and return None.
let mut should_compile = true;
let dir = os::list_dir_path(&Path(outputs.out_filename.dirname()));
- let maybe_lib_path = do dir.find |file| {
+ let maybe_lib_path = do dir.iter().find_ |file| {
// The actual file's name has a hash value and version
// number in it which is unknown at this time, so looking
// for a file that matches out_filename won't work,
let crate_path = Path(*crate);
let crate_dir = crate_path.dirname();
repl.program.record_extern(fmt!("extern mod %s;", *crate));
- if !repl.lib_search_paths.contains(&crate_dir) {
+ if !repl.lib_search_paths.iter().any_(|x| x == &crate_dir) {
repl.lib_search_paths.push(crate_dir);
}
}
if !cmd.is_empty() {
let args = if len > 1 {
- vec::slice(split, 1, len).to_vec()
+ vec::slice(split, 1, len).to_owned()
} else { ~[] };
match run_cmd(repl, in, out, cmd, args, use_rl) {
let dir;
let dirs = pkgid_src_in_workspace(&self.id, &self.root);
debug!("Checking dirs: %?", dirs);
- let path = dirs.find(|d| os::path_exists(d));
+ let path = dirs.iter().find_(|&d| os::path_exists(d));
match path {
- Some(d) => dir = d,
+ Some(d) => dir = copy *d,
None => dir = match self.fetch_git() {
None => cond.raise((copy self.id, ~"supplied path for package dir does not \
exist, and couldn't interpret it as a URL fragment")),
command_line_test([~"install", ~"bar"], &dir);
command_line_test([~"install", ~"quux"], &dir);
let list_output = command_line_test_output([~"list"]);
- assert!(list_output.contains(&~"foo"));
- assert!(list_output.contains(&~"bar"));
- assert!(list_output.contains(&~"quux"));
+ assert!(list_output.iter().any_(|x| x == &~"foo"));
+ assert!(list_output.iter().any_(|x| x == &~"bar"));
+ assert!(list_output.iter().any_(|x| x == &~"quux"));
command_line_test([~"remove", ~"foo"], &dir);
let list_output = command_line_test_output([~"list"]);
- assert!(!list_output.contains(&~"foo"));
- assert!(list_output.contains(&~"bar"));
- assert!(list_output.contains(&~"quux"));
+ assert!(!list_output.iter().any_(|x| x == &~"foo"));
+ assert!(list_output.iter().any_(|x| x == &~"bar"));
+ assert!(list_output.iter().any_(|x| x == &~"quux"));
}
#[test]
command_line_test([~"install", ~"foo#0.1"], &workspace);
let output = command_line_test_output([~"list"]);
// make sure output includes versions
- assert!(!output.contains(&~"foo#0.2"));
+ assert!(!output.iter().any_(|x| x == &~"foo#0.2"));
}
#[test]
}
pub fn is_cmd(cmd: &str) -> bool {
- Commands.any(|&c| c == cmd)
+ Commands.iter().any_(|&c| c == cmd)
}
struct ListenerFn {
/// Just an approximation
fn is_url_like(p: &RemotePath) -> bool {
let str = p.to_str();
- str.split_iter('/').count() > 2
+ str.split_iter('/').len_() > 2
}
/// If s is of the form foo#bar, where bar is a valid version
for s.split_iter(sep).advance |st| {
debug!("whole = %s part = %s", s, st);
}
- if s.split_iter(sep).count() > 2 {
+ if s.split_iter(sep).len_() > 2 {
return None;
}
match s.rfind(sep) {
let s = "a#1.2";
assert!(split_version(s) == Some((s.slice(0, 1), ExactRevision(~"1.2"))));
assert!(split_version("a#a#3.4") == None);
-}
\ No newline at end of file
+}
use to_str::ToStr;
use uint;
use vec;
-use vec::{OwnedVector, OwnedCopyableVector};
+use vec::{OwnedVector, OwnedCopyableVector, CopyableVector};
#[allow(non_camel_case_types)] // not sure what to do about this
pub type fd_t = c_int;
// over-read by reading 1-byte per char needed
nbread = if ncreq > nbreq { ncreq } else { nbreq };
if nbread > 0 {
- bytes = vec::slice(bytes, offset, bytes.len()).to_vec();
+ bytes = vec::slice(bytes, offset, bytes.len()).to_owned();
}
}
chars
use num::{Zero, One};
use option::{Option, Some, None};
use ops::{Add, Mul};
-use cmp::Ord;
+use cmp::{Ord, Eq};
use clone::Clone;
/// An interface for dealing with "external iterators". These types of iterators
/// ~~~
fn fold<B>(&mut self, start: B, f: &fn(B, A) -> B) -> B;
+ // FIXME: #5898: should be called len
/// Counts the number of elements in this iterator.
///
/// # Example
/// ~~~ {.rust}
/// let a = [1, 2, 3, 4, 5];
/// let mut it = a.iter();
- /// assert!(it.count() == 5);
- /// assert!(it.count() == 0);
+ /// assert!(it.len_() == 5);
+ /// assert!(it.len_() == 0);
/// ~~~
- fn count(&mut self) -> uint;
+ fn len_(&mut self) -> uint;
/// Tests whether the predicate holds true for all elements in the iterator.
///
/// Return the index of the first element satisfying the specified predicate
fn position_(&mut self, predicate: &fn(A) -> bool) -> Option<uint>;
+
+ /// Count the number of elements satisfying the specified predicate
+ fn count(&mut self, predicate: &fn(A) -> bool) -> uint;
}
/// Iterator adaptors provided for every `Iterator` implementation. The adaptor objects are also
/// Count the number of items yielded by an iterator
#[inline]
- fn count(&mut self) -> uint { self.fold(0, |cnt, _x| cnt + 1) }
+ fn len_(&mut self) -> uint { self.fold(0, |cnt, _x| cnt + 1) }
#[inline]
fn all(&mut self, f: &fn(A) -> bool) -> bool {
}
None
}
+
+ #[inline]
+ fn count(&mut self, predicate: &fn(A) -> bool) -> uint {
+ let mut i = 0;
+ for self.advance |x| {
+ if predicate(x) { i += 1 }
+ }
+ i
+ }
}
/// A trait for iterators over elements which can be added together
}
#[test]
- fn test_iterator_count() {
+ fn test_iterator_len() {
let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
- assert_eq!(v.slice(0, 4).iter().count(), 4);
- assert_eq!(v.slice(0, 10).iter().count(), 10);
- assert_eq!(v.slice(0, 0).iter().count(), 0);
+ assert_eq!(v.slice(0, 4).iter().len_(), 4);
+ assert_eq!(v.slice(0, 10).iter().len_(), 10);
+ assert_eq!(v.slice(0, 0).iter().len_(), 0);
}
#[test]
assert_eq!(v.iter().position_(|x| *x % 3 == 0).unwrap(), 1);
assert!(v.iter().position_(|x| *x % 12 == 0).is_none());
}
+
+ #[test]
+ fn test_count() {
+ let xs = &[1, 2, 2, 1, 5, 9, 0, 2];
+ assert_eq!(xs.iter().count(|x| *x == 2), 3);
+ assert_eq!(xs.iter().count(|x| *x == 5), 1);
+ assert_eq!(xs.iter().count(|x| *x == 95), 0);
+ }
}
#[allow(missing_doc)];
-use cmp::{Eq};
+use cmp::Eq;
use kinds::Copy;
use option::{None, Option, Some};
use vec;
}
/// Returns the number of characters that a string holds
#[inline]
- fn char_len(&self) -> uint { self.iter().count() }
+ fn char_len(&self) -> uint { self.iter().len_() }
/**
* Returns a slice of the given string from the byte range
-> Option<(uint, *libc::c_void)> {
let key_value = key_to_key_value(key);
- let map_pos = (*map).position(|entry|
+ let map_pos = (*map).iter().position_(|entry|
match *entry {
Some((k,_,_)) => k == key_value,
None => false
}
None => {
// Find an empty slot. If not, grow the vector.
- match (*map).position(|x| x.is_none()) {
+ match (*map).iter().position_(|x| x.is_none()) {
Some(empty_index) => { map[empty_index] = new_entry; }
None => { map.push(new_entry); }
}
#[test]
fn test_parse_flags() {
fn pack(fs: &[Flag]) -> uint {
- fs.foldl(0, |&p, &f| p | (1 << f as uint))
+ fs.iter().fold(0, |p, &f| p | (1 << f as uint))
}
fn test(s: &str, flags: &[Flag], next: uint) {
use kinds::Copy;
use libc;
use num::Zero;
-use old_iter::CopyableIter;
use option::{None, Option, Some};
use ptr::to_unsafe_ptr;
use ptr;
match position_between(v, start, ln, f) {
None => break,
Some(i) => {
- result.push(slice(v, start, i).to_vec());
+ result.push(slice(v, start, i).to_owned());
start = i + 1u;
}
}
}
- result.push(slice(v, start, ln).to_vec());
+ result.push(slice(v, start, ln).to_owned());
result
}
match position_between(v, start, ln, f) {
None => break,
Some(i) => {
- result.push(slice(v, start, i).to_vec());
+ result.push(slice(v, start, i).to_owned());
// Make sure to skip the separator.
start = i + 1u;
count -= 1u;
}
}
}
- result.push(slice(v, start, ln).to_vec());
+ result.push(slice(v, start, ln).to_owned());
result
}
match rposition_between(v, 0, end, f) {
None => break,
Some(i) => {
- result.push(slice(v, i + 1, end).to_vec());
+ result.push(slice(v, i + 1, end).to_owned());
end = i;
}
}
}
- result.push(slice(v, 0u, end).to_vec());
+ result.push(slice(v, 0u, end).to_owned());
reverse(result);
result
}
match rposition_between(v, 0u, end, f) {
None => break,
Some(i) => {
- result.push(slice(v, i + 1u, end).to_vec());
+ result.push(slice(v, i + 1u, end).to_owned());
// Make sure to skip the separator.
end = i;
count -= 1u;
}
}
}
- result.push(slice(v, 0u, end).to_vec());
+ result.push(slice(v, 0u, end).to_owned());
reverse(result);
result
}
fn initn(&self, n: uint) -> &'self [T];
fn last(&self) -> &'self T;
fn last_opt(&self) -> Option<&'self T>;
- fn position(&self, f: &fn(t: &T) -> bool) -> Option<uint>;
fn rposition(&self, f: &fn(t: &T) -> bool) -> Option<uint>;
fn map<U>(&self, f: &fn(t: &T) -> U) -> ~[U];
fn mapi<U>(&self, f: &fn(uint, t: &T) -> U) -> ~[U];
#[inline]
fn last_opt(&self) -> Option<&'self T> { last_opt(*self) }
- /**
- * Find the first index matching some predicate
- *
- * Apply function `f` to each element of `v`. When function `f` returns
- * true then an option containing the index is returned. If `f` matches no
- * elements then none is returned.
- */
- #[inline]
- fn position(&self, f: &fn(t: &T) -> bool) -> Option<uint> {
- position(*self, f)
- }
-
/**
* Find the last index matching some predicate
*
}
}
-// ___________________________________________________________________________
-// ITERATION TRAIT METHODS
-
impl<'self,A> old_iter::BaseIter<A> for &'self [A] {
#[inline]
fn each<'a>(&'a self, blk: &fn(v: &'a A) -> bool) -> bool {
fn size_hint(&self) -> Option<uint> { Some(self.len()) }
}
-// FIXME(#4148): This should be redundant
-impl<A> old_iter::BaseIter<A> for ~[A] {
- #[inline]
- fn each<'a>(&'a self, blk: &fn(v: &'a A) -> bool) -> bool {
- each(*self, blk)
- }
- #[inline]
- fn size_hint(&self) -> Option<uint> { Some(self.len()) }
-}
-
-// FIXME(#4148): This should be redundant
-impl<A> old_iter::BaseIter<A> for @[A] {
- #[inline]
- fn each<'a>(&'a self, blk: &fn(v: &'a A) -> bool) -> bool {
- each(*self, blk)
- }
- #[inline]
- fn size_hint(&self) -> Option<uint> { Some(self.len()) }
-}
-
-impl<'self,A> old_iter::ExtendedIter<A> for &'self [A] {
- pub fn eachi(&self, blk: &fn(uint, v: &A) -> bool) -> bool {
- old_iter::eachi(self, blk)
- }
- pub fn all(&self, blk: &fn(&A) -> bool) -> bool {
- old_iter::all(self, blk)
- }
- pub fn any(&self, blk: &fn(&A) -> bool) -> bool {
- old_iter::any(self, blk)
- }
- pub fn foldl<B>(&self, b0: B, blk: &fn(&B, &A) -> B) -> B {
- old_iter::foldl(self, b0, blk)
- }
- pub fn position(&self, f: &fn(&A) -> bool) -> Option<uint> {
- old_iter::position(self, f)
- }
- fn map_to_vec<B>(&self, op: &fn(&A) -> B) -> ~[B] {
- old_iter::map_to_vec(self, op)
- }
- fn flat_map_to_vec<B,IB:BaseIter<B>>(&self, op: &fn(&A) -> IB)
- -> ~[B] {
- old_iter::flat_map_to_vec(self, op)
- }
-}
-
-// FIXME(#4148): This should be redundant
-impl<A> old_iter::ExtendedIter<A> for ~[A] {
- pub fn eachi(&self, blk: &fn(uint, v: &A) -> bool) -> bool {
- old_iter::eachi(self, blk)
- }
- pub fn all(&self, blk: &fn(&A) -> bool) -> bool {
- old_iter::all(self, blk)
- }
- pub fn any(&self, blk: &fn(&A) -> bool) -> bool {
- old_iter::any(self, blk)
- }
- pub fn foldl<B>(&self, b0: B, blk: &fn(&B, &A) -> B) -> B {
- old_iter::foldl(self, b0, blk)
- }
- pub fn position(&self, f: &fn(&A) -> bool) -> Option<uint> {
- old_iter::position(self, f)
- }
- fn map_to_vec<B>(&self, op: &fn(&A) -> B) -> ~[B] {
- old_iter::map_to_vec(self, op)
- }
- fn flat_map_to_vec<B,IB:BaseIter<B>>(&self, op: &fn(&A) -> IB)
- -> ~[B] {
- old_iter::flat_map_to_vec(self, op)
- }
-}
-
-// FIXME(#4148): This should be redundant
-impl<A> old_iter::ExtendedIter<A> for @[A] {
- pub fn eachi(&self, blk: &fn(uint, v: &A) -> bool) -> bool {
- old_iter::eachi(self, blk)
- }
- pub fn all(&self, blk: &fn(&A) -> bool) -> bool {
- old_iter::all(self, blk)
- }
- pub fn any(&self, blk: &fn(&A) -> bool) -> bool {
- old_iter::any(self, blk)
- }
- pub fn foldl<B>(&self, b0: B, blk: &fn(&B, &A) -> B) -> B {
- old_iter::foldl(self, b0, blk)
- }
- pub fn position(&self, f: &fn(&A) -> bool) -> Option<uint> {
- old_iter::position(self, f)
- }
- fn map_to_vec<B>(&self, op: &fn(&A) -> B) -> ~[B] {
- old_iter::map_to_vec(self, op)
- }
- fn flat_map_to_vec<B,IB:BaseIter<B>>(&self, op: &fn(&A) -> IB)
- -> ~[B] {
- old_iter::flat_map_to_vec(self, op)
- }
-}
-
-impl<'self,A:Eq> old_iter::EqIter<A> for &'self [A] {
- pub fn contains(&self, x: &A) -> bool { old_iter::contains(self, x) }
- pub fn count(&self, x: &A) -> uint { old_iter::count(self, x) }
-}
-
-// FIXME(#4148): This should be redundant
-impl<A:Eq> old_iter::EqIter<A> for ~[A] {
- pub fn contains(&self, x: &A) -> bool { old_iter::contains(self, x) }
- pub fn count(&self, x: &A) -> uint { old_iter::count(self, x) }
-}
-
-// FIXME(#4148): This should be redundant
-impl<A:Eq> old_iter::EqIter<A> for @[A] {
- pub fn contains(&self, x: &A) -> bool { old_iter::contains(self, x) }
- pub fn count(&self, x: &A) -> uint { old_iter::count(self, x) }
-}
-
-impl<'self,A:Copy> old_iter::CopyableIter<A> for &'self [A] {
- fn filter_to_vec(&self, pred: &fn(&A) -> bool) -> ~[A] {
- old_iter::filter_to_vec(self, pred)
- }
- fn to_vec(&self) -> ~[A] { old_iter::to_vec(self) }
- pub fn find(&self, f: &fn(&A) -> bool) -> Option<A> {
- old_iter::find(self, f)
- }
-}
-
-// FIXME(#4148): This should be redundant
-impl<A:Copy> old_iter::CopyableIter<A> for ~[A] {
- fn filter_to_vec(&self, pred: &fn(&A) -> bool) -> ~[A] {
- old_iter::filter_to_vec(self, pred)
- }
- fn to_vec(&self) -> ~[A] { old_iter::to_vec(self) }
- pub fn find(&self, f: &fn(&A) -> bool) -> Option<A> {
- old_iter::find(self, f)
- }
-}
-
-// FIXME(#4148): This should be redundant
-impl<A:Copy> old_iter::CopyableIter<A> for @[A] {
- fn filter_to_vec(&self, pred: &fn(&A) -> bool) -> ~[A] {
- old_iter::filter_to_vec(self, pred)
- }
- fn to_vec(&self) -> ~[A] { old_iter::to_vec(self) }
- pub fn find(&self, f: &fn(&A) -> bool) -> Option<A> {
- old_iter::find(self, f)
- }
-}
-
impl<A:Clone> Clone for ~[A] {
#[inline]
fn clone(&self) -> ~[A] {
fn test_slice() {
// Test fixed length vector.
let vec_fixed = [1, 2, 3, 4];
- let v_a = slice(vec_fixed, 1u, vec_fixed.len()).to_vec();
+ let v_a = slice(vec_fixed, 1u, vec_fixed.len()).to_owned();
assert_eq!(v_a.len(), 3u);
assert_eq!(v_a[0], 2);
assert_eq!(v_a[1], 3);
// Test on stack.
let vec_stack = &[1, 2, 3];
- let v_b = slice(vec_stack, 1u, 3u).to_vec();
+ let v_b = slice(vec_stack, 1u, 3u).to_owned();
assert_eq!(v_b.len(), 2u);
assert_eq!(v_b[0], 2);
assert_eq!(v_b[1], 3);
// Test on managed heap.
let vec_managed = @[1, 2, 3, 4, 5];
- let v_c = slice(vec_managed, 0u, 3u).to_vec();
+ let v_c = slice(vec_managed, 0u, 3u).to_owned();
assert_eq!(v_c.len(), 3u);
assert_eq!(v_c[0], 1);
assert_eq!(v_c[1], 2);
// Test on exchange heap.
let vec_unique = ~[1, 2, 3, 4, 5, 6];
- let v_d = slice(vec_unique, 1u, 6u).to_vec();
+ let v_d = slice(vec_unique, 1u, 6u).to_owned();
assert_eq!(v_d.len(), 5u);
assert_eq!(v_d[0], 2);
assert_eq!(v_d[1], 3);
let mut abis = ~[];
for self.each |abi| { abis.push(abi); }
- for abis.eachi |i, abi| {
+ for abis.iter().enumerate().advance |(i, abi)| {
let data = abi.data();
for abis.slice(0, i).each |other_abi| {
let other_data = other_abi.data();
#[test]
fn indices_are_correct() {
- for AbiDatas.eachi |i, abi_data| {
+ for AbiDatas.iter().enumerate().advance |(i, abi_data)| {
assert!(i == abi_data.abi.index());
}
ast::meta_list(ref nb, ref misb) => {
if na != nb { return false; }
for misa.each |mi| {
- if !misb.contains(mi) { return false; }
+ if !misb.iter().any_(|x| x == mi) { return false; }
}
true
}
let mut elided = false;
let mut display_lines = /* FIXME (#2543) */ copy lines.lines;
if display_lines.len() > max_lines {
- display_lines = vec::slice(display_lines, 0u, max_lines).to_vec();
+ display_lines = vec::slice(display_lines, 0u, max_lines).to_owned();
elided = true;
}
// Print the offending lines
pub fn expand_syntax_ext(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
-> base::MacResult {
let mut res_str = ~"";
- for tts.eachi |i, e| {
+ for tts.iter().enumerate().advance |(i, e)| {
if i & 1 == 1 {
match *e {
ast::tt_tok(_, token::COMMA) => (),
let mut variants = ~[];
let rvariant_arg = cx.ident_of("read_enum_variant_arg");
- for fields.eachi |i, f| {
+ for fields.iter().enumerate().advance |(i, f)| {
let (name, parts) = match *f { (i, ref p) => (i, p) };
variants.push(cx.expr_str(span, cx.str_of(name)));
Struct(ref fields) => {
let emit_struct_field = cx.ident_of("emit_struct_field");
let mut stmts = ~[];
- for fields.eachi |i, f| {
+ for fields.iter().enumerate().advance |(i, f)| {
let (name, val) = match *f {
(Some(id), e, _) => (cx.str_of(id), e),
(None, e, _) => (fmt!("_field%u", i).to_managed(), e)
let encoder = cx.expr_ident(span, blkarg);
let emit_variant_arg = cx.ident_of("emit_enum_variant_arg");
let mut stmts = ~[];
- for fields.eachi |i, f| {
+ for fields.iter().enumerate().advance |(i, f)| {
let val = match *f { (_, e, _) => e };
let enc = cx.expr_method_call(span, val, encode, ~[blkencoder]);
let lambda = cx.lambda_expr_1(span, enc, blkarg);
None => respan(span, ast::sty_static),
};
- for self.args.eachi |i, ty| {
+ for self.args.iter().enumerate().advance |(i, ty)| {
let ast_ty = ty.to_ty(cx, span, type_ident, generics);
let ident = cx.ident_of(fmt!("__arg_%u", i));
arg_tys.push((ident, ast_ty));
let mut enum_matching_fields = vec::from_elem(self_vec.len(), ~[]);
for matches_so_far.tail().each |&(_, _, other_fields)| {
- for other_fields.eachi |i, &(_, other_field)| {
+ for other_fields.iter().enumerate().advance |(i, &(_, other_field))| {
enum_matching_fields[i].push(other_field);
}
}
}
} else {
// create an arm matching on each variant
- for enum_def.variants.eachi |index, variant| {
+ for enum_def.variants.iter().enumerate().advance |(index, variant)| {
let (pattern, idents) = create_enum_variant_pattern(cx, span,
variant,
current_match_str,
let mut ident_expr = ~[];
let mut struct_type = Unknown;
- for struct_def.fields.eachi |i, struct_field| {
+ for struct_def.fields.iter().enumerate().advance |(i, struct_field)| {
let opt_id = match struct_field.node.kind {
ast::named_field(ident, _) if (struct_type == Unknown ||
struct_type == Record) => {
// does this attribute list contain "macro_escape" ?
pub fn contains_macro_escape (attrs: &[ast::attribute]) -> bool {
- attrs.any(|attr| "macro_escape" == attr::get_attr_name(attr))
+ attrs.iter().any_(|attr| "macro_escape" == attr::get_attr_name(attr))
}
// Support for item-position macro invocations, exactly the same
fold_ident: |id,_| {
// the individual elements are memoized... it would
// also be possible to memoize on the whole list at once.
- let new_ctxt = renames.foldl(id.ctxt,|ctxt,&(from,to)| {
- new_rename(from,to,*ctxt)
+ let new_ctxt = renames.iter().fold(id.ctxt,|ctxt,&(from,to)| {
+ new_rename(from,to,ctxt)
});
ast::ident{name:id.name,ctxt:new_ctxt}
},
pub fn analyze(proto: @mut protocol_, _cx: @ExtCtxt) {
debug!("initializing colive analysis");
let num_states = proto.num_states();
- let mut colive = do (copy proto.states).map_to_vec |state| {
+ let mut colive: ~[~Bitv] = do (copy proto.states).iter().transform() |state| {
let mut bv = ~Bitv::new(num_states, false);
for state.reachable |s| {
bv.set(s.id, true);
}
bv
- };
+ }.collect();
let mut i = 0;
let mut changed = true;
changed = false;
debug!("colive iteration %?", i);
let mut new_colive = ~[];
- for colive.eachi |i, this_colive| {
+ for colive.iter().enumerate().advance |(i, this_colive)| {
let mut result = this_colive.clone();
let this = proto.get_state_by_id(i);
for this_colive.ones |j| {
// Determine if we're bounded
let mut self_live = ~[];
- for colive.eachi |i, bv| {
+ for colive.iter().enumerate().advance |(i, bv)| {
if bv.get(i) {
self_live.push(proto.get_state_by_id(i))
}
dummy_sp(),
path(~[ext_cx.ident_of("__Buffer")],
dummy_sp()),
- self.states.map_to_vec(|s| {
+ self.states.iter().transform(|s| {
let fty = s.to_ty(ext_cx);
ext_cx.field_imm(dummy_sp(),
ext_cx.ident_of(s.name),
quote_expr!(
::std::pipes::mk_packet::<$fty>()
))
- }))
+ }).collect())
}
fn gen_init_bounded(&self, ext_cx: @ExtCtxt) -> @ast::expr {
let entangle_body = ext_cx.expr_blk(
ext_cx.blk(
dummy_sp(),
- self.states.map_to_vec(
+ self.states.iter().transform(
|s| ext_cx.parse_stmt(
fmt!("data.%s.set_buffer(buffer)",
- s.name).to_managed())),
+ s.name).to_managed())).collect(),
Some(ext_cx.parse_expr(fmt!(
"::std::ptr::to_mut_unsafe_ptr(&mut (data.%s))",
self.states[0].name).to_managed()))));
fn gen_buffer_type(&self, cx: @ExtCtxt) -> @ast::item {
let ext_cx = cx;
let mut params: OptVec<ast::TyParam> = opt_vec::Empty;
- let fields = do (copy self.states).map_to_vec |s| {
+ let fields = do (copy self.states).iter().transform |s| {
for s.generics.ty_params.each |tp| {
match params.find(|tpp| tp.ident == tpp.ident) {
None => params.push(*tp),
},
span: dummy_sp()
}
- };
+ }.collect();
let generics = Generics {
lifetimes: opt_vec::Empty,
impl protocol_ {
/// Get a state.
pub fn get_state(&self, name: &str) -> state {
- self.states.find(|i| name == i.name).get()
+ *self.states.iter().find_(|i| name == i.name).get()
}
pub fn get_state_by_id(&self, id: uint) -> state { self.states[id] }
pub fn has_state(&self, name: &str) -> bool {
- self.states.find(|i| name == i.name).is_some()
+ self.states.iter().find_(|i| name == i.name).is_some()
}
pub fn filename(&self) -> ~str {
proto: protocol, visitor: V) -> Tproto {
// the copy keywords prevent recursive use of dvec
- let states = do (copy proto.states).map_to_vec |&s| {
- let messages = do (copy s.messages).map_to_vec |&m| {
+ let states: ~[Tstate] = do (copy proto.states).iter().transform |&s| {
+ let messages: ~[Tmessage] = do (copy s.messages).iter().transform |&m| {
let message(name, span, tys, this, next) = m;
visitor.visit_message(name, span, tys, this, next)
- };
+ }.collect();
visitor.visit_state(s, messages)
- };
+ }.collect();
visitor.visit_proto(proto, states)
}
let s_d = cx.parse_sess().span_diagnostic;
- for lhses.eachi |i, lhs| { // try each arm's matchers
+ for lhses.iter().enumerate().advance |(i, lhs)| { // try each arm's matchers
match *lhs {
@matched_nonterminal(nt_matchers(ref mtcs)) => {
// `none` is because we're not interpolating
print_generics(s, generics);
if traits.len() != 0u {
word(s.s, ":");
- for traits.eachi |i, trait_| {
+ for traits.iter().enumerate().advance |(i, trait_)| {
nbsp(s);
if i != 0 {
word_space(s, "+");
pub fn print_tts(s: @ps, tts: &[ast::token_tree]) {
ibox(s, 0);
- for tts.eachi |i, tt| {
+ for tts.iter().enumerate().advance |(i, tt)| {
if i != 0 {
space(s.s);
}
space(s.s);
bopen(s);
let len = arms.len();
- for arms.eachi |i, arm| {
+ for arms.iter().enumerate().advance |(i, arm)| {
space(s.s);
cbox(s, indent_unit);
ibox(s, 0u);
if os::getenv(~"RUST_BENCH").is_some() {
run_test = true
} else if argv.len() > 0 {
- run_test = argv.contains(&~"all") || argv.contains(&name)
+ run_test = argv.iter().any_(|x| x == &~"all") || argv.iter().any_(|x| x == &name)
}
if !run_test {
info!(~"Verifying graph edges...");
- let status = do edges.all() |e| {
+ let status = do edges.iter().all |e| {
let (u, v) = *e;
abs(level[u] - level[v]) <= 1
if *v == -1i64 || u == root {
true
} else {
- edges.contains(&(u, *v)) || edges.contains(&(*v, u))
+ edges.iter().any_(|x| x == &(u, *v)) || edges.iter().any_(|x| x == &(*v, u))
}
};
result
// given a map, increment the counter for a key
fn update_freq(mm: &mut HashMap<~[u8], uint>, key: &[u8]) {
- let key = vec::slice(key, 0, key.len()).to_vec();
+ let key = vec::slice(key, 0, key.len()).to_owned();
let newval = match mm.pop(&key) {
Some(v) => v + 1,
None => 1
ii += 1u;
}
- return vec::slice(bb, len - (nn - 1u), len).to_vec();
+ return vec::slice(bb, len - (nn - 1u), len).to_owned();
}
fn make_sequence_processor(sz: uint,
(_, true) => {
let line_bytes = line.as_bytes();
- for sizes.eachi |ii, _sz| {
+ for sizes.iter().enumerate().advance |(ii, _sz)| {
let mut lb = line_bytes.to_owned();
to_child[ii].send(lb);
}
}
// finish...
- for sizes.eachi |ii, _sz| {
+ for sizes.iter().enumerate().advance |(ii, _sz)| {
to_child[ii].send(~[]);
}
// now fetch and print result messages
- for sizes.eachi |ii, _sz| {
+ for sizes.iter().enumerate().advance |(ii, _sz)| {
io::println(from_child[ii].recv());
}
}
fn dot(v: &[f64], u: &[f64]) -> f64 {
let mut sum = 0.0;
- for v.eachi |i, &v_i| {
+ for v.iter().enumerate().advance |(i, &v_i)| {
sum += v_i * u[i];
}
sum
// in order for both Ord and TotalOrd
let es = [e0, e11, e12, e21, e22];
- for es.eachi |i, e1| {
- for es.eachi |j, e2| {
+ for es.iter().enumerate().advance |(i, e1)| {
+ for es.iter().enumerate().advance |(j, e2)| {
let ord = i.cmp(&j);
let eq = i == j;
// in order for both Ord and TotalOrd
let ss = [s1, s2];
- for ss.eachi |i, s1| {
- for ss.eachi |j, s2| {
+ for ss.iter().enumerate().advance |(i, s1)| {
+ for ss.iter().enumerate().advance |(j, s2)| {
let ord = i.cmp(&j);
let eq = i == j;
// in order for both Ord and TotalOrd
let tss = [ts1, ts2];
- for tss.eachi |i, ts1| {
- for tss.eachi |j, ts2| {
+ for tss.iter().enumerate().advance |(i, ts1)| {
+ for tss.iter().enumerate().advance |(j, ts2)| {
let ord = i.cmp(&j);
let eq = i == j;
+++ /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::old_iter::BaseIter;
-use std::old_iter;
-
-trait FlatMapToVec<A> {
- fn flat_map_to_vec<B, IB:BaseIter<B>>(&self, op: &fn(&A) -> IB) -> ~[B];
-}
-
-impl<A:Copy> FlatMapToVec<A> for ~[A] {
- fn flat_map_to_vec<B, IB:BaseIter<B>>(&self, op: &fn(&A) -> IB) -> ~[B] {
- old_iter::flat_map_to_vec(self, op)
- }
-}
-
-pub fn main() {}
+++ /dev/null
-// Copyright 2013 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.
-
-pub fn main() {
- let mut v = ~[1, 2, 3];
- assert!(v.position(|x| *x == 1) == Some(0));
- assert!(v.position(|x| *x == 3) == Some(2));
- assert!(v.position(|x| *x == 17) == None);
-}
projects / rust.git / commitdiff