diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,6 +1,12 @@
 # ChangeLog / ReleaseNotes
 
 
+## Version 0.2.0.0
+
+* Instances for `Integer` and `Natural`.
+* Build on GHC 8.2.2 and Stackage LTS 10.\*.
+
+
 ## Version 0.1.0.1
 
 * Removed dead code. (**minor change**)
diff --git a/LICENSE b/LICENSE
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2015-2016, Peter Trško
+Copyright (c) 2015-2016, 2018 Peter Trško
 
 All rights reserved.
 
diff --git a/number-length.cabal b/number-length.cabal
--- a/number-length.cabal
+++ b/number-length.cabal
@@ -1,5 +1,5 @@
 name:                   number-length
-version:                0.1.0.1
+version:                0.2.0.0
 synopsis:
   Number of digits in a number in decimal and hexadecimal representation.
 description:
@@ -22,7 +22,7 @@
 license-file:           LICENSE
 author:                 Peter Trško
 maintainer:             peter.trsko@gmail.com
-copyright:              (c) 2015-2016, Peter Trško
+copyright:              (c) 2015-2016, 2018 Peter Trško
 category:               Data
 build-type:             Simple
 cabal-version:          >=1.10
@@ -39,6 +39,7 @@
   exposed-modules:
       Data.NumberLength
     , Data.NumberLength.Int
+    , Data.NumberLength.Integer
     , Data.NumberLength.Internal
     , Data.NumberLength.Word
   -- other-modules:
@@ -47,16 +48,26 @@
   other-extensions:     NoImplicitPrelude
 
   build-depends:        base >=4.5 && <5
-  if impl(ghc <7.8)
-    -- Data.Proxy was introduced in base ==4.7, which was bundled with GHC 7.8.
-    build-depends:      tagged >=0.6 && <0.9
 
-  ghc-options:          -Wall -fwarn-tabs
+  if impl(ghc >=7.10)
+    -- Module Numeric.Natural providing new Natural type representing
+    -- non-negative arbitrary-precision integers was introduced in base
+    -- 4.8.0.0, which was bundled with GHC 7.10.1.
+    cpp-options:        -DHAVE_NATURAL
+    exposed-modules:    Data.NumberLength.Natural
+
+  ghc-options:          -Wall
   if flag(pedantic)
-    ghc-options:
-      -fwarn-implicit-prelude
-      -fwarn-missing-import-lists
---    -Werror
+    if impl(ghc >8)
+      ghc-options:
+        -Wimplicit-prelude
+        -Wmissing-import-lists
+        -Werror
+    else
+      ghc-options:
+        -fwarn-implicit-prelude
+        -fwarn-missing-import-lists
+        -Werror
 
 test-suite unit-tests
   hs-source-dirs:       src, test
@@ -66,8 +77,15 @@
       TestCase
     , TestCase.Data.NumberLength
     , TestCase.Data.NumberLength.Int
+    , TestCase.Data.NumberLength.Integer
     , TestCase.Data.NumberLength.Word
 
+    , Data.NumberLength
+    , Data.NumberLength.Int
+    , Data.NumberLength.Integer
+    , Data.NumberLength.Internal
+    , Data.NumberLength.Word
+
   default-language:     Haskell2010
   other-extensions:     DefaultSignatures, NoImplicitPrelude
 
@@ -76,6 +94,15 @@
     -- Data.Proxy was introduced in base ==4.7, which was bundled with GHC 7.8.
     build-depends:      tagged >=0.6 && <0.9
 
+  if impl(ghc >=7.10)
+    -- Module Numeric.Natural providing new Natural type representing
+    -- non-negative arbitrary-precision integers was introduced in base
+    -- 4.8.0.0, which was bundled with GHC 7.10.1.
+    cpp-options:        -DHAVE_NATURAL
+    other-modules:
+        TestCase.Data.NumberLength.Natural
+      , Data.NumberLength.Natural
+
   build-depends:
       base >=4.5 && <5
   -- }}} Dependencies of the library ------------------------------------------
