One-liners -- http://www.haskell.org/haskellwiki/Prime_numbers_miscellaneous

gistfile1.hs

== One-liners ==

primes = [n | n<-[2..], not $ elem n [j*k | j<-[2..n-1], k<-[2..n-1]]]
primes = [n | n<-[2..], not $ elem n [j*k | j<-[2..n-1], k<-[2..min j (n`div`j)]]]

primes = nubBy (((==0).).rem) [2..]
primes = [n | n<-[2..], all ((> 0).rem n) [2..n-1]]
primes = 2 : [n | n<-[3,5..], all ((> 0).rem n) [3,5..floor.sqrt$fromIntegral n]]

primes = 2 : [n | n<-[3..], all ((> 0).rem n) $ takeWhile ((<= n).(^2)) primes]
primes = 2 : 3 : [n | n<-[5,7..],
                      foldr (\p r-> p*p>n || (rem n p>0 && r)) True $ tail primes]
primes = 2 : fix (\xs-> 3 : [n | n<-[5,7..],
                      foldr (\p r-> p*p>n || (rem n p>0 && r)) True xs])

primes = map head $ iterate (\(x:xs)-> filter ((> 0).(`rem`x)) xs) [2..]
primes = 2 : unfoldr (\(x:xs)-> Just(x, filter ((> 0).(`rem`x)) xs)) [3,5..]

primesTo n = foldl (\r x-> r `minus` [x*x, x*x+2*x..]) (2:[3,5..n]) 
                                [3,5..floor.sqrt$fromIntegral n]
primesTo n = 2 : foldr (\r z-> if (head r^2) <= n then head r : z else r) []  
                   (fix $ \rs-> [3,5..n] : [t `minus` [p*p, p*p+2*p..] | (p:t)<- rs])

primes = 2 : concat (unfoldr (\(xs,p:ps)-> let (h,t)=span (< p*p) xs in 
                  Just (h, (filter ((> 0).(`rem`p)) t, ps))) ([3,5..],[3,5..]))
primes = 2 : 3 : concat (unfoldr (\(xs,p:ps)-> let (h,t)=span (< p*p) xs in 
                      Just (h, (t `minus` [p*p, p*p+2*p..], ps))) ([5,7..],tail primes))

primes = concatMap snd $ iterate (\((n, p:t@(q:_)),_) -> ((n+1,t),
           [x | let lst = take n $ tail primes, x <- [p*p+2, p*p+4 .. q*q-2],
                all ((/= 0).rem x) $ lst]))  ((1, tail primes), [2,3,5,7]) 

primes = concatMap snd $ iterate (\((n, p2:t@(q2:_)),_) -> ((n+1,t), 
             minus [p2+2, p2+4 .. q2-2] $ foldi union [] [ [o, o+2*i .. q2-2] |
                     i <- take n $ tail primes, let o=p2-rem (p2-i) (2*i)+2*i] ))
           ((1, map (^2) $ tail primes), [2,3,5,7])  


primes = let { sieve (x:xs) = x : sieve [n | n <- xs, rem n x > 0] } in sieve [2..]
 
primes = let { sieve xs (p:ps) | (h,t)<-span (< p*p) xs =
                             h ++ sieve (filter ((> 0).(`rem` p)) t) ps } 
           in 2 : 3 : sieve [5,7..] (tail primes)

primes = let { sieve xs (p:ps) | (h,t)<-span (< p*p) xs = 
                             h ++ sieve (t `minus` [p*p, p*p+2*p..]) ps } 
           in 2 : 3 : sieve [5,7..] (tail primes)

------------------------------------------------------------------------
primes = let { sieve x (p:ps) cs | (h,t)<-span (< p*p) cs = minus [x,x+2..p*p-2] h
                               ++ sieve (p*p) ps (union t [p*p, p*p+2*p..]) }
           in 2 : 3 : sieve 5 (tail primes) []

primes = let { sieve x (p:ps) is = minus [x,x+2..p*p-2] (foldi union [] 
                 [[o, o+2*i..p*p-2] | i <- reverse is, -- let o=x-rem (x-i) (2*i) ])
                             -- let r=rem(x-i)(2*i);o=if r==0 then x else x-r+2*i ])
                                      let o = ((x+i-1)`div`(2*i))*2*i + i  ])
                               ++ sieve (p*p) ps (p:is) } 
           in 2 : 3 : sieve 5 (tail primes) []
------------------------------------------------------------------------

------------------------------------------------------------------------
primes = let { sieve x (p:ps) cs | (h,t)<-span (< p*p) cs = minus [x+2,x+4..p*p-2] h
                               ++ sieve (p*p) ps (union t [p*p+2*p, p*p+4*p..]) }
           in 2 : 3 : sieve 3 (tail primes) []

primes = let { sieve x (p:ps) is = minus [x+2,x+4..p*p-2] (foldi union [] 
                 [[o, o+2*i..p*p-2] | i <- reverse is, let o=x-rem (x-i) (2*i)+2*i ])
                               ++ sieve (p*p) ps (p:is) } 
           in 2 : 3 : sieve 3 (tail primes) []
------------------------------------------------------------------------


primes = 2 : minus [3..] (foldr (\(x:xs)->(x:).union xs) [] 
                              $ map (\x->[x*x, x*x+x..]) primes)
primes = 2 : minus [3,5..] (foldi (\(x:xs)->(x:).union xs) [] 
                              $ map (\x->[x*x, x*x+2*x..]) [3,5..])
primes = 2 : _Y ( (3:) . gaps 5          -- unbounded Sieve of Eratosthenes
                          . foldi (\(x:xs) ys-> x:union xs ys) [] 
                              . map (\p->[p*p, p*p+2*p..]) )
_Y g = g (_Y g)

gaps x s@(c:cs) | x < c = x : gaps (x+2) s    -- == minus [x,x+2..] s
                | otherwise = gaps (x+2) cs   --       , when x <= c