From 88962eeed86631b6646fce0602acd7daae7a1ddc Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Tue, 11 Dec 2012 09:06:56 -0800 Subject: [PATCH] core: Add &self to core::iter methods --- src/libcore/int-template.rs | 6 ++-- src/libcore/iter-trait.rs | 51 +++++++++++++++++++--------------- src/libcore/iter.rs | 39 +++++++++++++------------- src/libcore/uint-template.rs | 4 +-- src/libcore/vec.rs | 53 ++++++++++++++++++++---------------- 5 files changed, 83 insertions(+), 70 deletions(-) diff --git a/src/libcore/int-template.rs b/src/libcore/int-template.rs index 3d9de89aa6f..eed439823fc 100644 --- a/src/libcore/int-template.rs +++ b/src/libcore/int-template.rs @@ -98,12 +98,12 @@ impl T: iter::Times { will execute the given function exactly x times. If we assume that \ `x` is an int, this is functionally equivalent to \ `for int::range(0, x) |_i| { /* anything */ }`."] - pure fn times(it: fn() -> bool) { - if self < 0 { + pure fn times(&self, it: fn() -> bool) { + if *self < 0 { fail fmt!("The .times method expects a nonnegative number, \ but found %?", self); } - let mut i = self; + let mut i = *self; while i > 0 { if !it() { break } i -= 1; diff --git a/src/libcore/iter-trait.rs b/src/libcore/iter-trait.rs index e0bd4d5b7c8..001e7f5648d 100644 --- a/src/libcore/iter-trait.rs +++ b/src/libcore/iter-trait.rs @@ -20,46 +20,53 @@ use self::inst::{IMPL_T, EACH, SIZE_HINT}; impl IMPL_T: iter::BaseIter { - pure fn each(blk: fn(v: &A) -> bool) { EACH(&self, blk) } - pure fn size_hint() -> Option { SIZE_HINT(&self) } + pure fn each(&self, blk: fn(v: &A) -> bool) { EACH(self, blk) } + pure fn size_hint(&self) -> Option { SIZE_HINT(self) } } impl IMPL_T: iter::ExtendedIter { - 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 any(blk: fn(&A) -> bool) -> bool { iter::any(&self, blk) } - pure fn foldl(b0: B, blk: fn(&B, &A) -> B) -> B { - iter::foldl(&self, move b0, blk) + pure fn eachi(&self, blk: fn(uint, v: &A) -> bool) { + iter::eachi(self, blk) } - pure fn position(f: fn(&A) -> bool) -> Option { - iter::position(&self, f) + pure fn all(&self, blk: fn(&A) -> bool) -> bool { + iter::all(self, blk) + } + pure fn any(&self, blk: fn(&A) -> bool) -> bool { + iter::any(self, blk) + } + pure fn foldl(&self, b0: B, blk: fn(&B, &A) -> B) -> B { + iter::foldl(self, move b0, blk) + } + pure fn position(&self, f: fn(&A) -> bool) -> Option { + iter::position(self, f) } } impl IMPL_T: iter::EqIter { - pure fn contains(x: &A) -> bool { iter::contains(&self, x) } - pure fn count(x: &A) -> uint { iter::count(&self, x) } + pure fn contains(&self, x: &A) -> bool { iter::contains(self, x) } + pure fn count(&self, x: &A) -> uint { iter::count(self, x) } } impl IMPL_T: iter::CopyableIter { - pure fn filter_to_vec(pred: fn(a: A) -> bool) -> ~[A] { - iter::filter_to_vec(&self, pred) + pure fn filter_to_vec(&self, pred: fn(a: A) -> bool) -> ~[A] { + iter::filter_to_vec(self, pred) } - pure fn map_to_vec(op: fn(v: A) -> B) -> ~[B] { - iter::map_to_vec(&self, op) + pure fn map_to_vec(&self, op: fn(v: A) -> B) -> ~[B] { + iter::map_to_vec(self, op) } - pure fn to_vec() -> ~[A] { iter::to_vec(&self) } + pure fn to_vec(&self) -> ~[A] { iter::to_vec(self) } - pure fn flat_map_to_vec>(op: fn(a: A) -> IB) + pure fn flat_map_to_vec>(&self, op: fn(a: A) -> IB) -> ~[B] { - iter::flat_map_to_vec(&self, op) + iter::flat_map_to_vec(self, op) + } + pure fn find(&self, f: fn(A) -> bool) -> Option { + iter::find(self, f) } - - pure fn find(p: fn(a: A) -> bool) -> Option { iter::find(&self, p) } } impl IMPL_T: iter::CopyableOrderedIter { - pure fn min() -> A { iter::min(&self) } - pure fn max() -> A { iter::max(&self) } + pure fn min(&self) -> A { iter::min(self) } + pure fn max(&self) -> A { iter::max(self) } } diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 7685fe06ad9..2933259a18e 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -23,38 +23,39 @@ pub type InitOp = &fn(uint) -> T; pub trait BaseIter { - pure fn each(blk: fn(v: &A) -> bool); - pure fn size_hint() -> Option; + pure fn each(&self, blk: fn(v: &A) -> bool); + pure fn size_hint(&self) -> Option; } pub trait ExtendedIter { - pure fn eachi(blk: fn(uint, v: &A) -> bool); - pure fn all(blk: fn(&A) -> bool) -> bool; - pure fn any(blk: fn(&A) -> bool) -> bool; - pure fn foldl(b0: B, blk: fn(&B, &A) -> B) -> B; - pure fn position(f: fn(&A) -> bool) -> Option; + pure fn eachi(&self, blk: fn(uint, v: &A) -> bool); + pure fn all(&self, blk: fn(&A) -> bool) -> bool; + pure fn any(&self, blk: fn(&A) -> bool) -> bool; + pure fn foldl(&self, b0: B, blk: fn(&B, &A) -> B) -> B; + pure fn position(&self, f: fn(&A) -> bool) -> Option; } pub trait EqIter { - pure fn contains(x: &A) -> bool; - pure fn count(x: &A) -> uint; + pure fn contains(&self, x: &A) -> bool; + pure fn count(&self, x: &A) -> uint; } pub trait Times { - pure fn times(it: fn() -> bool); + pure fn times(&self, it: fn() -> bool); } pub trait CopyableIter { - pure fn filter_to_vec(pred: fn(a: A) -> bool) -> ~[A]; - pure fn map_to_vec(op: fn(v: A) -> B) -> ~[B]; - pure fn flat_map_to_vec>(op: fn(A) -> IB) -> ~[B]; - pure fn to_vec() -> ~[A]; - pure fn find(p: fn(a: A) -> bool) -> Option; + pure fn filter_to_vec(&self, pred: fn(a: A) -> bool) -> ~[A]; + pure fn map_to_vec(&self, op: fn(v: A) -> B) -> ~[B]; + pure fn flat_map_to_vec>(&self, op: fn(A) -> IB) + -> ~[B]; + pure fn to_vec(&self) -> ~[A]; + pure fn find(&self, p: fn(A) -> bool) -> Option; } pub trait CopyableOrderedIter { - pure fn min() -> A; - pure fn max() -> A; + pure fn min(&self) -> A; + pure fn max(&self) -> A; } pub trait CopyableNonstrictIter { @@ -222,9 +223,9 @@ pub trait Buildable { } pub pure fn find>(self: &IA, - p: fn(a: A) -> bool) -> Option { + f: fn(A) -> bool) -> Option { for self.each |i| { - if p(*i) { return Some(*i) } + if f(*i) { return Some(*i) } } return None; } diff --git a/src/libcore/uint-template.rs b/src/libcore/uint-template.rs index da0c92021a4..1a9bca92d1f 100644 --- a/src/libcore/uint-template.rs +++ b/src/libcore/uint-template.rs @@ -92,8 +92,8 @@ impl T: iter::Times { will execute the given function exactly x times. If we assume that \ `x` is an int, this is functionally equivalent to \ `for int::range(0, x) |_i| { /* anything */ }`."] - pure fn times(it: fn() -> bool) { - let mut i = self; + pure fn times(&self, it: fn() -> bool) { + let mut i = *self; while i > 0 { if !it() { break } i -= 1; diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs index c568faccf89..912f9b1bf1b 100644 --- a/src/libcore/vec.rs +++ b/src/libcore/vec.rs @@ -2013,57 +2013,62 @@ pub fn memmove(dst: &[mut u8], src: &[const u8], count: uint) { // required in the slice. impl &[A]: iter::BaseIter { - pub pure fn each(blk: fn(v: &A) -> bool) { + pub pure fn each(&self, blk: fn(v: &A) -> bool) { // FIXME(#2263)---should be able to call each(self, blk) - for each(self) |e| { + for each(*self) |e| { if (!blk(e)) { return; } } } - pure fn size_hint() -> Option { Some(len(self)) } + pure fn size_hint(&self) -> Option { Some(len(*self)) } } impl &[A]: iter::ExtendedIter { - pub pure fn eachi(blk: fn(uint, v: &A) -> bool) { - iter::eachi(&self, blk) + pub pure fn eachi(&self, blk: fn(uint, v: &A) -> bool) { + iter::eachi(self, blk) } - pub pure fn all(blk: fn(&A) -> bool) -> bool { iter::all(&self, blk) } - pub pure fn any(blk: fn(&A) -> bool) -> bool { iter::any(&self, blk) } - pub pure fn foldl(b0: B, blk: fn(&B, &A) -> B) -> B { - iter::foldl(&self, b0, blk) + pub pure fn all(&self, blk: fn(&A) -> bool) -> bool { + iter::all(self, blk) } - pub pure fn position(f: fn(&A) -> bool) -> Option { - iter::position(&self, f) + pub pure fn any(&self, blk: fn(&A) -> bool) -> bool { + iter::any(self, blk) + } + pub pure fn foldl(&self, b0: B, blk: fn(&B, &A) -> B) -> B { + iter::foldl(self, b0, blk) + } + pub pure fn position(&self, f: fn(&A) -> bool) -> Option { + iter::position(self, f) } } impl &[A]: iter::EqIter { - pub pure fn contains(x: &A) -> bool { iter::contains(&self, x) } - pub pure fn count(x: &A) -> uint { iter::count(&self, x) } + pub pure fn contains(&self, x: &A) -> bool { iter::contains(self, x) } + pub pure fn count(&self, x: &A) -> uint { iter::count(self, x) } } impl &[A]: iter::CopyableIter { - pure fn filter_to_vec(pred: fn(a: A) -> bool) -> ~[A] { - iter::filter_to_vec(&self, pred) + pure fn filter_to_vec(&self, pred: fn(a: A) -> bool) -> ~[A] { + iter::filter_to_vec(self, pred) } - pure fn map_to_vec(op: fn(v: A) -> B) -> ~[B] { - iter::map_to_vec(&self, op) + pure fn map_to_vec(&self, op: fn(v: A) -> B) -> ~[B] { + iter::map_to_vec(self, op) } - pure fn to_vec() -> ~[A] { iter::to_vec(&self) } + pure fn to_vec(&self) -> ~[A] { iter::to_vec(self) } - pure fn flat_map_to_vec>(op: fn(A) -> IB) -> ~[B] { - iter::flat_map_to_vec(&self, op) + pure fn flat_map_to_vec>(&self, op: fn(A) -> IB) + -> ~[B] { + iter::flat_map_to_vec(self, op) } - pub pure fn find(p: fn(a: A) -> bool) -> Option { - iter::find(&self, p) + pub pure fn find(&self, f: fn(A) -> bool) -> Option { + iter::find(self, f) } } impl &[A]: iter::CopyableOrderedIter { - pure fn min() -> A { iter::min(&self) } - pure fn max() -> A { iter::max(&self) } + pure fn min(&self) -> A { iter::min(self) } + pure fn max(&self) -> A { iter::max(self) } } impl &[A] : iter::CopyableNonstrictIter { -- GitLab