diff --git a/Text/HTML/TagSoup/Parsec.hs b/Text/HTML/TagSoup/Parsec.hs
--- a/Text/HTML/TagSoup/Parsec.hs
+++ b/Text/HTML/TagSoup/Parsec.hs
@@ -29,29 +29,31 @@
 import Text.ParserCombinators.Parsec.Pos
 import Text.HTML.TagSoup
 
+import Text.StringLike
+
 import Data.Maybe
 import Data.Char
 
 -- | A type represent the TagOpen, any inner tags , and the TagClose.
-type WholeTag =
-   ( Tag , [ Tag ] , Tag )
+type WholeTag str =
+   ( Tag str, [ Tag str] , Tag str)
 
 -- | The Tag parser, using Tag as the token.
-type TagParser =
-   GenParser Tag ( )
+type TagParser str =
+   GenParser (Tag str) ( )
 
 -- | A stateful tag parser
 -- This is a new type alias to allow backwards compatibility with old code.
-type TagParserSt =
-   GenParser Tag
+type TagParserSt str =
+   GenParser (Tag str)
 
 -- | Used to invoke parsing of Tags.
-tParse :: TagParser a -> [ Tag ] -> a
+tParse :: (StringLike str, Show str) => TagParser str a -> [ Tag str ] -> a
 tParse p ts =
    either ( error . show ) id $ parse p "tagsoup" ts
 
 -- | Simply run a stateful tag parser
-tStParse :: TagParserSt st a -> st -> [ Tag ] -> a
+tStParse :: (StringLike str, Show str) => TagParserSt str st a -> st -> [ Tag str ] -> a
 tStParse p state tos =
    either ( error . show ) id $ runParser p state "tagsoup" tos
       
@@ -65,17 +67,18 @@
              matcher
 
 -- make a string lowercase
+lowercase :: StringLike s => s -> s
 lowercase =
-   map toLower
+   fromString . map toLower . toString
 
 
 -- | openTag matches a TagOpen with the given name.  It is not case sensitive.
-openTag :: String -> TagParserSt st Tag
+openTag :: (StringLike str, Show str) => str -> TagParserSt str st (Tag str)
 openTag soughtName =
    openTagMatch soughtName ( Just ) $ \ _ -> Nothing
 
 -- | notOpenTag will match any tag which is not a TagOpen with the given name.  It is not case sensitive.
-notOpenTag :: String -> TagParserSt st Tag
+notOpenTag :: (StringLike str, Show str) => str -> TagParserSt str st (Tag str)
 notOpenTag avoidName =
    openTagMatch avoidName ( \ _ -> Nothing ) Just
 
@@ -109,7 +112,7 @@
 -- then all intervening tags,
 -- until it reaches a TagClose with the given name.
 -- It is not case sensitive.
-wholeTag :: String -> TagParserSt st WholeTag
+wholeTag :: (StringLike str, Show str) => str -> TagParserSt str st (WholeTag str)
 wholeTag soughtName = do
    open <- openTag soughtName
    ts <- many $ notCloseTag soughtName
@@ -117,51 +120,51 @@
    return ( open , ts , close )
 
 -- | closeTag matches a TagClose with the given name.  It is not case sensitive.
-closeTag :: String -> TagParserSt st Tag
+closeTag :: (StringLike str, Show str) => str -> TagParserSt str st (Tag str)
 closeTag soughtName =
    closeTagMatch soughtName ( Just ) $ \ _ -> Nothing
 
 -- | notCloseTag will match any tag which is not a TagClose with the given name.  It is not case sensitive.
-notCloseTag :: String -> TagParserSt st Tag
+notCloseTag :: (StringLike str, Show str) => str -> TagParserSt str st (Tag str)
 notCloseTag avoidName =
    closeTagMatch avoidName ( \ _ -> Nothing ) Just
 
 -- | maybeOpenTag will return `Just` the tag if it gets a TagOpen with he given name,
 -- It will return `Nothing` otherwise.
 -- It is not case sensitive.
