Sieve of Eratosthenes

sieve-core-async.clj

(defn prime-filter [in out prime]
  (go
   (loop [i (<! in)]
     (when-not (zero? (mod i prime))
       (>! out i))
     (recur (<! in)))))

(let [ch (chan)]
  (go (loop [i 2] (>! ch i) (recur (inc i))))

  (loop [ch ch, i 100]
    (when (pos? i)
      (let [prime (<!! ch)
            next (chan)]
        (println prime)
        (prime-filter ch next prime)
        (recur next (dec i))))))

sieve.clj

(defn sieve-seq [[fst & rst]] 
  (lazy-seq 
    (cons fst (sieve-seq (remove #(zero? (mod % fst)) rst)))))

(def primes (sieve-seq (iterate inc 2)))

(take 100 primes)

sieve.scala

def sieve(s: Stream[Int]): Stream[Int] = {
  s.head #:: sieve(s.tail.filter(_ % s.head != 0))
}

val primes = sieve(Stream.from(2))

primes.take(100).toList