diff --git a/Web/PathPieces.hs b/Web/PathPieces.hs
--- a/Web/PathPieces.hs
+++ b/Web/PathPieces.hs
@@ -1,8 +1,12 @@
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE TypeSynonymInstances #-}
+{-# LANGUAGE FlexibleInstances, TypeSynonymInstances  #-}
 module Web.PathPieces
-    ( SinglePiece (..)
-    , MultiPiece (..)
+    ( PathPiece (..)
+    , PathMultiPiece (..)
+    -- * Deprecated
+    , toSinglePiece
+    , toMultiPiece
+    , fromSinglePiece
+    , fromMultiPiece
     ) where
 
 import Data.Int (Int64)
@@ -10,46 +14,72 @@
 import qualified Data.Text.Lazy as L
 import qualified Data.Text.Read
 
-class SinglePiece s where
-    fromSinglePiece :: S.Text -> Maybe s
-    toSinglePiece :: s -> S.Text
-instance SinglePiece String where
-    fromSinglePiece s = if S.null s then Nothing else Just (S.unpack s)
-    toSinglePiece = S.pack
-instance SinglePiece S.Text where
-    fromSinglePiece s = if S.null s then Nothing else Just s
-    toSinglePiece = id
-instance SinglePiece L.Text where
-    fromSinglePiece s = if S.null s then Nothing else Just (L.fromChunks [s])
-    toSinglePiece = S.concat . L.toChunks
-instance SinglePiece Integer where
-    fromSinglePiece s =
+class PathPiece s where
+    fromPathPiece :: S.Text -> Maybe s
+    toPathPiece :: s -> S.Text
+
+instance PathPiece String where
+    fromPathPiece s = if S.null s then Nothing else Just (S.unpack s)
+    toPathPiece = S.pack
+
+instance PathPiece S.Text where
+    fromPathPiece s = if S.null s then Nothing else Just s
+    toPathPiece = id
+
+instance PathPiece L.Text where
+    fromPathPiece s = if S.null s then Nothing else Just (L.fromChunks [s])
+    toPathPiece = S.concat . L.toChunks
+
+instance PathPiece Integer where
+    fromPathPiece s =
         case Data.Text.Read.decimal s of
             Right (i, _) -> Just i
             Left _ -> Nothing
-    toSinglePiece = S.pack . show
-instance SinglePiece Int where
-    fromSinglePiece s =
+    toPathPiece = S.pack . show
+
+instance PathPiece Int where
+    fromPathPiece s =
         case Data.Text.Read.decimal s of
             Right (i, _) -> Just i
             Left _ -> Nothing
-    toSinglePiece = S.pack . show
-instance SinglePiece Int64 where
-    fromSinglePiece s =
+    toPathPiece = S.pack . show
+
+instance PathPiece Int64 where
+    fromPathPiece s =
         case Data.Text.Read.decimal s of
             Right (i, _) -> Just i
             Left _ -> Nothing
-    toSinglePiece = S.pack . show
+    toPathPiece = S.pack . show
 
-class MultiPiece s where
-    fromMultiPiece :: [S.Text] -> Maybe s
-    toMultiPiece :: s -> [S.Text]
-instance MultiPiece [String] where
-    fromMultiPiece = Just . map S.unpack
-    toMultiPiece = map S.pack
-instance MultiPiece [S.Text] where
-    fromMultiPiece = Just
-    toMultiPiece = id
-instance MultiPiece [L.Text] where
-    fromMultiPiece = Just . map (L.fromChunks . return)
-    toMultiPiece = map $ S.concat . L.toChunks
+
+class PathMultiPiece s where
+    fromPathMultiPiece :: [S.Text] -> Maybe s
+    toPathMultiPiece :: s -> [S.Text]
+
+instance PathMultiPiece [String] where
+    fromPathMultiPiece = Just . map S.unpack
+    toPathMultiPiece = map S.pack
+
+instance PathMultiPiece [S.Text] where
+    fromPathMultiPiece = Just
+    toPathMultiPiece = id
+
+instance PathMultiPiece [L.Text] where
+    fromPathMultiPiece = Just . map (L.fromChunks . return)
+    toPathMultiPiece = map $ S.concat . L.toChunks
+
+{-# DEPRECATED toSinglePiece "Use toPathPiece instead of toSinglePiece" #-}
+toSinglePiece :: PathPiece p => p -> S.Text
+toSinglePiece = toPathPiece
+
+{-# DEPRECATED fromSinglePiece "Use fromPathPiece instead of fromSinglePiece" #-}
+fromSinglePiece :: PathPiece p => S.Text -> Maybe p
+fromSinglePiece = fromPathPiece
+
+{-# DEPRECATED toMultiPiece "Use toPathMultiPiece instead of toMultiPiece" #-}
+toMultiPiece :: PathMultiPiece ps => ps -> [S.Text]
+toMultiPiece = toPathMultiPiece
+
+{-# DEPRECATED fromMultiPiece "Use fromPathMultiPiece instead of fromMultiPiece" #-}
+fromMultiPiece :: PathMultiPiece ps => [S.Text] -> Maybe ps
+fromMultiPiece = fromPathMultiPiece
diff --git a/path-pieces.cabal b/path-pieces.cabal
--- a/path-pieces.cabal
+++ b/path-pieces.cabal
@@ -1,5 +1,5 @@
 name:            path-pieces
-version:         0.0.0
+version:         0.1.0
 license:         BSD3
 license-file:    LICENSE
 author:          Michael Snoyman <michael@snoyman.com>
@@ -7,15 +7,29 @@
 synopsis:        Components of paths.
 category:        Web, Yesod
 stability:       unstable
-cabal-version:   >= 1.6
+cabal-version:   >= 1.8
 build-type:      Simple
 homepage:        http://github.com/snoyberg/path-pieces
+extra-source-files: test/main.hs
 
 library
     build-depends:   base             >= 4       && < 5
                    , text             >= 0.5     && < 0.12
     exposed-modules: Web.PathPieces
     ghc-options:     -Wall
+
+test-suite test
+    type:          exitcode-stdio-1.0
+    main-is:       main.hs
+    hs-source-dirs: test
+    ghc-options:   -Wall
+    build-depends:   HUnit
+                   , hspec >= 0.8 && < 0.9
+                   , file-location >= 0.4 && < 0.5
+                   , base >= 4 && < 5
+                   , QuickCheck == 2.4.*
+                   , path-pieces
+                   , text
 
 source-repository head
   type:     git
diff --git a/test/main.hs b/test/main.hs
new file mode 100644
--- /dev/null
+++ b/test/main.hs
@@ -0,0 +1,70 @@
+{-# Language ScopedTypeVariables #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+module Main where
+
+import Test.Hspec.Monadic (Specs, describe, hspecX)
+import Test.Hspec.HUnit()
+import Test.Hspec.QuickCheck(prop)
+import Test.QuickCheck
+
+import Web.PathPieces
+import qualified Data.Text as T
+import Data.Maybe (fromJust)
+
+-- import FileLocation (debug)
+
+instance Arbitrary T.Text where
+  arbitrary = fmap T.pack arbitrary
+
+
+main :: IO ()
+main = hspecX specs
+
+specs :: Specs
+specs = do
+  describe "RoutePiece" $ do
+    prop "toRoutePiece <=> fromSinglePiece String" $ \(p::String) ->
+      case (fromRoutePiece . toSinglePiece) p of
+        Nothing -> null p
+        Just pConverted -> p == pConverted
+
+    prop "toRoutePiece <=> fromSinglePiece String" $ \(p::T.Text) ->
+      case (fromRoutePiece . toSinglePiece) p of
+        Nothing -> T.null p
+        Just pConverted -> p == pConverted
+
+    prop "toRoutePiece <=> fromSinglePiece String" $ \(p::Int) ->
+      case (fromRoutePiece . toSinglePiece) p of
+        Nothing -> p < 0
+        Just pConverted -> p == pConverted
+
+  describe "RouteMultiPiece" $ do
+    prop "toRouteMultiPiece <=> fromMultiPiece String" $ \(p::[String]) ->
+      p == (fromJust . fromRouteMultiPiece . toMultiPiece) p
+
+    prop "toRouteMultiPiece <=> fromMultiPiece String" $ \(p::[T.Text]) ->
+      p == (fromJust . fromRouteMultiPiece . toMultiPiece) p
+
+
+  describe "SinglePiece" $ do
+    prop "toSinglePiece <=> fromSinglePiece String" $ \(p::String) ->
+      case (fromSinglePiece . toSinglePiece) p of
+        Nothing -> null p
+        Just pConverted -> p == pConverted
+
+    prop "toSinglePiece <=> fromSinglePiece String" $ \(p::T.Text) ->
+      case (fromSinglePiece . toSinglePiece) p of
+        Nothing -> T.null p
+        Just pConverted -> p == pConverted
+
+    prop "toSinglePiece <=> fromSinglePiece String" $ \(p::Int) ->
+      case (fromSinglePiece . toSinglePiece) p of
+        Nothing -> p < 0
+        Just pConverted -> p == pConverted
+
+  describe "MultiPiece" $ do
+    prop "toMultiPiece <=> fromMultiPiece String" $ \(p::[String]) ->
+      p == (fromJust . fromMultiPiece . toMultiPiece) p
+
+    prop "toMultiPiece <=> fromMultiPiece String" $ \(p::[T.Text]) ->
+      p == (fromJust . fromMultiPiece . toMultiPiece) p