diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-Generic random generators
+Generic random generators [![Hackage](https://img.shields.io/hackage/v/generic-random.svg)](https://hackage.haskell.org/package/generic-random) [![Build Status](https://travis-ci.org/Lysxia/generic-random.svg)](https://travis-ci.org/Lysxia/generic-random)
 =========================
 
 Define sized random generators for almost any type.
diff --git a/generic-random.cabal b/generic-random.cabal
--- a/generic-random.cabal
+++ b/generic-random.cabal
@@ -1,5 +1,5 @@
 name:                generic-random
-version:             0.1.0.0
+version:             0.1.1.0
 synopsis:            Generic random generators
 description:         Please see the README below.
 homepage:            http://github.com/lysxia/generic-random
@@ -12,6 +12,7 @@
 build-type:          Simple
 extra-source-files:  README.md
 cabal-version:       >=1.10
+tested-with:         GHC == 7.10.3
 
 library
   hs-source-dirs:      src
@@ -62,4 +63,4 @@
 
 source-repository head
   type:     git
-  location: https://github.com/lyxia/generic-random
+  location: https://github.com/lysxia/generic-random
diff --git a/src/Data/Random/Generics/Internal/Oracle.hs b/src/Data/Random/Generics/Internal/Oracle.hs
--- a/src/Data/Random/Generics/Internal/Oracle.hs
+++ b/src/Data/Random/Generics/Internal/Oracle.hs
@@ -18,7 +18,6 @@
 import qualified Data.Vector as V
 import qualified Data.Vector.Storable as S
 import GHC.Generics ( Generic )
-import GHC.Stack ( CallStack, showCallStack )
 import Numeric.AD
 import Data.Random.Generics.Internal.Types
 import Data.Random.Generics.Internal.Solver
@@ -363,6 +362,7 @@
     -- Equations defining C_i(x) for all types with indices i
     phis :: Num a => V.Vector (a -> V.Vector a -> a)
     phis = V.fromList [ phi dd c (types #! c) | c <- listCs dd ]
+    eval' :: Double -> Maybe (S.Vector Double)
     eval' x = fixedPoint defSolveArgs phi' (S.replicate m 0)
       where
         phi' :: (Mode a, Scalar a ~ Double) => V.Vector a -> V.Vector a
@@ -510,11 +510,9 @@
     select _ _ = (snd . head) as
     -- That should not happen in theory, but floating point might be funny.
 
-(#!) :: (?loc :: CallStack, Eq k, Hashable k)
+(#!) :: (Eq k, Hashable k)
   => HashMap k v -> k -> v
-h #! k = HashMap.lookupDefault (e ?loc) k h
-  where
-    e loc = error ("HashMap.(!): key not found\n" ++ showCallStack loc)
+(#!) = (HashMap.!)
 
 -- | @partitions k n@: lists of non-negative integers of length @n@ with sum
 -- less than or equal to @k@.
diff --git a/src/Data/Random/Generics/Internal/Types.hs b/src/Data/Random/Generics/Internal/Types.hs
--- a/src/Data/Random/Generics/Internal/Types.hs
+++ b/src/Data/Random/Generics/Internal/Types.hs
@@ -7,7 +7,6 @@
 import Data.Coerce
 import Data.Data
 import Data.Function
-import GHC.Stack ( CallStack, showCallStack )
 import Test.QuickCheck
 
 data SomeData m where
@@ -46,36 +45,35 @@
 
 -- | > composeCast f g = f . g
 composeCastM :: forall a b c d m
-  . (?loc :: CallStack, Typeable b, Typeable c)
+  . (Typeable b, Typeable c)
   => (m c -> d) -> (a -> m b) -> (a -> d)
 composeCastM f g | Just Refl <- eqT :: Maybe (b :~: c) = f . g
 composeCastM _ _ = castError ([] :: [b]) ([] :: [c])
 
 castM :: forall a b m
-  . (?loc :: CallStack, Typeable a, Typeable b)
+  . (Typeable a, Typeable b)
   => m a -> m b
 castM a | Just Refl <- eqT :: Maybe (a :~: b) = a
 castM a = let x = castError a x in x
 
-unSomeData :: (?loc :: CallStack, Typeable a) => SomeData m -> m a
+unSomeData :: Typeable a => SomeData m -> m a
 unSomeData (SomeData a) = castM a
 
 applyCast :: (Typeable a, Data b) => (m a -> m b) -> SomeData m -> SomeData m
 applyCast f = SomeData . f . unSomeData
 
-castError :: (?loc :: CallStack, Typeable a, Typeable b)
+castError :: (Typeable a, Typeable b)
   => proxy a -> proxy' b -> c
 castError a b = error $ unlines
   [ "Error trying to cast"
   , "  " ++ show (typeRep a)
   , "to"
   , "  " ++ show (typeRep b)
-  , showCallStack ?loc
   ]
 
-withProxy :: (?loc :: CallStack) => (a -> b) -> proxy a -> b
+withProxy :: (a -> b) -> proxy a -> b
 withProxy f _ =
-  f (error $ "This should not be evaluated\n" ++ showCallStack ?loc)
+  f (error "This should not be evaluated\n")
 
 reproxy :: proxy a -> Proxy a
 reproxy _ = Proxy