@@ -83,7 +110,7 @@
   -- {{{ Test-suite dependencies ----------------------------------------------
     , HUnit >=1.2 && <2
       -- ^ Same constraints as test-framework-hunit
-    , QuickCheck >=2.6 && <2.9
+    , QuickCheck >=2.6 && <3
       -- ^ Same constraints as test-framework-quickcheck2==0.3.0.3.
     , test-framework >=0.8 && <1
       -- ^ Same constraint as test-framework-skip, other packages that
@@ -95,26 +122,40 @@
       -- on it had a compilation failure on Hackage.
   -- }}} Test-suite dependencies ----------------------------------------------
 
-  ghc-options:          -Wall -fwarn-tabs
+  ghc-options:          -Wall
   if flag(pedantic)
-    ghc-options:
-      -fwarn-implicit-prelude
-      -fwarn-missing-import-lists
---    -Werror
+    if impl(ghc >8)
+      ghc-options:
+        -Wimplicit-prelude
+        -Wmissing-import-lists
+        -Werror
+    else
+      ghc-options:
+        -fwarn-implicit-prelude
+        -fwarn-missing-import-lists
+        -Werror
 
 benchmark benchmark
   hs-source-dirs:       src, test
   type:                 exitcode-stdio-1.0
   main-is:              benchmark.hs
