diff --git a/.travis.yml b/.travis.yml
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,4 +1,63 @@
-language: haskell
+# NB: don't set `language: haskell` here
+
+# See also https://github.com/hvr/multi-ghc-travis for more information
+env:
+ - GHCVER=7.0.4 CABALVER=1.16
+ # we have to use CABALVER=1.16 for GHC<7.6 as well, as there's
+ # no package for earlier cabal versions in the PPA
+ - GHCVER=7.4.2 CABALVER=1.16
+ - GHCVER=7.6.3 CABALVER=1.16 OPTS="--constraint=hashable>=1.2"
+ - GHCVER=7.6.3 CABALVER=1.16 OPTS="--constraint=hashable<1.2"
+ - GHCVER=7.6.3 CABALVER=1.16 OPTS=-f-hashable
+ - GHCVER=7.8.3 CABALVER=1.18 OPTS="--constraint=hashable>=1.2"
+ - GHCVER=7.8.3 CABALVER=1.18 OPTS="--constraint=hashable<1.2"
+ - GHCVER=7.8.3 CABALVER=1.18 OPTS=-f-hashable
+ # NOTE: we can't use Cabal 1.20 yet due to
+ #  https://github.com/haskell/cabal/issues/1806
+ - GHCVER=head  CABALVER=head
+
+matrix:
+  allow_failures:
+   - env: GHCVER=head  CABALVER=head
+
+# Note: the distinction between `before_install` and `install` is not
+#       important.
+before_install:
+ - travis_retry sudo add-apt-repository -y ppa:hvr/ghc
+ - travis_retry sudo apt-get update
+ - travis_retry sudo apt-get install cabal-install-$CABALVER ghc-$GHCVER
+ - export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH
+ - cabal --version
+ - echo "$(ghc --version) [$(ghc --print-project-git-commit-id 2> /dev/null || echo '?')]"
+
+install:
+ - travis_retry cabal update
+ - cabal install --only-dependencies
+
+# Here starts the actual work to be performed for the package under
+# test; any command which exits with a non-zero exit code causes the
+# build to fail.
+script:
+ # -v2 provides useful information for debugging
+ - cabal configure -v2 $OPTS
+
+ # this builds all libraries and executables
+ # (including tests/benchmarks)
+ - cabal build
+
+ # tests that a source-distribution can be generated
+ - cabal sdist
+
+ # check that the generated source-distribution can be built & installed
+ - export SRC_TGZ=$(cabal info . | awk '{print $2 ".tar.gz";exit}') ;
+   cd dist/;
+   if [ -f "$SRC_TGZ" ]; then
+      cabal install --force-reinstalls "$SRC_TGZ";
+   else
+      echo "expected '$SRC_TGZ' not found";
+      exit 1;
+   fi
+
 notifications:
   irc:
     channels:
diff --git a/CHANGELOG.markdown b/CHANGELOG.markdown
--- a/CHANGELOG.markdown
+++ b/CHANGELOG.markdown
@@ -1,3 +1,11 @@
+1.0
+---
+* Make `nats` a compat-package since `Numeric.Natural` moved to `base-4.8.0.0`.
+
+0.2.1
+-----
+* Better `readsPrec` handling when you try to feed it a negative number. Not it is a failed parse rather than an error.
+
 0.2
 ---
 * Added `Hashable` and `Data` support.
diff --git a/README.markdown b/README.markdown
--- a/README.markdown
+++ b/README.markdown
@@ -1,7 +1,8 @@
 nats
 ====
 
