rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Demode iter-trait

Browse Source
This commit is contained in:
Tim Chevalier
2012-09-25 17:39:22 -07:00
parent 473a866733
commit e19e628b19
21 changed files with 70 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/libcore/iter-trait.rs
View File

@@ -2,17 +2,19 @@
// workaround our lack of traits and lack of macros. See core.{rc,rs} for // workaround our lack of traits and lack of macros. See core.{rc,rs} for
// how this file is used. // how this file is used.
#[warn(deprecated_mode)];
use cmp::{Eq, Ord}; use cmp::{Eq, Ord};
use inst::{IMPL_T, EACH, SIZE_HINT}; use inst::{IMPL_T, EACH, SIZE_HINT};
export extensions; export extensions;
impl<A> IMPL_T<A>: iter::BaseIter<A> { impl<A> IMPL_T<A>: iter::BaseIter<A> {
pure fn each(blk: fn(v: &A) -> bool) { EACH(self, blk) } pure fn each(blk: fn(v: &A) -> bool) { EACH(&self, blk) }
pure fn size_hint() -> Option<uint> { SIZE_HINT(self) } pure fn size_hint() -> Option<uint> { SIZE_HINT(&self) }
} }
impl<A> IMPL_T<A>: iter::ExtendedIter<A> { impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
pure fn eachi(blk: fn(uint, v: &A) -> bool) { iter::eachi(self, blk) } pure fn eachi(blk: fn(uint, v: &A) -> bool) { iter::eachi(&self, blk) }
pure fn all(blk: fn(A) -> bool) -> bool { iter::all(self, blk) } pure fn all(blk: fn(A) -> bool) -> bool { iter::all(self, blk) }
pure fn any(blk: fn(A) -> bool) -> bool { iter::any(self, blk) } pure fn any(blk: fn(A) -> bool) -> bool { iter::any(self, blk) }
pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B { pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B {
@@ -24,8 +26,8 @@ impl<A> IMPL_T<A>: iter::ExtendedIter<A> {
} }
impl<A: Eq> IMPL_T<A>: iter::EqIter<A> { impl<A: Eq> IMPL_T<A>: iter::EqIter<A> {
pure fn contains(x: A) -> bool { iter::contains(self, x) } pure fn contains(x: &A) -> bool { iter::contains(self, x) }
pure fn count(x: A) -> uint { iter::count(self, x) } pure fn count(x: &A) -> uint { iter::count(self, x) }
} }
impl<A: Copy> IMPL_T<A>: iter::CopyableIter<A> { impl<A: Copy> IMPL_T<A>: iter::CopyableIter<A> {

4
src/libcore/iter-trait/dlist.rs
View File

@@ -8,7 +8,7 @@ type IMPL_T<A> = dlist::DList<A>;
* e.g. breadth-first search with in-place enqueues), but removing the current * e.g. breadth-first search with in-place enqueues), but removing the current
* node is forbidden. * node is forbidden.
*/ */
pure fn EACH<A>(self: IMPL_T<A>, f: fn(v: &A) -> bool) { pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
let mut link = self.peek_n(); let mut link = self.peek_n();
while option::is_some(&link) { while option::is_some(&link) {
let nobe = option::get(&link); let nobe = option::get(&link);
@@ -29,6 +29,6 @@ pure fn EACH<A>(self: IMPL_T<A>, f: fn(v: &A) -> bool) {
} }
} }
pure fn SIZE_HINT<A>(self: IMPL_T<A>) -> Option<uint> { pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
Some(self.len()) Some(self.len())
} }

4
src/libcore/iter-trait/dvec.rs
View File

@@ -6,7 +6,7 @@ type IMPL_T<A> = dvec::DVec<A>;
* *
* Attempts to access this dvec during iteration will fail. * Attempts to access this dvec during iteration will fail.
*/ */
pure fn EACH<A>(self: IMPL_T<A>, f: fn(v: &A) -> bool) { pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
unsafe { unsafe {
do self.swap |v| { do self.swap |v| {
v.each(f); v.each(f);
@@ -15,6 +15,6 @@ pure fn EACH<A>(self: IMPL_T<A>, f: fn(v: &A) -> bool) {
} }
} }
pure fn SIZE_HINT<A>(self: IMPL_T<A>) -> Option<uint> { pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
Some(self.len()) Some(self.len())
} }

12
src/libcore/iter-trait/option.rs
View File

@@ -1,16 +1,16 @@
#[allow(non_camel_case_types)] #[allow(non_camel_case_types)]
type IMPL_T<A> = Option<A>; type IMPL_T<A> = Option<A>;
pure fn EACH<A>(self: IMPL_T<A>, f: fn(v: &A) -> bool) { pure fn EACH<A>(self: &IMPL_T<A>, f: fn(v: &A) -> bool) {
match self { match *self {
None => (), None => (),
Some(ref a) => { f(a); } Some(ref a) => { f(a); }
} }
} }
pure fn SIZE_HINT<A>(self: IMPL_T<A>) -> Option<uint> { pure fn SIZE_HINT<A>(self: &IMPL_T<A>) -> Option<uint> {
match self { match *self {
None => Some(0u), None => Some(0),
Some(_) => Some(1u) Some(_) => Some(1)
} }
} }

22
src/libcore/iter.rs
View File

@@ -23,8 +23,8 @@ trait ExtendedIter<A> {
} }
trait EqIter<A:Eq> { trait EqIter<A:Eq> {
pure fn contains(x: A) -> bool; pure fn contains(x: &A) -> bool;
pure fn count(x: A) -> uint; pure fn count(x: &A) -> uint;
} }
trait Times { trait Times {
@@ -66,11 +66,11 @@ trait Buildable<A> {
builder: fn(push: pure fn(+v: A))) -> self; builder: fn(push: pure fn(+v: A))) -> self;
} }
pure fn eachi<A,IA:BaseIter<A>>(self: IA, blk: fn(uint, v: &A) -> bool) { pure fn eachi<A,IA:BaseIter<A>>(self: &IA, blk: fn(uint, v: &A) -> bool) {
let mut i = 0u; let mut i = 0;
for self.each |a| { for self.each |a| {
if !blk(i, a) { break; } if !blk(i, a) { break; }
i += 1u; i += 1;
} }
} }
@@ -130,17 +130,17 @@ pure fn to_vec<A:Copy,IA:BaseIter<A>>(self: IA) -> ~[A] {
foldl::<A,~[A],IA>(self, ~[], |r, a| vec::append(copy r, ~[a])) foldl::<A,~[A],IA>(self, ~[], |r, a| vec::append(copy r, ~[a]))
} }
pure fn contains<A:Eq,IA:BaseIter<A>>(self: IA, x: A) -> bool { pure fn contains<A:Eq,IA:BaseIter<A>>(self: IA, x: &A) -> bool {
for self.each |a| { for self.each |a| {
if *a == x { return true; } if *a == *x { return true; }
} }
return false; return false;
} }
pure fn count<A:Eq,IA:BaseIter<A>>(self: IA, x: A) -> uint { pure fn count<A:Eq,IA:BaseIter<A>>(self: IA, x: &A) -> uint {
do foldl(self, 0u) |count, value| { do foldl(self, 0) |count, value| {
if value == x { if value == *x {
count + 1u count + 1
} else { } else {
count count
} }

4
src/libcore/str.rs
View File

@@ -377,7 +377,7 @@ fn unshift_char(s: &mut ~str, ch: char) {
pure fn trim_left_chars(s: &str, chars_to_trim: &[char]) -> ~str { pure fn trim_left_chars(s: &str, chars_to_trim: &[char]) -> ~str {
if chars_to_trim.is_empty() { return from_slice(s); } if chars_to_trim.is_empty() { return from_slice(s); }
match find(s, |c| !chars_to_trim.contains(c)) { match find(s, |c| !chars_to_trim.contains(&c)) {
None => ~"", None => ~"",
Some(first) => unsafe { raw::slice_bytes(s, first, s.len()) } Some(first) => unsafe { raw::slice_bytes(s, first, s.len()) }
} }
@@ -395,7 +395,7 @@ pure fn trim_left_chars(s: &str, chars_to_trim: &[char]) -> ~str {
pure fn trim_right_chars(s: &str, chars_to_trim: &[char]) -> ~str { pure fn trim_right_chars(s: &str, chars_to_trim: &[char]) -> ~str {
if chars_to_trim.is_empty() { return str::from_slice(s); } if chars_to_trim.is_empty() { return str::from_slice(s); }
match rfind(s, |c| !chars_to_trim.contains(c)) { match rfind(s, |c| !chars_to_trim.contains(&c)) {
None => ~"", None => ~"",
Some(last) => { Some(last) => {
let {next, _} = char_range_at(s, last); let {next, _} = char_range_at(s, last);

6
src/libcore/vec.rs
View File

@@ -1873,7 +1873,7 @@ impl<A> &[A]: iter::BaseIter<A> {
} }
impl<A> &[A]: iter::ExtendedIter<A> { impl<A> &[A]: iter::ExtendedIter<A> {
pure fn eachi(blk: fn(uint, v: &A) -> bool) { iter::eachi(self, blk) } pure fn eachi(blk: fn(uint, v: &A) -> bool) { iter::eachi(&self, blk) }
pure fn all(blk: fn(A) -> bool) -> bool { iter::all(self, blk) } pure fn all(blk: fn(A) -> bool) -> bool { iter::all(self, blk) }
pure fn any(blk: fn(A) -> bool) -> bool { iter::any(self, blk) } pure fn any(blk: fn(A) -> bool) -> bool { iter::any(self, blk) }
pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B { pure fn foldl<B>(+b0: B, blk: fn(B, A) -> B) -> B {
@@ -1885,8 +1885,8 @@ impl<A> &[A]: iter::ExtendedIter<A> {
} }
impl<A: Eq> &[A]: iter::EqIter<A> { impl<A: Eq> &[A]: iter::EqIter<A> {
pure fn contains(x: A) -> bool { iter::contains(self, x) } pure fn contains(x: &A) -> bool { iter::contains(self, x) }
pure fn count(x: A) -> uint { iter::count(self, x) } pure fn count(x: &A) -> uint { iter::count(self, x) }
} }
impl<A: Copy> &[A]: iter::CopyableIter<A> { impl<A: Copy> &[A]: iter::CopyableIter<A> {

2
src/libstd/net_url.rs
View File

@@ -524,7 +524,7 @@ fn get_authority(rawurl: &str) ->
let host_is_end_plus_one: &fn() -> bool = || { let host_is_end_plus_one: &fn() -> bool = || {
end+1 == len end+1 == len
&& !['?', '#', '/'].contains(rawurl[end] as char) && !['?', '#', '/'].contains(&(rawurl[end] as char))
}; };
// finish up // finish up

4
src/rustc/driver/rustc.rs
View File

@@ -140,12 +140,12 @@ fn run_compiler(args: ~[~str], demitter: diagnostic::emitter) {
let lint_flags = vec::append(getopts::opt_strs(matches, ~"W"), let lint_flags = vec::append(getopts::opt_strs(matches, ~"W"),
getopts::opt_strs(matches, ~"warn")); getopts::opt_strs(matches, ~"warn"));
if lint_flags.contains(~"help") { if lint_flags.contains(&~"help") {
describe_warnings(); describe_warnings();
return; return;
} }
if getopts::opt_strs(matches, ~"Z").contains(~"help") { if getopts::opt_strs(matches, ~"Z").contains(&~"help") {
describe_debug_flags(); describe_debug_flags();
return; return;
} }

4
src/rustc/middle/borrowck/check_loans.rs
View File

@@ -204,7 +204,7 @@ impl check_loan_ctxt {
let did = ast_util::def_id_of_def(def); let did = ast_util::def_id_of_def(def);
let is_fn_arg = let is_fn_arg =
did.crate == ast::local_crate && did.crate == ast::local_crate &&
(*self.fn_args).contains(did.node); (*self.fn_args).contains(&(did.node));
if is_fn_arg { return; } // case (a) above if is_fn_arg { return; } // case (a) above
} }
ast::expr_fn_block(*) | ast::expr_fn(*) | ast::expr_fn_block(*) | ast::expr_fn(*) |
@@ -251,7 +251,7 @@ impl check_loan_ctxt {
let def = self.tcx().def_map.get(expr.id); let def = self.tcx().def_map.get(expr.id);
let did = ast_util::def_id_of_def(def); let did = ast_util::def_id_of_def(def);
did.crate == ast::local_crate && did.crate == ast::local_crate &&
(*self.fn_args).contains(did.node) (*self.fn_args).contains(&(did.node))
} }
ast::expr_fn_block(*) | ast::expr_fn(*) => { ast::expr_fn_block(*) | ast::expr_fn(*) => {
self.is_stack_closure(expr.id) self.is_stack_closure(expr.id)

2
src/rustc/middle/check_alt.rs
View File

@@ -275,7 +275,7 @@ fn missing_ctor(tcx: ty::ctxt, m: matrix, left_ty: ty::t) -> Option<ctor> {
let variants = ty::enum_variants(tcx, eid); let variants = ty::enum_variants(tcx, eid);
if found.len() != (*variants).len() { if found.len() != (*variants).len() {
for vec::each(*variants) |v| { for vec::each(*variants) |v| {
if !found.contains(variant(v.id)) { if !found.contains(&(variant(v.id))) {
return Some(variant(v.id)); return Some(variant(v.id));
} }
} }

2
src/rustc/middle/check_const.rs
View File

@@ -169,7 +169,7 @@ fn check_item_recursion(sess: session, ast_map: ast_map::map,
visitor.visit_item(it, env, visitor); visitor.visit_item(it, env, visitor);
fn visit_item(it: @item, &&env: env, v: visit::vt<env>) { fn visit_item(it: @item, &&env: env, v: visit::vt<env>) {
if (*env.idstack).contains(it.id) { if (*env.idstack).contains(&(it.id)) {
env.sess.span_fatal(env.root_it.span, ~"recursive constant"); env.sess.span_fatal(env.root_it.span, ~"recursive constant");
} }
(*env.idstack).push(it.id); (*env.idstack).push(it.id);

6
src/rustc/middle/kind.rs
View File

@@ -199,13 +199,13 @@ fn check_fn(fk: visit::fn_kind, decl: fn_decl, body: blk, sp: span,
let id = ast_util::def_id_of_def(fv.def).node; let id = ast_util::def_id_of_def(fv.def).node;
// skip over free variables that appear in the cap clause // skip over free variables that appear in the cap clause
if captured_vars.contains(id) { loop; } if captured_vars.contains(&id) { loop; }
// if this is the last use of the variable, then it will be // if this is the last use of the variable, then it will be
// a move and not a copy // a move and not a copy
let is_move = { let is_move = {
match cx.last_use_map.find(fn_id) { match cx.last_use_map.find(fn_id) {
Some(vars) => (*vars).contains(id), Some(vars) => (*vars).contains(&id),
None => false None => false
} }
}; };
@@ -588,7 +588,7 @@ fn check_cast_for_escaping_regions(
do ty::walk_ty(source_ty) |ty| { do ty::walk_ty(source_ty) |ty| {
match ty::get(ty).sty { match ty::get(ty).sty {
ty::ty_param(source_param) => { ty::ty_param(source_param) => {
if target_params.contains(source_param) { if target_params.contains(&source_param) {
/* case (2) */ /* case (2) */
} else { } else {
check_owned(cx.tcx, ty, source.span); /* case (3) */ check_owned(cx.tcx, ty, source.span); /* case (3) */

14
src/rustc/middle/privacy.rs
View File

@@ -56,7 +56,7 @@ fn check_crate(tcx: ty::ctxt, method_map: &method_map, crate: @ast::crate) {
if method.vis == private && if method.vis == private &&
(impl_id.crate != local_crate || (impl_id.crate != local_crate ||
!privileged_items !privileged_items
.contains(impl_id.node)) { .contains(&(impl_id.node))) {
tcx.sess.span_err(span, tcx.sess.span_err(span,
fmt!("method `%s` is \ fmt!("method `%s` is \
private", private",
@@ -95,9 +95,9 @@ fn check_crate(tcx: ty::ctxt, method_map: &method_map, crate: @ast::crate) {
} }
match methods[method_num] { match methods[method_num] {
provided(method) provided(method)
if method.vis == private && if method.vis == private &&
!privileged_items !privileged_items
.contains(trait_id.node) => { .contains(&(trait_id.node)) => {
tcx.sess.span_err(span, tcx.sess.span_err(span,
fmt!("method fmt!("method
`%s` \ `%s` \
@@ -157,7 +157,7 @@ fn check_crate(tcx: ty::ctxt, method_map: &method_map, crate: @ast::crate) {
match ty::get(ty::expr_ty(tcx, base)).sty { match ty::get(ty::expr_ty(tcx, base)).sty {
ty_class(id, _) ty_class(id, _)
if id.crate != local_crate || if id.crate != local_crate ||
!privileged_items.contains(id.node) => { !privileged_items.contains(&(id.node)) => {
match method_map.find(expr.id) { match method_map.find(expr.id) {
None => { None => {
debug!("(privacy checking) checking \ debug!("(privacy checking) checking \
@@ -178,7 +178,7 @@ fn check_crate(tcx: ty::ctxt, method_map: &method_map, crate: @ast::crate) {
match ty::get(ty::expr_ty(tcx, expr)).sty { match ty::get(ty::expr_ty(tcx, expr)).sty {
ty_class(id, _) => { ty_class(id, _) => {
if id.crate != local_crate || if id.crate != local_crate ||
!privileged_items.contains(id.node) { !privileged_items.contains(&(id.node)) {
for fields.each |field| { for fields.each |field| {
debug!("(privacy checking) checking \ debug!("(privacy checking) checking \
field in struct literal"); field in struct literal");
@@ -205,7 +205,7 @@ fn check_crate(tcx: ty::ctxt, method_map: &method_map, crate: @ast::crate) {
match ty::get(ty::pat_ty(tcx, pattern)).sty { match ty::get(ty::pat_ty(tcx, pattern)).sty {
ty_class(id, _) => { ty_class(id, _) => {
if id.crate != local_crate || if id.crate != local_crate ||
!privileged_items.contains(id.node) { !privileged_items.contains(&(id.node)) {
for fields.each |field| { for fields.each |field| {
debug!("(privacy checking) checking \ debug!("(privacy checking) checking \
struct pattern"); struct pattern");

2
src/rustc/middle/region.rs
View File

@@ -485,7 +485,7 @@ impl determine_rp_ctxt {
} }
}; };
let dep = {ambient_variance: self.ambient_variance, id: self.item_id}; let dep = {ambient_variance: self.ambient_variance, id: self.item_id};
if !vec.contains(dep) { vec.push(dep); } if !vec.contains(&dep) { vec.push(dep); }
} }
// Determines whether a reference to a region that appears in the // Determines whether a reference to a region that appears in the

2
src/rustc/middle/trans/expr.rs
View File

@@ -813,7 +813,7 @@ fn trans_local_var(bcx: block, ref_id: ast::node_id, def: ast::def) -> Datum {
nid: ast::node_id) -> Datum { nid: ast::node_id) -> Datum {
let is_last_use = match bcx.ccx().maps.last_use_map.find(ref_id) { let is_last_use = match bcx.ccx().maps.last_use_map.find(ref_id) {
None => false, None => false,
Some(vars) => (*vars).contains(nid) Some(vars) => (*vars).contains(&nid)
}; };
let source = if is_last_use {FromLastUseLvalue} else {FromLvalue}; let source = if is_last_use {FromLastUseLvalue} else {FromLvalue};

2
src/rustc/middle/typeck/check/method.rs
View File

@@ -182,7 +182,7 @@ impl LookupContext {
ty_enum(did, _) => { ty_enum(did, _) => {
// Watch out for newtype'd enums like "enum t = @T". // Watch out for newtype'd enums like "enum t = @T".
// See discussion in typeck::check::do_autoderef(). // See discussion in typeck::check::do_autoderef().
if enum_dids.contains(did) { if enum_dids.contains(&did) {
return None; return None;
} }
enum_dids.push(did); enum_dids.push(did);

2
src/rustdoc/rustdoc.rs
View File

@@ -5,7 +5,7 @@ use config::Config;
fn main(args: ~[~str]) { fn main(args: ~[~str]) {
if args.contains(~"-h") || args.contains(~"--help") { if args.contains(&~"-h") || args.contains(&~"--help") {
config::usage(); config::usage();
return; return;
} }

2
src/test/run-pass/early-vtbl-resolution.rs
View File

@@ -9,7 +9,7 @@ fn foo_func<A, B: thing<A>>(x: B) -> Option<A> { x.foo() }
fn main() { fn main() {
for iter::eachi(Some({a: 0})) |i, a| { for iter::eachi(&(Some({a: 0}))) |i, a| {
#debug["%u %d", i, a.a]; #debug["%u %d", i, a.a];
} }

16
src/test/run-pass/iter-contains.rs
View File

@@ -1,10 +1,10 @@
fn main() { fn main() {
assert []/_.contains(22u) == false; assert []/_.contains(&22u) == false;
assert [1u, 3u]/_.contains(22u) == false; assert [1u, 3u]/_.contains(&22u) == false;
assert [22u, 1u, 3u]/_.contains(22u) == true; assert [22u, 1u, 3u]/_.contains(&22u) == true;
assert [1u, 22u, 3u]/_.contains(22u) == true; assert [1u, 22u, 3u]/_.contains(&22u) == true;
assert [1u, 3u, 22u]/_.contains(22u) == true; assert [1u, 3u, 22u]/_.contains(&22u) == true;
assert None.contains(22u) == false; assert None.contains(&22u) == false;
assert Some(1u).contains(22u) == false; assert Some(1u).contains(&22u) == false;
assert Some(22u).contains(22u) == true; assert Some(22u).contains(&22u) == true;
} }

14
src/test/run-pass/iter-count.rs
View File

@@ -1,9 +1,9 @@
fn main() { fn main() {
assert []/_.count(22u) == 0u; assert []/_.count(&22u) == 0u;
assert [1u, 3u]/_.count(22u) == 0u; assert [1u, 3u]/_.count(&22u) == 0u;
assert [22u, 1u, 3u]/_.count(22u) == 1u; assert [22u, 1u, 3u]/_.count(&22u) == 1u;
assert [22u, 1u, 22u]/_.count(22u) == 2u; assert [22u, 1u, 22u]/_.count(&22u) == 2u;
assert None.count(22u) == 0u; assert None.count(&22u) == 0u;
assert Some(1u).count(22u) == 0u; assert Some(1u).count(&22u) == 0u;
assert Some(22u).count(22u) == 1u; assert Some(22u).count(&22u) == 1u;
} }