---other-modules:
+  other-modules:
+      Data.NumberLength.Int
+    , Data.NumberLength.Internal
+    , Data.NumberLength.Integer
+    , Data.NumberLength.Natural
+    , Data.NumberLength.Word
 
   default-language:     Haskell2010
   other-extensions:     NoImplicitPrelude
 
   -- {{{ Dependencies of the library ------------------------------------------
-  if impl(ghc <7.8)
-    -- Data.Proxy was introduced in base ==4.7, which was bundled with GHC 7.8.
-    build-depends:      tagged >=0.6 && <0.9
+  if impl(ghc >=7.10)
+    -- Module Numeric.Natural providing new Natural type representing
+    -- non-negative arbitrary-precision integers was introduced in base
+    -- 4.8.0.0, which was bundled with GHC 7.10.1.
+    cpp-options:        -DHAVE_NATURAL
+    other-modules:      Data.NumberLength.Natural
 
   build-depends:
       base >=4.5 && <5
@@ -123,12 +164,18 @@
     , criterion >=1.0.0.0 && <2
     , number-length
 
-  ghc-options:          -Wall -fwarn-tabs
+  ghc-options:          -Wall
   if flag(pedantic)
-    ghc-options:
-      -fwarn-implicit-prelude
-      -fwarn-missing-import-lists
---    -Werror
+    if impl(ghc >8)
+      ghc-options:
+        -Wimplicit-prelude
+        -Wmissing-import-lists
+        -Werror
+    else
+      ghc-options:
+        -fwarn-implicit-prelude
+        -fwarn-missing-import-lists
+        -Werror
 
 source-repository head
   type:                 git
@@ -137,4 +184,4 @@
 source-repository this
   type:                 git
   location:             git://github.com/trskop/number-length.git
-  tag:                  v0.1.0.1
+  tag:                  v0.2.0.0
diff --git a/src/Data/NumberLength.hs b/src/Data/NumberLength.hs
--- a/src/Data/NumberLength.hs
+++ b/src/Data/NumberLength.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE CPP #-}
 {-# LANGUAGE DefaultSignatures #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 -- |
@@ -20,12 +21,14 @@
     )
   where
 
-import Prelude(Num((+)), fromIntegral)
+import Prelude(Integer, Num((+)), fromIntegral)
 
 import Data.Int (Int, Int16, Int32, Int64, Int8)
 import Data.Ord (Ord((<)))
-import Data.Proxy (Proxy)
 import Data.Word (Word, Word16, Word32, Word64, Word8)
+#ifdef HAVE_NATURAL
+import Numeric.Natural (Natural)
+#endif
 
 import Data.NumberLength.Int
     ( lengthInt
@@ -39,7 +42,11 @@
     , lengthInt8hex
     , lengthIntHex
     )
+import Data.NumberLength.Integer (lengthInteger, lengthIntegerHex)
 import Data.NumberLength.Internal (either32or64)
+#ifdef HAVE_NATURAL
+import Data.NumberLength.Natural (lengthNatural, lengthNaturalHex)
+#endif
 import Data.NumberLength.Word
     ( lengthWord
     , lengthWord16
@@ -134,10 +141,10 @@
 -- it.
 class NumberLength a => BoundedNumberLength a where
     -- | Get maximum number of digits of a number in base 10.
-    maxNumberLength :: Proxy a -> Int
+    maxNumberLength :: proxy a -> Int
 
     -- | Get maximum number of digits of a number in base 16.
-    maxNumberLengthHex :: Proxy a -> Int
+    maxNumberLengthHex :: proxy a -> Int
 
 -- {{{ Int* -------------------------------------------------------------------
 
@@ -240,3 +247,15 @@
     maxNumberLengthHex _ = 2
 
 -- }}} Word* ------------------------------------------------------------------
+
+-- | /Since 0.2.0.0/
+instance NumberLength Integer where
+    numberLength = lengthInteger
+    numberLengthHex = lengthIntegerHex
+
+#ifdef HAVE_NATURAL
+-- | /Since 0.2.0.0/
+instance NumberLength Natural where
+    numberLength = lengthNatural
+    numberLengthHex = lengthNaturalHex
+#endif
diff --git a/src/Data/NumberLength/Integer.hs b/src/Data/NumberLength/Integer.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/NumberLength/Integer.hs
@@ -0,0 +1,84 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+-- |
+-- Module:       $HEADER$
+-- Description:  Get number of digits of an Integer.
+-- Copyright:    (c) 2016, Peter Trško
+-- License:      BSD3
+--
+-- Stability:    experimental
+-- Portability:  NoImplicitPrelude
+--
+-- Get number of digits of an 'Integer'.
+--
+-- /Since 0.2.0.0/
+module Data.NumberLength.Integer
+    (
+    -- * Decimal (base 10)
+      lengthInteger
+
+    -- * Hexadecimal (base 16)
+    , lengthIntegerHex
+    )
+  where
+
+import Prelude
+    ( Bounded(maxBound)
+    , Integer
+    , Integral(quot)
+    , Num((+), fromInteger, negate)
+    , (^)
+    , fromIntegral
+    )
+
+import Data.Bool (otherwise)
+import Data.Eq (Eq((==)))
+import Data.Int (Int)
+import Data.Ord (Ord((<)))
+
+import Data.NumberLength.Int (lengthInt, lengthIntHex)
+import Data.NumberLength.Internal (either32or64)
+
+
+-- | Number of digits in a @number :: 'Integer'@ in base 10.
+--
+-- /Since 0.2.0.0/
+lengthInteger :: Integer -> Int
+lengthInteger n
+  | n < 0     = go (negate (fromIntegral n))
+  | otherwise = go (fromIntegral n)
+  where
+    go :: Integer -> Int
+    go m
+      | m < maxInt = lengthInt (fromInteger m)
+      | otherwise  =
+        let r = m `quot` (10 ^ maxIntDigits)
+        in maxIntDigits + if r == 0 then 0 else lengthInteger r
+
+    maxIntDigits :: Int
+    maxIntDigits = 10 `either32or64` 19
+{-# INLINE lengthInteger #-}
+
+-- | Number of digits in a @number :: 'Integer'@ in base 16.
+--
+-- /Since 0.2.0.0/
+lengthIntegerHex :: Integer -> Int
+lengthIntegerHex n
+  | n < 0     = go (negate n)
+  | otherwise = go n
+  where
+    go :: Integer -> Int
+    go m
+      | m < maxInt = lengthIntHex (fromInteger m)
+      | otherwise  =
+        let r = m `quot` (16 ^ maxIntDigits)
+        in maxIntDigits + if r == 0 then 0 else lengthIntegerHex r
+
+    maxIntDigits :: Int
+    maxIntDigits = 8 `either32or64` 16
+{-# INLINE lengthIntegerHex #-}
+
+-- | Maximum value of type 'Int' cast in to 'Integral'.
+--
+-- /Do not export this function!/
+maxInt :: Integer
+maxInt = fromIntegral (maxBound :: Int)
diff --git a/src/Data/NumberLength/Natural.hs b/src/Data/NumberLength/Natural.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/NumberLength/Natural.hs
@@ -0,0 +1,75 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+-- |
+-- Module:       $HEADER$
+-- Description:  Get number of digits of a Natural.
+-- Copyright:    (c) 2016, Peter Trško
+-- License:      BSD3
+--
+-- Stability:    experimental
+-- Portability:  NoImplicitPrelude
+--
+-- Get number of digits of a 'Natural'.
+--
+-- /Since 0.2.0.0/
+module Data.NumberLength.Natural
+    (
+    -- * Decimal (base 10)
+      lengthNatural
+
+    -- * Hexadecimal (base 16)
+    , lengthNaturalHex
+    )
+  where
+
+import Prelude
+    ( Bounded(maxBound)
+    , Integral(quot)
+    , Num((+))
+    , (^)
+    , fromIntegral
+    )
+
+import Data.Bool (otherwise)
+import Data.Eq (Eq((==)))
+import Data.Int (Int)
+import Data.Ord (Ord((<)))
+import Data.Word (Word)
+import Numeric.Natural (Natural)
+
+import Data.NumberLength.Internal (either32or64)
+import Data.NumberLength.Word (lengthWord, lengthWordHex)
+
+
+-- | Number of digits in a @number :: 'Natural'@ in base 10.
+--
+-- /Since 0.2.0.0/
+lengthNatural :: Natural -> Int
+lengthNatural n
+  | n < maxWord = lengthWord (fromIntegral n)
+  | otherwise   =
+    let r = n `quot` (10 ^ maxWordDigits)
+    in maxWordDigits + if r == 0 then 0 else lengthNatural r
+  where
+    maxWordDigits :: Int
+    maxWordDigits = 10 `either32or64` 20
+{-# INLINE lengthNatural #-}
+
+-- | Number of digits in a @number :: 'Natural'@ in base 16.
+--
+-- /Since 0.2.0.0/
+lengthNaturalHex :: Natural -> Int
+lengthNaturalHex n
+  | n < maxWord = lengthWordHex (fromIntegral n)
+  | otherwise   =
+    let r = n `quot` (16 ^ maxWordDigits)
+    in maxWordDigits + if r == 0 then 0 else lengthNaturalHex r
+  where
+    maxWordDigits :: Int
+    maxWordDigits = 8 `either32or64` 16
+{-# INLINE lengthNaturalHex #-}
+
+-- | Maximum value of type 'Word' cast in to 'Natural'.
+--
+-- /Do not export this function!/
+maxWord :: Natural
+maxWord = fromIntegral (maxBound :: Word)
diff --git a/test/TestCase.hs b/test/TestCase.hs
--- a/test/TestCase.hs
+++ b/test/TestCase.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE CPP #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 -- |
 -- Module:       $HEADER$
@@ -14,14 +15,23 @@
 
 import Test.Framework (Test, testGroup)
 
-import qualified TestCase.Data.NumberLength.Int as NumberLength.Int (tests)
 import qualified TestCase.Data.NumberLength as NumberLength (tests)
-import qualified TestCase.Data.NumberLength.Word as NumberLength.Word (tests)
+import qualified TestCase.Data.NumberLength.Int as Int (tests)
+import qualified TestCase.Data.NumberLength.Integer as Integer (tests)
+import qualified TestCase.Data.NumberLength.Word as Word (tests)
 
+#ifdef HAVE_NATURAL
+import qualified TestCase.Data.NumberLength.Natural as Natural (tests)
+#endif
 
+
 tests :: [Test]
 tests =
-    [ testGroup "Data.NumberLength.Int" NumberLength.Int.tests
-    , testGroup "Data.NumberLength.Word" NumberLength.Word.tests
+    [ testGroup "Data.NumberLength.Int" Int.tests
+    , testGroup "Data.NumberLength.Word" Word.tests
+    , testGroup "Data.NumberLength.Integer" Integer.tests
+#ifdef HAVE_NATURAL
+    , testGroup "Data.NumberLength.Natural" Natural.tests
+#endif
     , testGroup "Data.NumberLength" NumberLength.tests
     ]
diff --git a/test/TestCase/Data/NumberLength.hs b/test/TestCase/Data/NumberLength.hs
--- a/test/TestCase/Data/NumberLength.hs
+++ b/test/TestCase/Data/NumberLength.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE CPP #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 -- |
 -- Module:       $HEADER$
@@ -46,6 +47,16 @@
     , lengthInt8hex
     , lengthIntHex
     )
+import Data.NumberLength.Integer
+    ( lengthInteger
+    , lengthIntegerHex
+    )
+#ifdef HAVE_NATURAL
+import Data.NumberLength.Natural
+    ( lengthNatural
+    , lengthNaturalHex
+    )
+#endif
 import Data.NumberLength.Word
     ( lengthWord
     , lengthWord16
@@ -64,29 +75,37 @@
 tests =
     [ testGroup "class NumberLength"
         [ testGroup "numberLengthHex"
-            [ testProperty "Int"    $ numberLength <==> lengthInt
-            , testProperty "Int8"   $ numberLength <==> lengthInt8
-            , testProperty "Int16"  $ numberLength <==> lengthInt16
-            , testProperty "Int32"  $ numberLength <==> lengthInt32
-            , testProperty "Int64"  $ numberLength <==> lengthInt64
-            , testProperty "Word"   $ numberLength <==> lengthWord
-            , testProperty "Word8"  $ numberLength <==> lengthWord8
-            , testProperty "Word16" $ numberLength <==> lengthWord16
-            , testProperty "Word32" $ numberLength <==> lengthWord32
-            , testProperty "Word64" $ numberLength <==> lengthWord64
+            [ testProperty "Int"     $ numberLength <==> lengthInt
+            , testProperty "Int8"    $ numberLength <==> lengthInt8
+            , testProperty "Int16"   $ numberLength <==> lengthInt16
+            , testProperty "Int32"   $ numberLength <==> lengthInt32
+            , testProperty "Int64"   $ numberLength <==> lengthInt64
+            , testProperty "Word"    $ numberLength <==> lengthWord
+            , testProperty "Word8"   $ numberLength <==> lengthWord8
+            , testProperty "Word16"  $ numberLength <==> lengthWord16
+            , testProperty "Word32"  $ numberLength <==> lengthWord32
+            , testProperty "Word64"  $ numberLength <==> lengthWord64
+            , testProperty "Integer" $ numberLength <==> lengthInteger
+#ifdef HAVE_NATURAL
+            , testProperty "Natural" $ numberLength <==> lengthNatural
+#endif
             ]
 
         , testGroup "numberLengthHex"
-            [ testProperty "Int"    $ numberLengthHex <==> lengthIntHex
-            , testProperty "Int8"   $ numberLengthHex <==> lengthInt8hex
-            , testProperty "Int16"  $ numberLengthHex <==> lengthInt16hex
-            , testProperty "Int32"  $ numberLengthHex <==> lengthInt32hex
-            , testProperty "Int64"  $ numberLengthHex <==> lengthInt64hex
-            , testProperty "Word"   $ numberLengthHex <==> lengthWordHex
-            , testProperty "Word8"  $ numberLengthHex <==> lengthWord8hex
-            , testProperty "Word16" $ numberLengthHex <==> lengthWord16hex
-            , testProperty "Word32" $ numberLengthHex <==> lengthWord32hex
-            , testProperty "Word64" $ numberLengthHex <==> lengthWord64hex
+            [ testProperty "Int"     $ numberLengthHex <==> lengthIntHex
+            , testProperty "Int8"    $ numberLengthHex <==> lengthInt8hex
+            , testProperty "Int16"   $ numberLengthHex <==> lengthInt16hex
+            , testProperty "Int32"   $ numberLengthHex <==> lengthInt32hex
+            , testProperty "Int64"   $ numberLengthHex <==> lengthInt64hex
+            , testProperty "Word"    $ numberLengthHex <==> lengthWordHex
+            , testProperty "Word8"   $ numberLengthHex <==> lengthWord8hex
+            , testProperty "Word16"  $ numberLengthHex <==> lengthWord16hex
+            , testProperty "Word32"  $ numberLengthHex <==> lengthWord32hex
+            , testProperty "Word64"  $ numberLengthHex <==> lengthWord64hex
+            , testProperty "Integer" $ numberLengthHex <==> lengthIntegerHex
+#ifdef HAVE_NATURAL
+            , testProperty "Natural" $ numberLengthHex <==> lengthNaturalHex
+#endif
             ]
         ]
 
diff --git a/test/TestCase/Data/NumberLength/Integer.hs b/test/TestCase/Data/NumberLength/Integer.hs
new file mode 100644
--- /dev/null
+++ b/test/TestCase/Data/NumberLength/Integer.hs
@@ -0,0 +1,102 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+-- |
+-- Module:       $HEADER$
+-- Description:  TODO
+-- Copyright:    (c) 2015-2016, Peter Trško
+-- License:      BSD3
+--
+-- Stability:    experimental
+-- Portability:  NoImplicitPrelude
+module TestCase.Data.NumberLength.Integer (tests)
+  where
+
+import Prelude
+    ( Bounded(maxBound, minBound)
+    , Integer
+    , Num((-), (*), negate)
+    , fromIntegral
+    , (^)
+    )
+
+import Control.Applicative (liftA2)
+import Data.Bool (Bool, otherwise)
+import Data.Eq (Eq((==)))
+import Data.Function ((.), ($))
+import Data.Int (Int, Int64)
+import qualified Data.List as List (dropWhile, length)
+import Data.Ord (Ord((<)))
+import Data.String (String)
+import Data.Word (Word64)
+import Text.Printf (printf)
+import Text.Show (Show(show))
+
+import Test.Framework (Test)
+import Test.Framework.Providers.HUnit (testCase)
+import Test.Framework.Providers.QuickCheck2 (testProperty)
+import Test.HUnit (Assertion, (@?=))
+
+import Data.NumberLength.Integer
+    ( lengthInteger
+    , lengthIntegerHex
+    )
+
+
+tests :: [Test]
+tests =
+    [ testCase "lengthInteger minInt64" $ test_lengthInteger minInt64
+    , testCase "lengthInteger maxInt64" $ test_lengthInteger maxInt64
+    , testCase "lengthInteger minWord64" $ test_lengthInteger minWord64
+    , testCase "lengthInteger maxWord64" $ test_lengthInteger maxWord64
+    , testCase "lengthInteger (maxWord64 * 2)"
+        $ test_lengthInteger (maxWord64 * 2)
+    , testCase "lengthInteger (10 ^ maxWordDigits32 - 1)"
+        $ test_lengthInteger (10 ^ maxWordDigits32 - 1)
+    , testCase "lengthInteger (10 ^ maxWordDigits64 - 1)"
+        $ test_lengthInteger (10 ^ maxWordDigits64 - 1)
+    , testProperty "lengthInteger = length . show" property_lengthInteger
+
+    , testCase "lengthIntegerHex minInt64" $ test_lengthIntegerHex minInt64
+    , testCase "lengthIntegerHex maxInt64" $ test_lengthIntegerHex maxInt64
+    , testCase "lengthIntegerHex minWord64" $ test_lengthIntegerHex minWord64
+    , testCase "lengthIntegerHex maxWord64" $ test_lengthIntegerHex maxWord64
+    , testCase "lengthIntegerHex (maxWord64 * 2)"
+        $ test_lengthIntegerHex (maxWord64 * 2)
+    , testCase "lengthIntegerHex (10 ^ maxWordDigits32hex - 1)"
+        $ test_lengthIntegerHex (16 ^ maxWordDigits32hex - 1)
+    , testCase "lengthIntegerHex (10 ^ maxWordDigits64hex - 1)"
+        $ test_lengthIntegerHex (16 ^ maxWordDigits64hex - 1)
+    , testProperty "lengthIntegerHex = length . show" property_lengthIntegerHex
+    ]
+  where
+    minInt64 = fromIntegral (minBound :: Int64)
+    maxInt64 = fromIntegral (maxBound :: Int64)
+    minWord64 = fromIntegral (minBound :: Word64)
+    maxWord64 = fromIntegral (maxBound :: Word64)
+    maxWordDigits32 = 10 :: Int
+    maxWordDigits64 = 20 :: Int
+    maxWordDigits32hex = 8 :: Int
+    maxWordDigits64hex = 16 :: Int
+
+numberLengthDec :: Integer -> Int
+numberLengthDec = List.length . List.dropWhile (== '-') . show
+
+numberLengthHex :: Integer -> Int
+numberLengthHex n
+  | n < 0     = numberLengthHex' $ negate n
+  | otherwise = numberLengthHex' n
+  where
+    numberLengthHex' :: Integer -> Int
+    numberLengthHex' m = List.length (printf "%x" m :: String)
+
+(<==>) :: Eq b => (a -> b) -> (a -> b) -> a -> Bool
+(<==>) = liftA2 (==)
+
+test_lengthInteger, test_lengthIntegerHex :: Integer -> Assertion
+test_lengthInteger n = lengthInteger n @?= numberLengthDec n
+test_lengthIntegerHex n = lengthIntegerHex n @?= numberLengthHex n
+
+property_lengthInteger :: Integer -> Bool
+property_lengthInteger = lengthInteger <==> numberLengthDec
+
+property_lengthIntegerHex :: Integer -> Bool
+property_lengthIntegerHex = lengthIntegerHex <==> numberLengthHex
diff --git a/test/TestCase/Data/NumberLength/Natural.hs b/test/TestCase/Data/NumberLength/Natural.hs
new file mode 100644
--- /dev/null
+++ b/test/TestCase/Data/NumberLength/Natural.hs
@@ -0,0 +1,88 @@
+{-# LANGUAGE NoImplicitPrelude #-}
+-- |
+-- Module:       $HEADER$
+-- Description:  TODO
+-- Copyright:    (c) 2015-2016, Peter Trško
+-- License:      BSD3
+--
+-- Stability:    experimental
+-- Portability:  NoImplicitPrelude
+module TestCase.Data.NumberLength.Natural (tests)
+  where
+
+import Prelude
+    ( Bounded(maxBound)
+    , Num((-), (*))
+    , fromIntegral
+    , (^)
+    )
+
+import Control.Applicative (liftA2)
+import Data.Bool (Bool)
+import Data.Eq (Eq((==)))
+import Data.Function ((.), ($))
+import Data.Int (Int, Int64)
+import qualified Data.List as List (length)
+import Data.String (String)
+import Data.Word (Word64)
+import Numeric.Natural (Natural)
+import Text.Printf (printf)
+import Text.Show (Show(show))
+
+import Test.Framework (Test)
+import Test.Framework.Providers.HUnit (testCase)
+import Test.Framework.Providers.QuickCheck2 (testProperty)
+import Test.HUnit (Assertion, (@?=))
+
+import Data.NumberLength.Natural
+    ( lengthNatural
+    , lengthNaturalHex
+    )
+
+
+tests :: [Test]
+tests =
+    [ testCase "lengthNatural maxInt64" $ test_lengthNatural maxInt64
+    , testCase "lengthNatural maxWord64" $ test_lengthNatural maxWord64
+    , testCase "lengthNatural (maxWord64 * 2)"
+        $ test_lengthNatural (maxWord64 * 2)
+    , testCase "lengthNatural (10 ^ maxWordDigits32 - 1)"
+        $ test_lengthNatural (10 ^ maxWordDigits32 - 1)
+    , testCase "lengthNatural (10 ^ maxWordDigits64 - 1)"
+        $ test_lengthNatural (10 ^ maxWordDigits64 - 1)
+    , testProperty "lengthNatural = length . show" property_lengthNatural
+
+    , testCase "lengthNaturalHex maxInt64" $ test_lengthNaturalHex maxInt64
+    , testCase "lengthNaturalHex maxWord64" $ test_lengthNaturalHex maxWord64
+    , testCase "lengthNaturalHex (maxWord64 * 2)"
+        $ test_lengthNaturalHex (maxWord64 * 2)
+    , testCase "lengthNaturalHex (10 ^ maxWordDigits32hex - 1)"
+        $ test_lengthNaturalHex (16 ^ maxWordDigits32hex - 1)
+    , testCase "lengthNaturalHex (10 ^ maxWordDigits64hex - 1)"
+        $ test_lengthNaturalHex (16 ^ maxWordDigits64hex - 1)
+    , testProperty "lengthNaturalHex = length . show" property_lengthNaturalHex
+    ]
+  where
+    maxInt64 = fromIntegral (maxBound :: Int64)
+    maxWord64 = fromIntegral (maxBound :: Word64)
+    maxWordDigits32 = 10 :: Int
+    maxWordDigits64 = 20 :: Int
+    maxWordDigits32hex = 8 :: Int
+    maxWordDigits64hex = 16 :: Int
+
+numberLengthDec :: Natural -> Int
+numberLengthDec = List.length . show
+
+numberLengthHex :: Natural -> Int
+numberLengthHex n = List.length (printf "%x" n :: String)
+
+(<==>) :: Eq b => (a -> b) -> (a -> b) -> a -> Bool
+(<==>) = liftA2 (==)
+
+test_lengthNatural, test_lengthNaturalHex :: Natural -> Assertion
+test_lengthNatural n = lengthNatural n @?= numberLengthDec n
+test_lengthNaturalHex n = lengthNaturalHex n @?= numberLengthHex n
+
+property_lengthNatural, property_lengthNaturalHex :: Natural -> Bool
+property_lengthNatural = lengthNatural <==> numberLengthDec
+property_lengthNaturalHex = lengthNaturalHex <==> numberLengthHex
diff --git a/test/benchmark.hs b/test/benchmark.hs
--- a/test/benchmark.hs
+++ b/test/benchmark.hs
@@ -1,4 +1,6 @@
+{-# LANGUAGE CPP #-}
 {-# LANGUAGE NoImplicitPrelude #-}
+{-# LANGUAGE NoMonomorphismRestriction #-}
 -- |
 -- Module:       Main
 -- Description:  Benchmarks for low-level functions.
@@ -12,9 +14,11 @@
 module Main (main)
   where
 
-import Prelude (Bounded(minBound, maxBound))
+import Prelude (Bounded(minBound, maxBound), Num((*)), fromIntegral)
 
 import Data.Function (($))
+import Data.Int (Int64)
+import Data.Word (Word64)
 import System.IO (IO)
 
 import Criterion.Main (bench, defaultMain, nf)
@@ -31,6 +35,16 @@
     , lengthInt8hex
     , lengthIntHex
     )
+import Data.NumberLength.Integer
+    ( lengthInteger
+    , lengthIntegerHex
+    )
+#ifdef HAVE_NATURAL
+import Data.NumberLength.Natural
+    ( lengthNatural
+    , lengthNaturalHex
+    )
+#endif
 import Data.NumberLength.Word
     ( lengthWord
     , lengthWord16
@@ -88,6 +102,32 @@
     , bench "lengthInt64hex maxBound" $ nf lengthInt64hex maxBound
 
 
+    , bench "lengthInteger minInt64"           $ nf lengthInteger minInt64
+    , bench "lengthInteger 0"                  $ nf lengthInteger 0
+    , bench "lengthInteger maxInt64"           $ nf lengthInteger maxInt64
+    , bench "lengthInteger maxWord64"          $ nf lengthInteger maxWord64
+    , bench "lengthInteger (maxWord64 * 2)"    $ nf lengthInteger maxWord64x2
+
+    , bench "lengthIntegerHex minInt64"        $ nf lengthIntegerHex minInt64
+    , bench "lengthIntegerHex 0"               $ nf lengthIntegerHex 0
+    , bench "lengthIntegerHex minInt64"        $ nf lengthIntegerHex maxInt64
+    , bench "lengthIntegerHex maxWord64"       $ nf lengthIntegerHex maxWord64
+    , bench "lengthIntegerHex (maxWord64 * 2)" $ nf lengthIntegerHex maxWord64x2
+
+
+#ifdef HAVE_NATURAL
+    , bench "lengthNatural 0"                  $ nf lengthNatural 0
+    , bench "lengthNatural maxInt64"           $ nf lengthNatural maxInt64
+    , bench "lengthNatural maxWord64"          $ nf lengthNatural maxInt64
+    , bench "lengthNatural (maxWord64 * 2)"    $ nf lengthNatural maxWord64x2
+
+    , bench "lengthNaturalHex 0"               $ nf lengthNaturalHex 0
+    , bench "lengthNaturalHex minInt64"        $ nf lengthNaturalHex maxInt64
+    , bench "lengthNaturalHex maxWord64"       $ nf lengthNaturalHex maxWord64
+    , bench "lengthNaturalHex (maxWord64 * 2)" $ nf lengthNaturalHex maxWord64x2
+#endif
+
+
     , bench "lengthWord 0"        $ nf lengthWord 0
     , bench "lengthWord maxBound" $ nf lengthWord maxBound
 
@@ -118,3 +158,8 @@
     , bench "lengthWord64hex 0"        $ nf lengthWord64hex 0
     , bench "lengthWord64hex maxBound" $ nf lengthWord64hex maxBound
     ]
+  where
+    maxInt64 = fromIntegral (maxBound :: Int64)
+    minInt64 = fromIntegral (minBound :: Int64)
+    maxWord64 = fromIntegral (maxBound :: Word64)
+    maxWord64x2 = maxWord64 * 2