Primes

main.go

package main

import "fmt"

func main() {
	for prime := range primes(100) {
		fmt.Println(prime)
	}
}

func filter(src chan int, prime int) chan int {
	dest := make(chan int)
	go func() {
		defer close(dest)
		for n := range src {
			if n%prime != 0 {
				dest <- n
			}
		}
	}()
	return dest
}

func generate() chan int {
	dest := make(chan int)
	go func() {
		defer close(dest)
		for n := 2; ; n++ {
			dest <- n
		}
	}()
	return dest
}

func primes(n int) chan int {
	src := generate()
	primes := make(chan int)

	go func() {
		defer close(primes)
		for i := 0; i < n; i++ {
			prime := <-src
			primes <- prime
			src = filter(src, prime)
		}
	}()
	return primes
}

main.rs

#![feature(generators, generator_trait)]

use std::{ops::{Generator, GeneratorState}, pin::Pin};

pub fn nth(n: u32) -> u32 {
    let mut seq : Box<dyn Iterator<Item = u32>> = Box::new(2..);
    for _ in 0..n {
        let prime = seq.next().unwrap();
        seq = filter(seq, prime);
    }
    seq.next().unwrap()
}

fn filter(src: Box<dyn Iterator<Item = u32>>, prime: u32) -> Box<dyn Iterator<Item = u32>> {
    Box::new(src.filter(move |n| n % prime != 0))
}

fn main() {
    let mut primes = || {
        let mut seq: Box<dyn Iterator<Item = u32>> = Box::new(2..);
        loop {
            let prime = seq.next().unwrap();
            yield prime;
            seq = filter(seq, prime);
        }
    };
    for _ in 0..10 {
        match Pin::new(&mut primes).resume(()) {
            GeneratorState::Yielded(prime) => {
                println!("{}", prime)
            }
            _ => panic!("unexpected")
        }
    }
}