Struct generator::Gn

pub struct Gn<A = ()> { /* private fields */ }

Generator helper

Implementations

impl<A> Gn<A>

pub fn new_scoped<'a, T, F>(f: F) -> Generator<'a, A, T>

where for<'scope> F: FnOnce(Scope<'scope, 'a, A, T>) -> T + Send + 'a, T: Send + 'a, A: Send + 'a,

create a scoped generator with default stack size

Examples found in repository

examples/pipe.rs (lines 6-11)

    fn square<'a, T: Iterator<Item = u32> + Send + 'a>(input: T) -> Generator<'a, (), u32> {
        Gn::new_scoped(|mut s| {
            for i in input {
                s.yield_with(i * i);
            }
            done!();
        })
    }

    // fn sum<'a, T: Iterator<Item = u32> + 'a>(input: T) -> impl Iterator<Item = u32> + 'a {
    fn sum<'a, T: Iterator<Item = u32> + Send + 'a>(input: T) -> Generator<'a, (), u32> {
        Gn::new_scoped(|mut s| {
            let mut acc = 0;
            for i in input {
                acc += i;
                s.yield_with(acc);
            }
            done!();
        })
    }

examples/range.rs (lines 5-12)

fn main() {
    let n = 100000;
    let range = Gn::new_scoped(move |mut s| {
        let mut num = 0;
        while num < n {
            s.yield_(num);
            num += 1;
        }
        done!();
    });

    let sum: usize = range.sum();
    println!("sum ={sum}");
}

examples/fib.rs (lines 4-12)

fn main() {
    let g = Gn::new_scoped(|mut s| {
        let (mut a, mut b) = (0, 1);
        while b < 200 {
            std::mem::swap(&mut a, &mut b);
            b += a;
            s.yield_(b);
        }
        done!();
    });

    for i in g {
        println!("{i}");
    }
}

examples/number.rs (lines 4-17)

fn factors(n: u32) -> Generator<'static, (), u32> {
    Gn::new_scoped(move |mut s| {
        if n == 0 {
            return 0;
        }

        s.yield_with(1);

        for i in 2..n {
            if n % i == 0 {
                s.yield_with(i);
            }
        }
        done!();
    })
}

examples/yield_from.rs (lines 16-20)

fn main() {
    let g1 = Gn::new(|| xrange(0, 10));
    let g2 = Gn::new(|| xrange(10, 20));

    let g = Gn::new_scoped(|mut s| {
        s.yield_from(g1);
        s.yield_from(g2);
        done!();
    });

    g.fold(0, |sum, x| {
        println!("i={}, sum={}", x, sum + x);
        sum + x
    });
}

examples/lifetime.rs (lines 4-16)

fn main() {
    let str = "foo".to_string();

    let mut gen = generator::Gn::new_scoped(|mut s| {
        std::thread::scope(|s2| {
            s2.spawn(|| {
                std::thread::sleep(std::time::Duration::from_millis(500));
                println!("{str}");
            });
            // here we can't use `yield_` because it still ref to `str`
            // `yield_` only impl for static captured lifetime
            // s.yield_(());
            unsafe { s.yield_unsafe(()) };
        });
        generator::done!();
    });

    gen.next();
    // std::mem::forget(gen);
    // drop(gen);
    // drop(str);
    std::thread::sleep(std::time::Duration::from_millis(1000));
}

Additional examples can be found in:

• examples/cd.rs

pub fn new_scoped_local<'a, T, F>(f: F) -> LocalGenerator<'a, A, T>

where F: FnOnce(Scope<'_, '_, A, T>) -> T + 'a, T: 'a, A: 'a,

create a scoped local generator with default stack size

pub fn new_scoped_opt<'a, T, F>(size: usize, f: F) -> Generator<'a, A, T>

where for<'scope> F: FnOnce(Scope<'scope, 'a, A, T>) -> T + Send + 'a, T: Send + 'a, A: Send + 'a,

create a scoped generator with specified stack size

pub fn new_scoped_opt_local<'a, T, F>( size: usize, f: F ) -> LocalGenerator<'a, A, T>

where F: FnOnce(Scope<'_, '_, A, T>) -> T + 'a, T: 'a, A: 'a,

create a scoped local generator with specified stack size

impl<A: Any> Gn<A>

pub fn new<'a, T: Any, F>(f: F) -> Generator<'a, A, T>

where F: FnOnce() -> T + Send + 'a,

👎Deprecated since 0.6.18: please use scope version instead

create a new generator with default stack size

Examples found in repository

examples/get_yield.rs (line 18)

fn main() {
    // we specify the send type is u32
    let mut s = Gn::<u32>::new(|| sum(1));
    let mut i = 1u32;
    while !s.is_done() {
        i = s.send(i);
        println!("{i}");
    }
}

examples/yield_from.rs (line 13)

fn main() {
    let g1 = Gn::new(|| xrange(0, 10));
    let g2 = Gn::new(|| xrange(10, 20));

    let g = Gn::new_scoped(|mut s| {
        s.yield_from(g1);
        s.yield_from(g2);
        done!();
    });

    g.fold(0, |sum, x| {
        println!("i={}, sum={}", x, sum + x);
        sum + x
    });
}

examples/send.rs (line 20)

fn main() {
    // we specify the send type is u32
    let mut s = Gn::<u32>::new(|| sum(0));
    // first start the generator
    assert_eq!(s.raw_send(None).unwrap(), 0);
    let mut cur = 1;
    let mut last = 1;

    while !s.is_done() {
        // println!("send={}", last);
        mem::swap(&mut cur, &mut last);
        cur = s.send(cur); // s += cur
                           // println!("cur={} last={}", cur, last);
        println!("{cur}");
    }
}

pub fn new_opt<'a, T: Any, F>(size: usize, f: F) -> Generator<'a, A, T>

where F: FnOnce() -> T + Send + 'a,

create a new generator with specified stack size