-maybeOpenTag :: String -> TagParserSt st ( Maybe Tag )
+maybeOpenTag :: (StringLike str, Show str) => str -> TagParserSt str st ( Maybe (Tag str) )
 maybeOpenTag =
    maybeP . openTag
 
 -- | maybeCloseTag will return `Just` the tag if it gets a TagClose with he given name,
 -- It will return `Nothing` otherwise.
 -- It is not case sensitive.
-maybeCloseTag :: String -> TagParserSt st ( Maybe Tag )
+maybeCloseTag :: (StringLike str, Show str) => str -> TagParserSt str st ( Maybe (Tag str) )
 maybeCloseTag =
    maybeP . closeTag
 
 -- | maybeWholeTag will return `Just` the tag if it gets a WholeTag with he given name,
 -- It will return `Nothing` otherwise.
 -- It is not case sensitive.
-maybeWholeTag :: String -> TagParserSt st ( Maybe WholeTag )
+maybeWholeTag :: (StringLike str, Show str) => str -> TagParserSt str st ( Maybe (WholeTag str) )
 maybeWholeTag =
    maybeP . wholeTag
 
 -- | allOpenTags will return all TagOpen with the given name.
 -- It is not case sensitive.
-allOpenTags :: String -> TagParserSt st [ Tag ]
+allOpenTags :: (StringLike str, Show str) => str -> TagParserSt str st [ Tag str ]
 allOpenTags =
    allP . maybeOpenTag
 
 -- | allCloseTags will return all TagClose with the given name.
 -- It is not case sensitive.
-allCloseTags :: String -> TagParserSt st [ Tag ]
+allCloseTags :: (StringLike str, Show str) => str -> TagParserSt str st [ Tag str ]
 allCloseTags =
    allP . maybeCloseTag
 
 -- | allWholeTags will return all WholeTag with the given name.
 -- It is not case sensitive.
-allWholeTags :: String -> TagParserSt st [ WholeTag ]
+allWholeTags :: (StringLike str, Show str) => str -> TagParserSt str st [ WholeTag str ]
 allWholeTags =
    allP . maybeWholeTag
 
@@ -174,17 +177,17 @@
                   return $ Left t
              )
 -- | either a Right TagOpen or a Left arbitary tag.
-eitherOpenTag :: String -> TagParserSt st ( Either Tag Tag )
+eitherOpenTag :: (StringLike str, Show str) => str -> TagParserSt str st ( Either (Tag str) (Tag str) )
 eitherOpenTag = 
    eitherP . openTag
 
 -- | either a Right TagClose or a Left arbitary tag.
-eitherCloseTag :: String -> TagParserSt st ( Either Tag Tag )
+eitherCloseTag :: (StringLike str, Show str) => str -> TagParserSt str st ( Either (Tag str) (Tag str) )
 eitherCloseTag =
    eitherP . closeTag
 
 -- | either a Right WholeTag or a Left arbitary tag.
-eitherWholeTag :: String -> TagParserSt st ( Either Tag WholeTag )
+eitherWholeTag :: (StringLike str, Show str) => str -> TagParserSt str st ( Either (Tag str) (WholeTag str) )
 eitherWholeTag = 
    eitherP . wholeTag
 
diff --git a/tagsoup-parsec.cabal b/tagsoup-parsec.cabal
--- a/tagsoup-parsec.cabal
+++ b/tagsoup-parsec.cabal
@@ -1,10 +1,10 @@
 Name:           tagsoup-parsec 
-Version:        0.0.6
+Version:        0.0.7
 License:        BSD3 
 License-file:   LICENSE
 Author:         Johnny Morrice
 Maintainer:     spoon@killersmurf.com
-Homepage:       http://www.killersmurf.com/projects/tagsoup-parsec
+Homepage:       http://www.killersmurf.com
 Category:       XML 
 Synopsis:       Tokenizes Tag, so [ Tag ] can be used as parser input.
 Description:    Tokenizes Tag, so [ Tag ] can be used as parser input.  Provides