OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

libcore: use unboxed closures in the fields of Unfold

Browse Source
This commit is contained in:
Jorge Aparicio 2014-12-03 15:51:47 -05:00
parent a50c587242
commit 216bcfd66b
1 changed files with 18 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
src/libcore/iter.rs
View File

@ -2108,19 +2108,18 @@ impl<A, I, F> RandomAccessIterator<A> for Inspect<A, I, F> where
/// } /// }
/// ``` /// ```
#[experimental] #[experimental]
pub struct Unfold<'a, A, St> { pub struct Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> {
f: |&mut St|: 'a -> Option<A>, f: F,
/// Internal state that will be passed to the closure on the next iteration /// Internal state that will be passed to the closure on the next iteration
pub state: St, pub state: St,
} }
#[experimental] #[experimental]
impl<'a, A, St> Unfold<'a, A, St> { impl<A, St, F> Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> {
/// Creates a new iterator with the specified closure as the "iterator /// Creates a new iterator with the specified closure as the "iterator
/// function" and an initial state to eventually pass to the closure /// function" and an initial state to eventually pass to the closure
#[inline] #[inline]
pub fn new<'a>(initial_state: St, f: |&mut St|: 'a -> Option<A>) pub fn new(initial_state: St, f: F) -> Unfold<A, St, F> {
-> Unfold<'a, A, St> {
Unfold { Unfold {
f: f, f: f,
state: initial_state state: initial_state
@ -2129,7 +2128,7 @@ impl<'a, A, St> Unfold<'a, A, St> {
} }
#[experimental] #[experimental]
impl<'a, A, St> Iterator<A> for Unfold<'a, A, St> { impl<A, St, F> Iterator<A> for Unfold<A, St, F> where F: FnMut(&mut St) -> Option<A> {
#[inline] #[inline]
fn next(&mut self) -> Option<A> { fn next(&mut self) -> Option<A> {
(self.f)(&mut self.state) (self.f)(&mut self.state)
@ -2456,18 +2455,24 @@ impl<A: Clone> RandomAccessIterator<A> for Repeat<A> {
fn idx(&mut self, _: uint) -> Option<A> { Some(self.element.clone()) } fn idx(&mut self, _: uint) -> Option<A> { Some(self.element.clone()) }
} }
type IterateState<'a, T> = (|T|: 'a -> T, Option<T>, bool); type IterateState<T, F> = (F, Option<T>, bool);
/// An iterator that repeatedly applies a given function, starting /// An iterator that repeatedly applies a given function, starting
/// from a given seed value. /// from a given seed value.
#[experimental] #[experimental]
pub type Iterate<'a, T> = Unfold<'a, T, IterateState<'a, T>>; pub type Iterate<T, F> = Unfold<T, IterateState<T, F>, fn(&mut IterateState<T, F>) -> Option<T>>;
/// Create a new iterator that produces an infinite sequence of /// Create a new iterator that produces an infinite sequence of
/// repeated applications of the given function `f`. /// repeated applications of the given function `f`.
#[experimental] #[experimental]
pub fn iterate<'a, T: Clone>(seed: T, f: |T|: 'a -> T) -> Iterate<'a, T> { pub fn iterate<T, F>(seed: T, f: F) -> Iterate<T, F> where
Unfold::new((f, Some(seed), true), |st| { T: Clone,
F: FnMut(T) -> T,
{
fn next<T, F>(st: &mut IterateState<T, F>) -> Option<T> where
T: Clone,
F: FnMut(T) -> T,
{
let &(ref mut f, ref mut val, ref mut first) = st; let &(ref mut f, ref mut val, ref mut first) = st;
if *first { if *first {
*first = false; *first = false;
@ -2480,7 +2485,9 @@ pub fn iterate<'a, T: Clone>(seed: T, f: |T|: 'a -> T) -> Iterate<'a, T> {
} }
} }
val.clone() val.clone()
}) }
Unfold::new((f, Some(seed), true), next)
} }
/// Create a new iterator that endlessly repeats the element `elt`. /// Create a new iterator that endlessly repeats the element `elt`.