Updates for PureScript 0.9

Author: sharkdp

bower.json

@@ -20,12 +20,12 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-maybe": "^0.3.2"
+    "purescript-maybe": "^1.0.0"
   },
   "devDependencies": {
-    "purescript-integers": "^0.2.1",
-    "purescript-console": "^0.1.0",
-    "purescript-assert": "^0.1.1",
-    "purescript-quickcheck": "^0.12.0"
+    "purescript-integers": "^1.0.0",
+    "purescript-console": "^1.0.0",
+    "purescript-assert": "^1.0.0",
+    "purescript-quickcheck": "^1.0.0"
   }
 }

src/Data/BigInt.purs

@@ -90,7 +90,7 @@ instance ordBigInt :: Ord BigInt where
 foreign import toString :: BigInt -> String
 
 instance showBigInt :: Show BigInt where
-  show x = "fromString \"" ++ toString x ++ "\""
+  show x = "fromString \"" <> toString x <> "\""
 
 foreign import biAdd :: BigInt -> BigInt -> BigInt
 foreign import biMul :: BigInt -> BigInt -> BigInt
@@ -109,6 +109,9 @@ instance ringBigInt :: Ring BigInt where
 foreign import biDiv :: BigInt -> BigInt -> BigInt
 foreign import biMod :: BigInt -> BigInt -> BigInt
 
-instance moduloSemiringBigInt :: ModuloSemiring BigInt where
+instance commutativeRingBigInt :: CommutativeRing BigInt
+
+instance euclideanRingBigInt :: EuclideanRing BigInt where
   div = biDiv
   mod = biMod
+  degree = degree <<< toNumber

test/Main.purs

@@ -1,17 +1,20 @@
 module Test.Main where
 
 import Prelude
-import Control.Monad.Eff.Console (log)
+import Control.Monad.Eff (Eff)
+import Control.Monad.Eff.Console (CONSOLE, log)
 import Data.Array (filter, range)
-import Data.BigInt
-import Data.Foldable (mconcat)
-import Data.Maybe (Maybe(..))
-import Data.Maybe.Unsafe (fromJust)
-import Test.Assert (assert)
+import Data.BigInt (BigInt, abs, fromInt, prime, pow, odd, even, fromString,
+                    toNumber, fromBase, toString)
+import Data.Foldable (fold)
+import Data.Maybe (Maybe(..), fromMaybe)
+import Test.Assert (ASSERT, assert)
+import Control.Monad.Eff.Random (RANDOM())
+import Control.Monad.Eff.Exception (EXCEPTION())
 import Test.QuickCheck (QC(), quickCheck)
-import Test.QuickCheck.Arbitrary (Arbitrary)
+import Test.QuickCheck.Arbitrary (class Arbitrary)
 import Test.QuickCheck.Gen (Gen(), chooseInt, arrayOf, elements)
-import qualified Data.Int as Int
+import Data.Int as Int
 
 -- | Newtype with an Arbitrary instance that generates only small integers
 newtype SmallInt = SmallInt Int
@@ -27,13 +30,13 @@ newtype TestBigInt = TestBigInt BigInt
 
 instance arbitraryBigInt :: Arbitrary TestBigInt where
   arbitrary = do
-    n <- (fromJust <<< fromString) <$> digitString
+    n <- (fromMaybe zero <<< fromString) <$> digitString
     op <- elements id [negate]
-    return (TestBigInt (op n))
+    pure (TestBigInt (op n))
     where digits :: Gen Int
           digits = chooseInt 0 9
           digitString :: Gen String
-          digitString = (mconcat <<< map show) <$> arrayOf digits
+          digitString = (fold <<< map show) <$> arrayOf digits
 
 -- | Convert SmallInt to BigInt
 fromSmallInt :: SmallInt -> BigInt
@@ -45,6 +48,7 @@ testBinary :: forall eff. (BigInt -> BigInt -> BigInt)
            -> QC eff Unit
 testBinary f g = quickCheck (\x y -> (fromInt x) `f` (fromInt y) == fromInt (x `g` y))
 
+main :: forall eff. Eff (console :: CONSOLE, assert :: ASSERT, random :: RANDOM, err :: EXCEPTION | eff) Unit
 main = do
   log "Simple arithmetic operations and conversions from Int"
   let two = one + one