Vendor things

third-party/vendor/generator/examples/cd.rs

@@ -0,0 +1,64 @@
+use generator::*;
+
+#[derive(Debug)]
+enum Action {
+    Play(&'static str),
+    Stop,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+enum State {
+    Playing,
+    Stopped,
+}
+
+use crate::Action::*;
+use crate::State::*;
+
+fn main() {
+    let mut cd_player = Gn::new_scoped(|mut s| {
+        let mut state = Stopped;
+        loop {
+            // println!("{:?}", *state);
+            // in release mod without this there is bugs!!!!! (rustc 1.59.0 (9d1b2106e 2022-02-23))
+            std::sync::atomic::compiler_fence(std::sync::atomic::Ordering::AcqRel);
+
+            match state {
+                Stopped => match s.get_yield() {
+                    Some(Play(t)) => {
+                        println!("I'm playing {t}");
+                        state = Playing;
+                    }
+                    Some(Stop) => println!("I'm already stopped"),
+                    _ => unreachable!("some thing wrong"),
+                },
+
+                Playing => match s.get_yield() {
+                    Some(Stop) => {
+                        println!("I'm stopped");
+                        state = Stopped;
+                    }
+                    Some(Play(_)) => println!("should first stop"),
+                    _ => unreachable!("some thing wrong"),
+                },
+            }
+
+            s.yield_with(state);
+        }
+    });
+
+    for _ in 0..1000 {
+        let ret = cd_player.send(Play("hello world"));
+        assert_eq!(ret, Playing);
+        let ret = cd_player.send(Play("hello another day"));
+        assert_eq!(ret, Playing);
+        let ret = cd_player.send(Stop);
+        assert_eq!(ret, Stopped);
+        let ret = cd_player.send(Stop);
+        assert_eq!(ret, Stopped);
+        let ret = cd_player.send(Play("hello another day"));
+        assert_eq!(ret, Playing);
+        let ret = cd_player.send(Stop);
+        assert_eq!(ret, Stopped);
+    }
+}

third-party/vendor/generator/examples/fib.rs

@@ -0,0 +1,17 @@
+use generator::{done, Gn};
+
+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}");
+    }
+}

third-party/vendor/generator/examples/get_yield.rs

@@ -0,0 +1,24 @@
+#![allow(deprecated)]
+use generator::{get_yield, yield_with, Gn};
+
+fn sum(a: u32) -> u32 {
+    let mut sum = a;
+    let mut recv: u32;
+    while sum < 200 {
+        recv = get_yield().unwrap();
+        yield_with(sum);
+        sum += recv;
+    }
+
+    sum
+}
+
+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}");
+    }
+}

third-party/vendor/generator/examples/number.rs

@@ -0,0 +1,30 @@
+use generator::*;
+
+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!();
+    })
+}
+
+fn main() {
+    for i in factors(28) {
+        println!("{i}");
+    }
+
+    (0..10000)
+        .filter(|n| factors(*n).sum::<u32>() == *n)
+        .fold((), |_, n| {
+            println!("n = {n}");
+        })
+}

third-party/vendor/generator/examples/pipe.rs

@@ -0,0 +1,29 @@
+use generator::*;
+
+fn main() {
+    // fn square<'a, T: Iterator<Item = u32> + 'a>(input: T) -> impl Iterator<Item = u32> + 'a {
+    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!();
+        })
+    }
+
+    for (i, sum) in sum(square(0..20)).enumerate() {
+        println!("square_sum_{i:<2} = {sum:^4}");
+    }
+}

third-party/vendor/generator/examples/range.rs

@@ -0,0 +1,16 @@
+use generator::{done, Gn};
+
+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}");
+}

third-party/vendor/generator/examples/send.rs

@@ -0,0 +1,33 @@
+#![allow(deprecated)]
+
+use generator::{yield_, Gn};
+use std::mem;
+
+fn sum(a: u32) -> u32 {
+    let mut sum = a;
+    let mut recv: u32;
+    while sum < 200 {
+        // println!("sum={} ", sum);
+        recv = yield_(sum).unwrap();
+        // println!("recv={}", recv);
+        sum += recv;
+    }
+    sum
+}
+
+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}");
+    }
+}

third-party/vendor/generator/examples/yield_from.rs

@@ -0,0 +1,26 @@
+#![allow(deprecated)]
+
+use generator::*;
+
+fn xrange(start: u32, end: u32) -> u32 {
+    for i in start..end {
+        yield_with(i);
+    }
+    done!();
+}
+
+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
+    });
+}