diff --git a/hw-succinct.cabal b/hw-succinct.cabal
--- a/hw-succinct.cabal
+++ b/hw-succinct.cabal
@@ -1,5 +1,5 @@
 name:                   hw-succinct
-version:                0.0.0.11
+version:                0.0.0.12
 synopsis:               Conduits for tokenizing streams.
 description:            Please see README.md
 homepage:               http://github.com/haskell-works/hw-succinct#readme
@@ -35,8 +35,7 @@
 
 library
   hs-source-dirs:       src
-  exposed-modules:      HaskellWorks.Data.Attoparsec.Final.Parser
-                      , HaskellWorks.Data.Json
+  exposed-modules:      HaskellWorks.Data.Json
                       , HaskellWorks.Data.Json.Succinct
                       , HaskellWorks.Data.Json.Succinct.Cursor
                       , HaskellWorks.Data.Json.Succinct.Cursor.BalancedParens
@@ -55,6 +54,7 @@
                       , conduit
                       , hw-bits
                       , hw-conduit
+                      , hw-parser
                       , hw-prim
                       , hw-rankselect
                       , mono-traversable
diff --git a/src/HaskellWorks/Data/Attoparsec/Final/Parser.hs b/src/HaskellWorks/Data/Attoparsec/Final/Parser.hs
deleted file mode 100644
--- a/src/HaskellWorks/Data/Attoparsec/Final/Parser.hs
+++ /dev/null
@@ -1,58 +0,0 @@
-module HaskellWorks.Data.Attoparsec.Final.Parser
-  ( Parser(..)
-  ) where
-
-import qualified Data.Attoparsec.ByteString                as ABS
-import qualified Data.Attoparsec.ByteString.Char8          as BC
-import qualified Data.Attoparsec.Text                      as AT
-import qualified Data.Attoparsec.Types                     as T
-import           Data.ByteString                           (ByteString)
-import           Data.MonoTraversable
-import           Data.Text                                 (Text)
-import           HaskellWorks.Data.Char.IsChar
-
-class MonoTraversable t => Parser t where
-  satisfy :: (Element t -> Bool) -> T.Parser t (Element t)
-  satisfyWith :: (Element t -> a) -> (a -> Bool) -> T.Parser t a
-  satisfyChar :: (Char -> Bool) -> T.Parser t Char
-  string :: t -> T.Parser t t
-  try :: T.Parser t a -> T.Parser t a
-  char :: Char -> T.Parser t Char
-  (<?>) :: T.Parser t Char -> String -> T.Parser t Char
-  rational :: Fractional f => T.Parser t f
-
-instance Parser ByteString where
-  satisfy = ABS.satisfy
-  satisfyWith = ABS.satisfyWith
-  satisfyChar = ABS.satisfyWith toChar
-  string = ABS.string
-  try = ABS.try
-  char = BC.char
-  (<?>) = (BC.<?>)
-  rational = BC.rational
-  {-# INLINABLE satisfy     #-}
-  {-# INLINABLE satisfyWith #-}
-  {-# INLINABLE satisfyChar #-}
-  {-# INLINABLE string      #-}
-  {-# INLINABLE try         #-}
-  {-# INLINABLE char        #-}
-  {-# INLINABLE (<?>)       #-}
-  {-# INLINABLE rational    #-}
-
-instance Parser Text where
-  satisfy = AT.satisfy
-  satisfyWith = AT.satisfyWith
-  satisfyChar = AT.satisfyWith toChar
-  string = AT.string
-  try = AT.try
-  char = AT.char
-  (<?>) = (AT.<?>)
-  rational = AT.rational
-  {-# INLINABLE satisfy     #-}
-  {-# INLINABLE satisfyWith #-}
-  {-# INLINABLE satisfyChar #-}
-  {-# INLINABLE string      #-}
-  {-# INLINABLE try         #-}
-  {-# INLINABLE char        #-}
-  {-# INLINABLE (<?>)       #-}
-  {-# INLINABLE rational    #-}
diff --git a/src/HaskellWorks/Data/Json/Token/Tokenize.hs b/src/HaskellWorks/Data/Json/Token/Tokenize.hs
--- a/src/HaskellWorks/Data/Json/Token/Tokenize.hs
+++ b/src/HaskellWorks/Data/Json/Token/Tokenize.hs
@@ -4,7 +4,6 @@
 module HaskellWorks.Data.Json.Token.Tokenize
     ( IsChar(..)
     , JsonToken(..)
-    , AFP.Parser(..)
     , parseJsonToken
     , parseJsonTokenString
     , escapedChar
@@ -12,38 +11,38 @@
 
 import           Control.Applicative
 import           Control.Monad
-import qualified Data.Attoparsec.ByteString.Char8          as BC
-import qualified Data.Attoparsec.Combinator                as AC
-import qualified Data.Attoparsec.Types                     as T
+import qualified Data.Attoparsec.ByteString.Char8   as BC
+import qualified Data.Attoparsec.Combinator         as AC
+import qualified Data.Attoparsec.Types              as T
 import           Data.Bits
 import           Data.Char
 import           Data.String
-import           HaskellWorks.Data.Attoparsec.Final.Parser as AFP
+import           HaskellWorks.Data.Parser           as P
 import           HaskellWorks.Data.Char.IsChar
 import           HaskellWorks.Data.Json.Token.Types
 
-hexDigitNumeric :: AFP.Parser t => T.Parser t Int
+hexDigitNumeric :: P.Parser t => T.Parser t Int
 hexDigitNumeric = do
   c <- satisfyChar (\c -> '0' <= c && c <= '9')
   return $ ord c - ord '0'
 
-hexDigitAlphaLower :: AFP.Parser t => T.Parser t Int
+hexDigitAlphaLower :: P.Parser t => T.Parser t Int
 hexDigitAlphaLower = do
   c <- satisfyChar (\c -> 'a' <= c && c <= 'z')
   return $ ord c - ord 'a' + 10
 
-hexDigitAlphaUpper :: AFP.Parser t => T.Parser t Int
+hexDigitAlphaUpper :: P.Parser t => T.Parser t Int
 hexDigitAlphaUpper = do
   c <- satisfyChar (\c -> 'A' <= c && c <= 'Z')
   return $ ord c - ord 'A' + 10
 
-hexDigit :: AFP.Parser t => T.Parser t Int
+hexDigit :: P.Parser t => T.Parser t Int
 hexDigit = hexDigitNumeric <|> hexDigitAlphaLower <|> hexDigitAlphaUpper
 
-verbatimChar :: AFP.Parser t => T.Parser t Char
+verbatimChar :: P.Parser t => T.Parser t Char
 verbatimChar  = satisfyChar (BC.notInClass "\"\\") <?> "invalid string character"
 
-escapedChar :: (IsString t, AFP.Parser t) => T.Parser t Char
+escapedChar :: (IsString t, P.Parser t) => T.Parser t Char
 escapedChar   = do
   _ <- string "\\"
   (   char '"'  >> return '"'  ) <|>
@@ -56,7 +55,7 @@
     ( char '\'' >> return '\'' ) <|>
     ( char '/'  >> return '/'  )
 
-escapedCode :: (IsString t, AFP.Parser t) => T.Parser t Char
+escapedCode :: (IsString t, P.Parser t) => T.Parser t Char
 escapedCode   = do
   _ <- string "\\u"
   a <- hexDigit
@@ -65,49 +64,49 @@
   d <- hexDigit
   return $ chr $ a `shift` 24 .|. b `shift` 16 .|. c `shift` 8 .|. d
 
-parseJsonTokenString :: (JsonTokenLike j, AFP.Parser t, Alternative (T.Parser t), IsString t) => T.Parser t j
+parseJsonTokenString :: (JsonTokenLike j, P.Parser t, Alternative (T.Parser t), IsString t) => T.Parser t j
 parseJsonTokenString = do
   _ <- string "\""
   value <- many (verbatimChar <|> escapedChar <|> escapedCode)
   _ <- string "\""
   return $ jsonTokenString value
 
-parseJsonTokenBraceL :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenBraceL :: (JsonTokenLike j, P.Parser t, IsString t) => T.Parser t j
 parseJsonTokenBraceL = string "{" >> return jsonTokenBraceL
 
-parseJsonTokenBraceR :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenBraceR :: (JsonTokenLike j, P.Parser t, IsString t) => T.Parser t j
 parseJsonTokenBraceR = string "}" >> return jsonTokenBraceR
 
-parseJsonTokenBracketL :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenBracketL :: (JsonTokenLike j, P.Parser t, IsString t) => T.Parser t j
 parseJsonTokenBracketL = string "[" >> return jsonTokenBracketL
 
-parseJsonTokenBracketR :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenBracketR :: (JsonTokenLike j, P.Parser t, IsString t) => T.Parser t j
 parseJsonTokenBracketR = string "]" >> return jsonTokenBracketR
 
-parseJsonTokenComma :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenComma :: (JsonTokenLike j, P.Parser t, IsString t) => T.Parser t j
 parseJsonTokenComma = string "," >> return jsonTokenComma
 
-parseJsonTokenColon :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenColon :: (JsonTokenLike j, P.Parser t, IsString t) => T.Parser t j
 parseJsonTokenColon = string ":" >> return jsonTokenColon
 
-parseJsonTokenWhitespace :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenWhitespace :: (JsonTokenLike j, P.Parser t, IsString t) => T.Parser t j
 parseJsonTokenWhitespace = do
   _ <- AC.many1' $ BC.choice [string " ", string "\t", string "\n", string "\r"]
   return jsonTokenWhitespace
 
-parseJsonTokenNull :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenNull :: (JsonTokenLike j, P.Parser t, IsString t) => T.Parser t j
 parseJsonTokenNull = string "null" >> return jsonTokenNull
 
-parseJsonTokenBoolean :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenBoolean :: (JsonTokenLike j, P.Parser t, IsString t) => T.Parser t j
 parseJsonTokenBoolean = true <|> false
   where
     true  = string "true"   >> return (jsonTokenBoolean True)
     false = string "false"  >> return (jsonTokenBoolean False)
 
-parseJsonTokenDouble :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonTokenDouble :: (JsonTokenLike j, P.Parser t, IsString t) => T.Parser t j
 parseJsonTokenDouble = liftM jsonTokenNumber rational
 
-parseJsonToken :: (JsonTokenLike j, AFP.Parser t, IsString t) => T.Parser t j
+parseJsonToken :: (JsonTokenLike j, P.Parser t, IsString t) => T.Parser t j
 parseJsonToken =
   parseJsonTokenString     <|>
   parseJsonTokenBraceL     <|>