-[![Build Status](https://secure.travis-ci.org/ekmett/nats.png?branch=master)](http://travis-ci.org/ekmett/nats)
+[![Hackage](https://img.shields.io/hackage/v/nats.svg)](https://hackage.haskell.org/package/nats)
+[![Build Status](https://secure.travis-ci.org/ekmett/nats.svg?branch=master)](http://travis-ci.org/ekmett/nats)
 
 Haskell 98 natural numbers
 
diff --git a/nats.cabal b/nats.cabal
--- a/nats.cabal
+++ b/nats.cabal
@@ -1,6 +1,6 @@
 name:          nats
 category:      Numeric, Algebra
-version:       0.2
+version:       1
 license:       BSD3
 cabal-version: >= 1.10
 license-file:  LICENSE
@@ -31,20 +31,21 @@
     .
     Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users.
     .
-    If set we will not supply an instance of `Hashable`
+    If disabled we will not supply an instance of `Hashable`
   default: True
   manual: True
 
 library
   default-language: Haskell98
-  hs-source-dirs: src
-  ghc-options: -Wall
-
-  exposed-modules:
-    Numeric.Natural
-    Numeric.Natural.Internal
-
-  build-depends: base >= 2 && < 10
+  if impl(ghc<7)
+    -- {-# LANGUAGE DeriveDataTypeable #-} is only understood starting w/ GHC-7.0
+    default-extensions: DeriveDataTypeable
 
-  if flag(hashable)
-    build-depends: hashable >= 1.1 && < 1.3
+  if !impl(ghc>=7.9)
+    -- Starting with GHC 7.10/base-4.8, "Numeric.Natural" lives in `base`
+    hs-source-dirs: src
+    exposed-modules: Numeric.Natural
+    ghc-options: -Wall
+    build-depends: base >= 2 && < 4.8
+    if flag(hashable)
+      build-depends: hashable >= 1.1 && < 1.3
diff --git a/src/Numeric/Natural.hs b/src/Numeric/Natural.hs
--- a/src/Numeric/Natural.hs
+++ b/src/Numeric/Natural.hs
@@ -1,7 +1,26 @@
+{-# LANGUAGE CPP #-}
+
+#ifdef __GLASGOW_HASKELL__
+#define LANGUAGE_DeriveDataTypeable
+{-# LANGUAGE DeriveDataTypeable #-}
+#endif
+
+#ifndef MIN_VERSION_base
+#define MIN_VERSION_base(x,y,z) 1
+#endif
+
+#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702
+#ifdef MIN_VERSION_hashable
+{-# LANGUAGE Trustworthy #-}
+#else
+{-# LANGUAGE Safe #-}
+#endif
+#endif
+
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Numeric.Natural
--- Copyright   :  (C) 2011 Edward Kmett,
+-- Copyright   :  (C) 2011-2014 Edward Kmett,
 -- License     :  BSD-style (see the file LICENSE)
 --
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
@@ -10,11 +29,180 @@
 --
 -- Natural numbers.
 --
+-- The "Numeric.Natural" module has become part of `base` starting
+-- with `base-4.8.0.0`.
 ----------------------------------------------------------------------------
-module Numeric.Natural
-  ( Natural
-  , Whole(toNatural)
-  , natural
-  ) where
+module Numeric.Natural ( Natural ) where
 
-import Numeric.Natural.Internal
+import Control.Exception ( throw, ArithException(Underflow) )
+import Data.Bits
+import Data.Ix
+#ifdef LANGUAGE_DeriveDataTypeable
+import Data.Data
+#endif
+#ifdef MIN_VERSION_hashable
+import Data.Hashable
+#endif
+
+-- | Type representing arbitrary-precision non-negative integers.
+--
+-- Operations whose result would be negative
+-- @'throw' ('Underflow' :: 'ArithException')@.
+--
+-- The 'Natural' type has become part of `base` starting with
+-- `base-4.8.0.0`.
+newtype Natural = Natural { runNatural :: Integer } deriving
+  ( Eq
+  , Ord
+  , Ix
+#ifdef LANGUAGE_DeriveDataTypeable
+  , Typeable
+#endif
+  )
+
+#ifdef MIN_VERSION_hashable
+instance Hashable Natural where
+#if MIN_VERSION_hashable(1,2,0)
+  hashWithSalt p (Natural a) = hashWithSalt p a
+#else
+  hash (Natural a) = hash a
+#endif
+#endif
+
+#ifdef LANGUAGE_DeriveDataTypeable
+-- This follows the same style as the other integral 'Data' instances
+-- defined in "Data.Data"
+naturalType :: DataType
+naturalType = mkIntType "Numeric.Natural.Natural"
+
+instance Data Natural where
+  toConstr x = mkIntegralConstr naturalType x
+  gunfold _ z c = case constrRep c of
+                    (IntConstr x) -> z (fromIntegral x)
+                    _ -> error $ "Data.Data.gunfold: Constructor " ++ show c
+                                 ++ " is not of type Natural"
+  dataTypeOf _ = naturalType
+#endif
+
+instance Show Natural where
+  showsPrec d (Natural n) = showsPrec d n
+
+instance Read Natural where
+  readsPrec d = map (\(n, s) -> (Natural n, s)) . filter ((>= 0) . fst) . readsPrec d
+
+instance Num Natural where
+  Natural n + Natural m = Natural (n + m)
+  {-# INLINE (+) #-}
+  Natural n * Natural m = Natural (n * m)
+  {-# INLINE (*) #-}
+  Natural n - Natural m | result < 0 = throw Underflow
+                        | otherwise  = Natural result
+    where result = n - m
+  {-# INLINE (-) #-}
+  abs (Natural n) = Natural n
+  {-# INLINE abs #-}
+  signum (Natural n) = Natural (signum n)
+  {-# INLINE signum #-}
+  fromInteger n
+    | n >= 0 = Natural n
+    | otherwise = throw Underflow
+  {-# INLINE fromInteger #-}
+
+instance Bits Natural where
+  Natural n .&. Natural m = Natural (n .&. m)
+  {-# INLINE (.&.) #-}
+  Natural n .|. Natural m = Natural (n .|. m)
+  {-# INLINE (.|.) #-}
+  xor (Natural n) (Natural m) = Natural (xor n m)
+  {-# INLINE xor #-}
+  complement _ = error "Bits.complement: Natural complement undefined"
+  {-# INLINE complement #-}
+  shift (Natural n) = Natural . shift n
+  {-# INLINE shift #-}
+  rotate (Natural n) = Natural . rotate n
+  {-# INLINE rotate #-}
+  bit = Natural . bit
+  {-# INLINE bit #-}
+  setBit (Natural n) = Natural . setBit n
+  {-# INLINE setBit #-}
+  clearBit (Natural n) = Natural . clearBit n
+  {-# INLINE clearBit #-}
+  complementBit (Natural n) = Natural . complementBit n
+  {-# INLINE complementBit #-}
+  testBit = testBit . runNatural
+  {-# INLINE testBit #-}
+#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 707
+  bitSizeMaybe _ = Nothing
+  {-# INLINE bitSizeMaybe #-}
+#endif
+  bitSize = error "Natural: bitSize"
+  {-# INLINE bitSize #-}
+  isSigned _ = False
+  {-# INLINE isSigned #-}
+  shiftL (Natural n) = Natural . shiftL n
+  {-# INLINE shiftL #-}
+  shiftR (Natural n) = Natural . shiftR n
+  {-# INLINE shiftR #-}
+  rotateL (Natural n) = Natural . rotateL n
+  {-# INLINE rotateL #-}
+  rotateR (Natural n) = Natural . rotateR n
+  {-# INLINE rotateR #-}
+#if MIN_VERSION_base(4,6,0)
+  popCount = popCountDefault
+  {-# INLINE popCount #-}
+#endif
+
+instance Real Natural where
+  toRational (Natural a) = toRational a
+  {-# INLINE toRational #-}
+
+instance Enum Natural where
+  pred (Natural 0) = throw Underflow
+  pred (Natural n) = Natural (pred n)
+  {-# INLINE pred #-}
+  succ (Natural n) = Natural (succ n)
+  {-# INLINE succ #-}
+  fromEnum (Natural n) = fromEnum n
+  {-# INLINE fromEnum #-}
+  toEnum n | n < 0     = error "Natural.toEnum: negative"
+           | otherwise = Natural (toEnum n)
+  {-# INLINE toEnum #-}
+
+  enumFrom = map Natural . enumFrom . runNatural
+
+  enumFromThen x y
+    | x <= y    = map Natural (enumFromThen   (runNatural x) (runNatural y))
+    | otherwise = map Natural (enumFromThenTo (runNatural x) (runNatural y) 0)
+
+  enumFromTo x y = map Natural (enumFromTo (runNatural x) (runNatural y))
+
+  enumFromThenTo x x1 y
+    = map Natural (enumFromThenTo (runNatural x) (runNatural x1) (runNatural y))
+
+{- NOTE: Using "Data.Coerce", we could instead say:
+
+  enumFrom      = coerce (enumFrom     :: Integer -> [Integer])
+  enumFromThen x y
+    | x <= y    = coerce (enumFromThen :: Integer -> Integer -> [Integer]) x y
+    | otherwise = enumFromThenTo x y 0
+
+  enumFromTo    = coerce (enumFromTo   :: Integer -> Integer -> [Integer])
+  enumFromThenTo
+    = coerce (enumFromThenTo :: Integer -> Integer -> Integer -> [Integer])
+-}
+
+instance Integral Natural where
+  quot (Natural a) (Natural b) = Natural (quot a b)
+  {-# INLINE quot #-}
+  rem (Natural a) (Natural b) = Natural (rem a b)
+  {-# INLINE rem #-}
+  div (Natural a) (Natural b) = Natural (div a b)
+  {-# INLINE div #-}
+  mod (Natural a) (Natural b) = Natural (mod a b)
+  {-# INLINE mod #-}
+  divMod (Natural a) (Natural b) = (Natural q, Natural r) where (q,r) = divMod a b
+  {-# INLINE divMod #-}
+  quotRem (Natural a) (Natural b) = (Natural q, Natural r) where (q,r) = quotRem a b
+  {-# INLINE quotRem #-}
+  toInteger = runNatural
+  {-# INLINE toInteger #-}
diff --git a/src/Numeric/Natural/Internal.hs b/src/Numeric/Natural/Internal.hs
deleted file mode 100644
--- a/src/Numeric/Natural/Internal.hs
+++ /dev/null
@@ -1,229 +0,0 @@
-{-# LANGUAGE CPP #-}
-
-#ifdef __GLASGOW_HASKELL__
-#define LANGUAGE_DeriveDataTypeable
-{-# LANGUAGE DeriveDataTypeable #-}
-#endif
-
-#ifndef MIN_VERSION_base
-#define MIN_VERSION_base(x,y,z) 1
-#endif
-
-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702
-#ifdef MIN_VERSION_hashable
-{-# LANGUAGE Trustworthy #-}
-#else
-{-# LANGUAGE Safe #-}
-#endif
-#endif
-
------------------------------------------------------------------------------
--- |
--- Module      :  Numeric.Natural.Internal
--- Copyright   :  (C) 2011-2014 Edward Kmett,
--- License     :  BSD-style (see the file LICENSE)
---
--- Maintainer  :  Edward Kmett <ekmett@gmail.com>
--- Stability   :  provisional
--- Portability :  portable
---
--- This module exposes the potentially unsafe operations that are sometimes
--- needed for efficiency: The Natural data constructor and unsafePred.
---
-----------------------------------------------------------------------------
-module Numeric.Natural.Internal
-  ( Natural(..)
-  , Whole(..)
-  , natural
-  ) where
-
-import Data.Word
-import Data.Bits
-import Data.Ix
-#ifdef LANGUAGE_DeriveDataTypeable
-import Data.Data
-#endif
-#ifdef MIN_VERSION_hashable
-import Data.Hashable
-#endif
-
-newtype Natural = Natural { runNatural :: Integer } deriving
-  ( Eq
-  , Ord
-  , Ix
-#ifdef LANGUAGE_DeriveDataTypeable
-  , Typeable
-#endif
-  )
-
-#ifdef MIN_VERSION_hashable
-instance Hashable Natural where
-#if MIN_VERSION_hashable(1,2,0)
-  hashWithSalt p (Natural a) = hashWithSalt p a
-#else
-  hash (Natural a) = hash a
-#endif
-#endif
-
-#ifdef LANGUAGE_DeriveDataTypeable
-instance Data Natural where
-  gfoldl f z (Natural n) = z fromInteger `f` n
-  gunfold k z c = case constrIndex c of
-    1 -> k (z fromInteger)
-    _ -> error "Natural: gunfold: bad constructor"
-  toConstr _     = fromIntegerConstr
-  dataTypeOf _   = naturalDataType
-
-fromIntegerConstr :: Constr
-fromIntegerConstr = mkConstr naturalDataType "fromInteger" [] Prefix
-
-naturalDataType :: DataType
-naturalDataType = mkDataType "Numeric.Natural.Internal.Natural" [fromIntegerConstr]
-#endif
-
--- | Church decoding
-natural :: a -> (a -> a) -> Natural -> a
-natural a _ 0 = a
-natural a f n = natural (f a) f (unsafePred n)
-{-# INLINEABLE natural #-}
-
-instance Show Natural where
-  showsPrec d (Natural n) = showsPrec d n
-
-instance Read Natural where
-  readsPrec d = map (\(n, s) -> (Natural n, s)) . readsPrec d
-
-instance Num Natural where
-  Natural n + Natural m = Natural (n + m)
-  {-# INLINE (+) #-}
-  Natural n * Natural m = Natural (n * m)
-  {-# INLINE (*) #-}
-  Natural n - Natural m | result < 0 = error "Natural.(-): negative result"
-                        | otherwise  = Natural result
-    where result = n - m
-  {-# INLINE (-) #-}
-  abs (Natural n) = Natural n
-  {-# INLINE abs #-}
-  signum (Natural n) = Natural (signum n)
-  {-# INLINE signum #-}
-  fromInteger n
-    | n >= 0 = Natural n
-    | otherwise = error "Natural.fromInteger: negative"
-  {-# INLINE fromInteger #-}
-
-instance Bits Natural where
-  Natural n .&. Natural m = Natural (n .&. m)
-  {-# INLINE (.&.) #-}
-  Natural n .|. Natural m = Natural (n .|. m)
-  {-# INLINE (.|.) #-}
-  xor (Natural n) (Natural m) = Natural (xor n m)
-  {-# INLINE xor #-}
-  complement _ = error "Bits.complement: Natural complement undefined"
-  {-# INLINE complement #-}
-  shift (Natural n) = Natural . shift n
-  {-# INLINE shift #-}
-  rotate (Natural n) = Natural . rotate n
-  {-# INLINE rotate #-}
-  bit = Natural . bit
-  {-# INLINE bit #-}
-  setBit (Natural n) = Natural . setBit n
-  {-# INLINE setBit #-}
-  clearBit (Natural n) = Natural . clearBit n
-  {-# INLINE clearBit #-}
-  complementBit (Natural n) = Natural . complementBit n
-  {-# INLINE complementBit #-}
-  testBit = testBit . runNatural
-  {-# INLINE testBit #-}
-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 707
-  bitSizeMaybe _ = Nothing
-  {-# INLINE bitSizeMaybe #-}
-#endif
-  bitSize = error "Natural: bitSize"
-  {-# INLINE bitSize #-}
-  isSigned _ = False
-  {-# INLINE isSigned #-}
-  shiftL (Natural n) = Natural . shiftL n
-  {-# INLINE shiftL #-}
-  shiftR (Natural n) = Natural . shiftR n
-  {-# INLINE shiftR #-}
-  rotateL (Natural n) = Natural . rotateL n
-  {-# INLINE rotateL #-}
-  rotateR (Natural n) = Natural . rotateR n
-  {-# INLINE rotateR #-}
-#if MIN_VERSION_base(4,6,0)
-  popCount = popCountDefault
-  {-# INLINE popCount #-}
-#endif
-
-instance Real Natural where
-  toRational (Natural a) = toRational a
-  {-# INLINE toRational #-}
-
-instance Enum Natural where
-  pred (Natural 0) = error "Natural.pred: 0"
-  pred (Natural n) = Natural (pred n)
-  {-# INLINE pred #-}
-  succ (Natural n) = Natural (succ n)
-  {-# INLINE succ #-}
-  fromEnum (Natural n) = fromEnum n
-  {-# INLINE fromEnum #-}
-  toEnum n | n < 0     = error "Natural.toEnum: negative"
-           | otherwise = Natural (toEnum n)
-  {-# INLINE toEnum #-}
-
-instance Integral Natural where
-  quot (Natural a) (Natural b) = Natural (quot a b)
-  {-# INLINE quot #-}
-  rem (Natural a) (Natural b) = Natural (rem a b)
-  {-# INLINE rem #-}
-  div (Natural a) (Natural b) = Natural (div a b)
-  {-# INLINE div #-}
-  mod (Natural a) (Natural b) = Natural (mod a b)
-  {-# INLINE mod #-}
-  divMod (Natural a) (Natural b) = (Natural q, Natural r) where (q,r) = divMod a b
-  {-# INLINE divMod #-}
-  quotRem (Natural a) (Natural b) = (Natural q, Natural r) where (q,r) = quotRem a b
-  {-# INLINE quotRem #-}
-  toInteger = runNatural
-  {-# INLINE toInteger #-}
-
--- | A refinement of 'Integral' to represent types that do not contain negative numbers.
-class Integral n => Whole n where
-  toNatural :: n -> Natural
-  unsafePred :: n -> n
-
-instance Whole Word where
-  toNatural = Natural . toInteger
-  unsafePred n = n - 1
-  {-# INLINE toNatural #-}
-  {-# INLINE unsafePred #-}
-
-instance Whole Word8 where
-  toNatural = Natural . toInteger
-  unsafePred n = n - 1
-  {-# INLINE toNatural #-}
-  {-# INLINE unsafePred #-}
-
-instance Whole Word16 where
-  toNatural = Natural . toInteger
-  unsafePred n = n - 1
-  {-# INLINE toNatural #-}
-  {-# INLINE unsafePred #-}
-
-instance Whole Word32 where
-  toNatural = Natural . toInteger
-  unsafePred n = n - 1
-  {-# INLINE toNatural #-}
-  {-# INLINE unsafePred #-}
-
-instance Whole Word64 where
-  toNatural = Natural . toInteger
-  unsafePred n = n - 1
-  {-# INLINE toNatural #-}
-  {-# INLINE unsafePred #-}
-
-instance Whole Natural where
-  toNatural = id
-  unsafePred (Natural n) = Natural (n - 1)
-  {-# INLINE toNatural #-}
-  {-# INLINE unsafePred #-}