diff --git a/bower.json b/bower.json
index c957e5a..4e00ed7 100644
--- a/bower.json
+++ b/bower.json
@@ -12,14 +12,14 @@
     "url": "git://github.com/purescript-contrib/purescript-hugenums.git"
   },
   "dependencies": {
-    "purescript-arrays": "^4.0.0",
-    "purescript-globals": "^3.0.0",
-    "purescript-integers": "^3.0.0",
-    "purescript-quickcheck": "^4.0.0",
-    "purescript-generics": "^4.0.0",      
-    "purescript-strings": "^3.0.0"
+    "purescript-arrays": "#compiler/0.12",
+    "purescript-globals": "#compiler/0.12",
+    "purescript-integers": "#compiler/0.12",
+    "purescript-quickcheck": "#compiler/0.12",
+    "purescript-generics-rep": "#compiler/0.12",
+    "purescript-strings": "#compiler/0.12"
   },
   "devDependencies": {
-    "purescript-quickcheck-laws": "^3.0.0"
+    "purescript-quickcheck-laws": "#compiler/0.12"
   }
 }
diff --git a/src/Data/Digit.purs b/src/Data/Digit.purs
index a0c481d..274b8ec 100644
--- a/src/Data/Digit.purs
+++ b/src/Data/Digit.purs
@@ -7,12 +7,12 @@ module Data.Digit
 
 import Prelude
 import Data.Char (toCharCode, fromCharCode)
-import Data.Generic (class Generic)
+import Data.Generic.Rep (class Generic)
 import Data.Maybe (Maybe(..))
 
 newtype Digit = Digit Int
 
-derive instance genericDigit :: Generic Digit
+derive instance genericDigit :: Generic Digit _
 
 instance showDigit :: Show Digit where
   show (Digit n) = "Digit " <> show n
diff --git a/src/Data/HugeInt.purs b/src/Data/HugeInt.purs
index 5734a74..03b1c1a 100644
--- a/src/Data/HugeInt.purs
+++ b/src/Data/HugeInt.purs
@@ -18,17 +18,17 @@ module Data.HugeInt
 
 import Prelude
 
-import Data.String (length, drop, takeWhile)
-import Data.Generic (class Generic)
-import Data.Int (toNumber)
-import Data.Int (round) as Int
-import Data.Maybe (Maybe(..))
+import Data.Generic.Rep (class Generic)
 import Data.HugeNum (HugeNum)
 import Data.HugeNum as HN
+import Data.Int (round) as Int
+import Data.Int (toNumber)
+import Data.Maybe (Maybe(..))
+import Data.String (length, drop, takeWhile)
 
 newtype HugeInt = HugeInt HugeNum
 
-derive instance genericHugeInt :: Generic HugeInt
+derive instance genericHugeInt :: Generic HugeInt _
 
 instance eqHugeInt :: Eq HugeInt where
   eq (HugeInt h1) (HugeInt h2) = h1 == h2
diff --git a/src/Data/HugeNum.purs b/src/Data/HugeNum.purs
index 0f898bb..c0939df 100644
--- a/src/Data/HugeNum.purs
+++ b/src/Data/HugeNum.purs
@@ -22,19 +22,19 @@ module Data.HugeNum
   ) where
 
 import Prelude
-import Data.List as L
-import Control.Monad.Eff.Exception.Unsafe (unsafeThrow)
+
 import Data.Digit (Digit, toInt, fromInt, fromChar, toChar, _zero, _one)
 import Data.Foldable (foldl, all, foldMap)
-import Data.Generic (class Generic)
+import Data.Generic.Rep (class Generic)
 import Data.Int (round, odd, toNumber) as Int
 import Data.List (List(..), (:))
+import Data.List as L
 import Data.Maybe (Maybe(..), fromJust)
-import Data.Monoid (mempty)
 import Data.String (Pattern(..), toCharArray, contains, singleton)
 import Data.Traversable (sequence)
 import Data.Tuple (Tuple(..), fst, snd)
 import Data.Unfoldable (replicate)
+import Effect.Exception.Unsafe (unsafeThrow)
 import Global (readFloat)
 import Partial.Unsafe (unsafePartial)
 import Test.QuickCheck.Arbitrary (class Arbitrary)
@@ -53,8 +53,8 @@ newtype HugeNum = HugeNum { digits :: List Digit, decimal :: Int, sign :: Sign }
 
 -- | ##Instances
 
-derive instance genericSign :: Generic Sign
-derive instance genericHugeNum :: Generic HugeNum
+derive instance genericSign :: Generic Sign _
+derive instance genericHugeNum :: Generic HugeNum _
 
 instance arbHugeNum :: Arbitrary HugeNum where
   arbitrary = do
diff --git a/test/Main.purs b/test/Main.purs
index f86ee4e..58ad4ff 100644
--- a/test/Main.purs
+++ b/test/Main.purs
@@ -1,28 +1,20 @@
 module Test.Main where
 
 import Prelude
+
+import Data.HugeNum (HugeNum)
+import Effect (Effect)
+import Effect.Console (log)
 import Test.QuickCheck.Laws.Data.Eq (checkEq)
 import Test.QuickCheck.Laws.Data.Ord (checkOrd)
-import Test.QuickCheck.Laws.Data.Semiring (checkSemiring)
 import Test.QuickCheck.Laws.Data.Ring (checkRing)
-import Data.HugeNum (HugeNum)
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE, log)
-import Control.Monad.Eff.Exception (EXCEPTION)
-import Control.Monad.Eff.Random (RANDOM)
+import Test.QuickCheck.Laws.Data.Semiring (checkSemiring)
 import Type.Proxy (Proxy(..))
 
 prxHugeNum :: Proxy HugeNum
 prxHugeNum = Proxy
 
-main :: forall eff.
-  Eff
-    ( console :: CONSOLE
-    , random :: RANDOM
-    , exception :: EXCEPTION
-    | eff
-    )
-    Unit
+main :: Effect Unit
 main = do
   log "Checking HugeNum instances...\n"
   checkEq prxHugeNum