diff --git a/egison.cabal b/egison.cabal
--- a/egison.cabal
+++ b/egison.cabal
@@ -1,9 +1,9 @@
 Name:                egison
-Version:             3.0.8
-Synopsis:            An Interpreter for the Programming Language Egison
+Version:             3.0.9
+Synopsis:            An Interpreter for Egison, the world-first programming langugage which realized non-linear pattern-matching with unfree data types
 Description:         An interpreter for the programming language Egison.
                      A feature of Egison is the strong pattern match facility.
-                     With Egison, you can represent pattern matching for unfree data intuitively,
+                     With Egison, you can represent pattern-matching for unfree data intuitively,
                      especially for collection data, such as lists, multisets, sets, and so on.
                      This package include sample Egison programs "*-test.egi" in "sample/" directory.
                      This package also include Emacs Lisp file "egison-mode.el" in "elisp/" directory.
diff --git a/hs-src/Language/Egison/Primitives.hs b/hs-src/Language/Egison/Primitives.hs
--- a/hs-src/Language/Egison/Primitives.hs
+++ b/hs-src/Language/Egison/Primitives.hs
@@ -73,11 +73,11 @@
              , ("modulo",    integerBinaryOp mod)
              , ("quotient",   integerBinaryOp quot)
              , ("remainder", integerBinaryOp rem)
-             , ("eq-n?",  integerBinaryPred (==))
-             , ("lt-n?",  integerBinaryPred (<))
-             , ("lte-n?", integerBinaryPred (<=))
-             , ("gt-n?",  integerBinaryPred (>))
-             , ("gte-n?", integerBinaryPred (>=))
+             , ("eq-i?",  integerBinaryPred (==))
+             , ("lt-i?",  integerBinaryPred (<))
+             , ("lte-i?", integerBinaryPred (<=))
+             , ("gt-i?",  integerBinaryPred (>))
+             , ("gte-i?", integerBinaryPred (>=))
              , ("+f", floatBinaryOp (+))
              , ("-f", floatBinaryOp (-))
              , ("*f", floatBinaryOp (*))
@@ -108,6 +108,7 @@
              , ("floor",    floatToIntegerOp floor)
              , ("ceiling",  floatToIntegerOp ceiling)
              , ("truncate", floatToIntegerOp truncate)
+             , ("itof", integerToFloat)
              , ("eq?",  eq)
              , ("lt?",  lt)
              , ("lte?", lte)
@@ -148,6 +149,10 @@
 floatToIntegerOp :: (Double -> Integer) -> PrimitiveFunc
 floatToIntegerOp op = (liftError .) $ oneArg $ \val ->
   Integer . op <$> fromFloatValue val
+
+integerToFloat :: PrimitiveFunc
+integerToFloat = (liftError .) $ oneArg $ \val ->
+  Float . fromInteger <$> fromIntegerValue val
 
 eq :: PrimitiveFunc
 eq = (liftError .) $ twoArgs $ \val val' ->
diff --git a/lib/core/collection.egi b/lib/core/collection.egi
--- a/lib/core/collection.egi
+++ b/lib/core/collection.egi
@@ -206,6 +206,15 @@
           {[<cons $x $xs> {x @(take (- n 1) xs)}]
            [<nil> {}]}))))
 
+(define $while
+  (lambda [$pred $xs]
+    (match xs (list something)
+      {[<nil> {}]
+       [<cons $x $rs>
+        (if (pred x)
+            {x @(while pred rs)}
+            {})]})))
+
 (define $drop
   (lambda [$n $xs]
     (if (eq? n 0)
diff --git a/lib/core/number.egi b/lib/core/number.egi
--- a/lib/core/number.egi
+++ b/lib/core/number.egi
@@ -116,7 +116,6 @@
                          }))]}
       (fib1 n 1 1))))
 
-
 (define $fact
   (lambda [$n]
     (letrec {[$fact1 (lambda [$n $ret]
@@ -136,10 +135,18 @@
         {[$tgt {(modulo tgt m)}]}]
        })))
 
+(define $nats {1 @(map (+ 1 $) nats)})
+
 (define $primes
   (letrec {[$next-primes
-            (lambda [$primes1 $n]
-              (if (one-of (lambda [$p] (eq-n? (remainder n p) 0)) primes1)
-                  (next-primes primes1 (+ n 1))
-                  {n @(next-primes {@primes1 n} (+ n 1))}))]}
-    {2 @(next-primes {2} 3)}))
+            (lambda [$primes1 $k]
+              (let {[$primes2 (while (lte? $ (floor (sqrt (itof (* 6 (+ k 1)))))) primes1)]}
+                (match [(one-of (lambda [$p] (eq? (remainder (+ (* 6 k) 1) p) 0)) primes2)
+                        (one-of (lambda [$p] (eq? (remainder (+ (* 6 k) 5) p) 0)) primes2)]
+                  [bool bool]
+                  {[[,#f ,#f] {(+ (* 6 k) 1) (+ (* 6 k) 5) @(next-primes {@primes1 (+ (* 6 k) 1) (+ (* 6 k) 5)} (+ k 1))}]
+                   [[,#f ,#t] {(+ (* 6 k) 1) @(next-primes {@primes1 (+ (* 6 k) 1)} (+ k 1))}]
+                   [[,#t ,#f] {(+ (* 6 k) 5) @(next-primes {@primes1 (+ (* 6 k) 5)} (+ k 1))}]
+                   [[,#t ,#t] (next-primes primes1 (+ k 1))]
+                   })))]}
+    {2 3 5 @(next-primes {2 3 5} 1)}))