egison 3.0.8 → 3.0.9

raw patch · 4 files changed

+35/−14 lines, 4 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• egison.cabal +3/−3
• hs-src/Language/Egison/Primitives.hs +10/−5
• lib/core/collection.egi +9/−0
• lib/core/number.egi +13/−6

@@ -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.

@@ -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' ->

@@ -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)

@@ -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)}))